Which are the build-in commands?

A shell built-in command is contained in the shell itself (implemented by shell author) and runs on the same shell without creating a new process, e.g. cd, pwd, exit, alias.

By contrast: For a regular(linux) command, it is run from a binary file (found in $PATH or specified file) by forking the existing process in a subshell, e.g. ls, cat, rm.

How to implement

1. Judge whether is build-in command

Assume we have already got the parsed arguments

char * parsedArgs[MAXPARSE].

For example, a input char * input = "cd .." can be parsed as char * parsedArgs[MAXPARSE] = {"cd", ".."}

Then, we just need to judge whether parsedArgs[0] is contained in our build-in command set {"exit", "cd", "pwd" ...} (by using strcmp)

2. Implementation

In this project (as of milestone 2) , we need to implement exit, pwd, cd.

exit

In Bash, exit is a built-in command used to terminate the current shell session (same in our mumsh).

Each running shell is a process, so we can use the exit() in stdlib.h to terminate the shell process, achieving the goal of exiting the shell.

1
2
3
4

void exec_exit(){
    printf("exit\n");
    exit(0); // 0 for exit normally, otherwise abnormally
}

pwd

Running a crude (or minimal?) shell and have no idea where you are? Just type pwd and it will print the name of the current/working directory.

In C, we can implement the similar functionality using the getcwd() in unistd.h.

if success, getcwd() will return the pointer to the result, else ( e.g. no enough space) return NULL

1
2
3
4

void exec_pwd(){
    char buf[1024]; // memory space need for storage
    printf("%s\n", getcwd(buf,sizeof(buf)));
}

However, the working directory is not guaranteed to be shorter than 1024, so we may need to dynamically allocate the buffer to suit the length.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int size = 100;
char *buffer = malloc(size);

while (getcwd(buffer, size) == NULL) {
    if (errno == ERANGE) {  // buffer too small
        size *= 2;
        buffer = realloc(buffer, size);
    } else {  // other error
        ...
        free(buffer);
        return 1;
    }
}

printf("%s\n", buffer);

free(buffer);

cd

cd is used for changing working directory.

In C, we can implement the similar functionality using the chdir() in unistd.h.

if success, chdir() will return 0, else ( e.g. no such directory) return -1

1
2
3

void exec_cd(char * path){
    chdir(path);
}

Very straight forward, but if we want to implement more advanced features of the cd command such as changing to the home directory or the previous directory, we would need to handle these cases manually.

For example, you could check if the argument is ~ or -, and then call chdir() with the appropriate path

Aircraft control policy

State Variable

Intuitive

• Aircraft
  • Rotation (in euler angle: x,y,z)
  • Position (In the world coordinate system:x,y,z)
  • Linear velocity (In the world coordinate system: x,y,z)
  • Angular velocity (In the world coordinate system: x,y,z)
  • Acceleration (In the world coordinate system:x,y,z)
• Carrier Vessel Landing Runway
  • Position
  • Rotation (fixed)
  • Velocity (fixed)

Extensive

• Aircraft
  • AoA (angle of attack 攻角)

Decision Variable

• Aircraft
  • Pitch angle (control aircraft’s rotation along x axis)
  • Roll angle (control aircraft’s rotation along z axis)
  • Yaw angle (control aircraft’s rotation along y axis)
  • Throttle (control thrust)

Level 1 (Basic) Policy

Only contain the control over control surface (on control over throttle)

Attitude Control/Maintainance

Pitch（俯仰角） C/M

Function: KeepPitch()

Control the angle of horizontal tail (elevator)

1. First keep the angle of elevator same with AoA(攻角), to avoid the disturbance of the horizontal tail on the attitide of the aircraft.

   1	aircraft.PitchAngle = aircraft.AoA;

   这里的aircraft.PitchAngle指的是飞机升降舵的角度(下片为正)

2. 根据当前俯仰角，俯仰速度，和目标俯仰角，调整升降舵面的角度

   1	aircraft.PitchAngle += 5 * (p - aircraft.Pitch) / Mathf.Exp(10 * aircraft.PitchSpeed * Mathf.Sign(p - aircraft.Pitch));

Other Attitude C/M

与俯仰角类似（分别控制滚转舵面以及偏航舵面），不过不需要第一步

Level 2 Policy

Velocity Direction Control/Maintainance

Gliding Angle (下滑角)

Control the thrust of aircraft to change the angle of gliding

1. 保持飞机的俯仰角不变(5度仰角)

   1	KeepPitch(5f);

2. 计算当前下滑角

   1	float velAngle = 90 - Vector3.Angle(aircraft.rb.velocity, Vector3.up);

3. 根据下滑角更改油门大小

   1	aircraft.Thrust += (p - velAngle)/500f;

Level 3 Policy

Follow Trajectory

Vertical Approaching (竖直平面上接近预定下滑道)

通过调整飞机的下滑角来使飞机在竖直面上接近并维持在理想的下滑道

1. 计算偏差对应的向量

   1	Vector3 approachDirection = Vector3.ProjectOnPlane(route.Destination - transform.position, route.direction);

2. 根据偏差值调整下滑角的大小（-3为目标下滑轨道的下滑角）

   1	ThrustKeepGliding(-3 + Mathf.Clamp(approachDirection.y / 10f, -5,5));

Horizontal Approaching (水平面上接近预定下滑道)

通过调整飞机的偏航舵面角度（进而影响飞机的y轴rotation）来使飞机在水平面上接近并维持在理想的航道上

1. 计算偏差对应的向量

   1 2 3 4 5 6 7 8 9 10 11

   Vector3 approachDirection = Vector3.ProjectOnPlane(route.Destination - transform.position, route.direction); float distance = 0; if (Vector3.Angle(approachDirection, transform.right) < 90) { distance = Vector3.ProjectOnPlane(approachDirection, Vector3.up).magnitude; } else { distance = -Vector3.ProjectOnPlane(approachDirection, Vector3.up).magnitude; }

2. 根据偏差值调整飞机的目标偏航角度（-8为目标下滑轨道的偏航角度）

   1	KeepYaw(-8 + Mathf.Clamp(distance / 10f, -50, 50));

Get the ideal trajectory（补充）

基本的策略以及阐述完毕，那么所谓的理想下滑道到底应该怎么得到呢？
理想下滑道是一个射线，包含一个终点（飞机着陆的终点）和一个方向（飞机接近的方向）

1
2
3
4
5

public class Target_Route
{
	public Vector3 Destination;
	public Vector3 direction;
}

理想航道的偏航角和下滑角已知（分别为-8（平行于着陆跑道）和-3）
通过迭代飞机着陆所需时间来求得下滑道终点的位置

1
2
3
4
5
6
7
8
9
10
11
12

route.Destination = CV.transform.position;
route.direction = new Vector3(-0.14f, -0.05f, 0.99f).normalized;
// 获取飞机速度在下滑道方向上投影的大小
float axialVel = Vector3.Dot(aircraft.rb.velocity, route.direction);

// calculate precise destination
float FlightTime = 0;
for (int i = 0; i < 10; i++)
{
	FlightTime = Vector3.Dot(route.Destination - aircraft.transform.position,route.direction) / axialVel;// 获取预计到达终点需要的时间
	route.Destination = CV.transform.position + 15 * FlightTime * Vector3.forward; // 其中15是航母的速度，Vector3.forward是航母前进方向
}

Autonomous Driving

• Autonomous Driving
  • Perception
  • Decision-making
    • Architecture
      • Pre-trip decisions
      • In-trip decisions
      • Post-trip decision
  • Speed tracking
    • Dynamic system
      • Open-loop control
      • Closed-loop control
        • Linear controller
    • LTI system
      • Control of LTI system
  • Speed tracking
  • Trajectory tracking
    • Control policy

Perception

• Navigation tool
• Camera
• Radar
• LiDAR
• Infrared detector
• Speedometer
• veh-veh communication
• veh-infrastructure communication

Decision-making

• departure time
• good route
• good lane
• driving style
• way to accel/decel
• make a turn
• park location

Architecture

• Pre-trip

  trip generation, modal choice, routine choice

• In-trip

  Path planning, Maneuver regulation

• Post-trip

  Parking

Pre-trip decisions

• Centralized

  central command center send instructions
  Some win, some lose

• Decentralized

  plan trip independently, selfish
  little communication
  Sometime efficient, sometime inefficient

In-trip decisions

• offline info

  static, in form of map

• online info

  enable the route to be adapted to changing traffic conditions

Post-trip decision

Speed tracking

Dynamic system

• State Variable

  $v[t]$

• State space

  $R>= 0$

• Control input

  $u[t]$(accel)

• System dynamic

  $v[t+dt] = v[t]+u[t]*dt$

Open-loop control

Specify the control input $u[t]$ for all t in $[0,T]$
not a good idea for autonomous driving.

In practice, we need to consider the uncertainty of the system.
We should have:
$$
v[t+dt]=v[t]+u[t]dt+w(t)
$$
Where w(t) is the noise term capturing the uncertainty of the system.

Closed-loop control

Specify the control input $u[t]$ as a function of the state $v[t]$
able to adapt to the uncertainty of the system.
Compare the state $v[t]$ with the desired state $v_desired[t]$
Essentially, we need a mapping from state to control input
like map speed to acceleration
$$
v[t+dt]=v[t]+mu[v[t]]dt+w(t)
$$

Linear controller

the $u[t]$ has linear relationship with $v[t]$
$$
\mu[v] = k[v-v_{desired}]
$$

LTI system

linear time-invariant

Control of LTI system

exponential convergence is stronger than asymptotic convergent
if LTI system is asymptotic convergent, it is also exponential convergent
$$
x[t+1]=ax[t]+bu[t]
$$

Speed tracking

• given:

  $v_{desired}, \delta$

• determine:

  $u[t]$ $t = 0,1,2$

• state

  $v[t]$
  $v[t+1] = v[t] + u[t]\delta + w[t]$

select $u[t]$ so that $w[t]$ will not accumulate

$u[t]=\mu(v[t]) = kv[t]$

$$
v[t+1] = f(v[t],u[t])
$$

Remember the review question

Trajectory tracking

Overview:

• track means asymptotic convergent

• $x[t]$ and $x_{desired}[t]$

• $\lim_{t\rightarrow\infty}|x[t]-x_{desired}[t] | = 0$

• state of system:$[x[t], v[t]]^T$

• if successful:
  $$
  [x[t], v[t]]^T \rightarrow [x_{desired}[t], v_{desired}[t]]^T
  $$

Control policy

• A control policy is a function
• This function maps a state to a control input
  $$
  u[t] = f(x[t],v[t])
  $$

$$
u[t] = -k_1(x[t]-x_{desired}[t])-k_2(v[t]-v_{desired}[t])
$$

$$
k_1,k_2>0
$$

TOEFL SPEECH

Practice

official 80 exercise

可供参考的资料

聊天记录：

• 《照明商店》
• 避开巨多人
• WOKKA 舒芙蕾店，点评
• 冰激凌店, 表
• 武康路

武康路

Trouble shooting

1. Pink material
   • Install Universal RP in package manager
   • Edit/Rendering/Materials/Convert…
   • or what about try this fork

Prefabs in Unity

A prefab is a template for a game object that can be reused across multiple scenes. Using prefabs can help build scenes faster because a prefab can be created and then reused across multiple scenes without having to recreate the same game object each time.

Creating Prefabs

To create a prefab, first create a game object in the Hierarchy window and add components and child game objects to it until it looks like the desired prefab. Then drag the game object from the Hierarchy window to the Assets folder in the Project window. This will turn the game object into a prefab that can be reused across multiple scenes.

An empty prefab can also be created by right-clicking in the Project window and selecting Create > Prefab, and then editing it in the Inspector window.

Instantiating Prefabs in Scripts

To instantiate an existing prefab in a script, first create a public variable in the script to reference the prefab, and then drag the prefab onto that variable in the Inspector window. For example:

1
2
3
4
5
6

public GameObject myPrefab;

void Start()
{
    Instantiate(myPrefab, new Vector3(0, 0, 0), Quaternion.identity);
}

The above code creates a public variable named myPrefab and uses the Instantiate method in the Start method to create an instance of the prefab. The prefab can be dragged onto the myPrefab variable in the Inspector window so that it is instantiated at runtime.

To instantiate a prefab from the Assets folder in a script, use the Resources.Load method to load the prefab and then use the Instantiate method to instantiate it. For example:

1
2
3
4
5

void Start()
{
    GameObject myPrefab = Resources.Load<GameObject>("MyPrefab");
    Instantiate(myPrefab, new Vector3(0, 0, 0), Quaternion.identity);
}

The above code uses the Resources.Load method to load a prefab named MyPrefab from the Resources folder in the Assets folder and then uses the Instantiate method to create an instance of the prefab.

Note: To use the Resources.Load method, the prefab must be located in a Resources folder within the Assets folder.

Vehicle Dynamics

WheelCollider

useful parameter
official

Stablizer Bar

Edy

• Task
• Vehicle Physics Pro
  • Needs
  • Install
• GLTFUtility
  • Needs
  • Install
  • Runtime API
  • Trouble shooting
• Csharp’s interpretation of Json
• Abstract the vehicle as a Json structure
  • Graph
  • Json example

Task

• Load car configuration from .json file
• Compose DevDocs
• Investigate csharp comment documentation
• use assimp to load .glb model

Vehicle Physics Pro

Starting point
The unity’s build-in physics engine PhysX is far from being precise enough for a vehicle simulator.

Needs

• Closer to reality vehicle physics
• Runtime performance
• Not so complicated to config so that the composition of the savings and editor will not be a headache

Official

Install

Through Asset Store

GLTFUtility

Starting point
The car model should be customizable, i.e. the user drag a car model into a directory and the game should be able to load it.
Filetype .glb is nice but unity doesn’t have build-in support

Needs

• Runtime import
• support mesh and material

GLTFUtility

Install

In tactics project:

1

git submodule add https://github.com/Siccity/GLTFUtility.git ./Tactics/Assets/ThirdParty/GLTFUtility

Runtime API

1
2
3
4
5
6
7
8
9
10
11
12
13
14

using Siccity.GLTFUtility

// Single thread
void ImportGLTF(string filepath){
    GameObject res = Importer.LoadFromFile(filepath);
}

// Multi thread
void ImportGLTFAsync(string filepath){
    Importer.ImportGLTFAsync(filepath, new ImportSettings(), OnFinish);
}
void OnFinish(){
    ...
}

here I use Application.streamingAssetsPath+"/Model/"+JsonReader.vehicle.model.carBody[0].dir as filepath

Trouble shooting

1. In the built game, encounter ArgumentNullException: Value cannot be null. Parameter name: shader
   Github Issue
2. The file management of the game changed after being built. How to determine where to place the Save and Model folders?
   Use Application.streamingAssetsPath, stands for Assets/StreamingAssets in Unity editor and Game_Data/StreamingAssets in exported game.

Csharp’s interpretation of Json

First construct the structure of the json file in c#.
Notice: the name of the member variable should be the same with those in json file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

[System.Serializable]
public class VehiclePhysicsPara
{
    public float bodyMass;
    public Vector3 centerOfMass;
    public List<BodyColliderPara> collider;
    public List<WheelColliderPara> wheel;
}

[System.Serializable]
public class BodyColliderPara
{
    public string type; // box | sphere
    public Vector3 position;
    public Vector3 eulerRotation;
    public Vector3 scale;
}
[System.Serializable]
public class SteeringWheelTypePara
{
    public bool use;
    public bool inverse;
}
[System.Serializable]
public class WheelTypePara
{
    public bool powered;
    public SteeringWheelTypePara steering;
}
[System.Serializable]
public class WheelSuspensionPara
{
    public float spring;
    public float damper;
    public float distance;
    public float initialPosition;
}
[System.Serializable]
public class WheelFrictionPara
{
    public float extremumSlip;
    public float extremumValue;
    public float AsymptoteSlip;
    public float AsymptoteValue;
}

[System.Serializable]
public class WheelColliderPara
{
    public WheelTypePara type;
    public float mass;
    public float radius;
    public Vector3 position;
    public WheelSuspensionPara suspension;
    public WheelFrictionPara forwardFriction;
    public WheelFrictionPara sidewayFriction;
}

[System.Serializable]
public class VehicleModelPara
{
    public List<CarBodyPara> carBody;
    public List<WheelModelPara> wheel;
}
[System.Serializable]
public class CarBodyPara
{
    public string name;
    public string dir;
    public Vector3 position;
    public Vector3 eulerRotation;
    public Vector3 scale;
    public string shader;
}
[System.Serializable]
public class WheelModelPara
{
    public string name;
    public string dir;
    public Vector3 scale;
    public string shader;
}
[System.Serializable]
public class VehiclePara
{
    public VehicleModelPara model;
    public VehiclePhysicsPara physics;  
}

Notice: [System.Serializable] is for serialized display in Unity editor.

Then, directly use build-in json loader:

1
2

VehiclePara vehicle;
vehicle = JsonUtility.FromJson<VehiclePara>(textJson.text);

All the parameters will be stored in the instance vehicle .

Abstract the vehicle as a Json structure

Graph

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

flowchart RL
    Main
    Model --> Main
    Physics --> Main
    Controller --> Main
    carBody --> Model
    subgraph bodyPart
    part1
    part2
    end
    bodyPart --> carBody
    wheelVis --> Model
    wheelVisGroup --> wheelVis
    subgraph bodyCollider
        boxCol
        sphereCol
    end
    bodyCollider --> collider
    collider --> Physics
    massProperty --> Physics
    wheelProperty --> Physics
    wheelColGroup --> wheelProperty
    subgraph wheelVisGroup
        tyreVis1
        tyreVis2
        tyreVis3
        tyreVis4
    end
    subgraph wheelColGroup
        wheelCol1 
        wheelCol2 
        wheelCol3 
        wheelCol4 
    end
    wheelVisGroup -- oneToOne --> wheelColGroup
    

Json example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

{
    "model":{
        "carBody":[
            {
                "name":"body1",
                "dir":"./CustomModel/car1/body1.obj",
                "position":{"x":0,"y":0,"z":0},
                "eulerRotation":{"x":0,"y":0,"z":0},
                "scale":{"x":0,"y":0,"z":0},
                "shader":"Standard"
            },
            {
                "name":"body2",
                "dir":"./CustomModel/car1/body2.obj",
                "position":{"x":0,"y":0,"z":0},
                "eulerRotation":{"x":0,"y":0,"z":0},
                "scale":{"x":0,"y":0,"z":0},
                "shader":"Standard"
            }
        ],
        "wheel":[
            {
                "name":"wheel1",
                "dir":"./CustomModel/car1/wheel1.obj",
                "scale":{"x":0,"y":0,"z":0},
                "shader":"Standard"
            }
        ]
    },
    "physics":{
        "collider":[
            {
                "type":"box",
                "position":{"x":0,"y":0,"z":0},
                "eulerRotation":{"x":0,"y":0,"z":0},
                "scale":{"x":0,"y":0,"z":0}
            },
            {
                "type":"sphere",
                "position":{"x":0,"y":0,"z":0},
                "eulerRotation":{"x":0,"y":0,"z":0},
                "scale":{"x":0,"y":0,"z":0}
            }
        ],
        "centerOfMass":{"x":0,"y":0,"z":0},
        "bodyMass":700,
        "wheel":[
            {
                "type":{"powered":true,"steering":{"use":true,"inverse":false}},
                "mass":7,
                "radius":0.5,
                "position":{"x":0,"y":0,"z":0},
                "suspension":{
                    "spring":25000,
                    "damper":9000,
                    "distance":0.3,
                    "initialPosition":0.5
                },
                "forwardFriction":{
                    "extremumSlip":0.1,
                    "extremumValue:":1,
                    "AsymptoteSlip":0.2,
                    "AsymptoteValue":0.8
                },
                "sidewayFriction":{
                    "extremumSlip":0.05,
                    "extremumValue:":1,
                    "AsymptoteSlip":0.2,
                    "AsymptoteValue":0.8
                }
            }
        ]
    }
}

• Lecture content
  • operational ability vs academic ability
• After lecture chatting
  • phd vs start a business
• How to design education

Lecture content

operational ability vs academic ability

动手能力对于公司创业初期有关键作用
基础研发实力决定公司后期发展(学科)

After lecture chatting

phd vs start a business

读书永远风险最低， 长线收益最高
李教授能搞项目是因为他可以带动硕博本，但本科生指挥不动人

How to design education

以项目为导向，兼顾基础知识的课程
自上而下， 夯实基础原理的理解，而不是调参摁卷（某些竞赛就是源代码拿来然后使劲调参，钻牛角尖，不符合人才培养要求，无基础能力，适应力差）
某些创新的小比赛就比较好，能给自己的成果锦上添花