💼 大厂面试专题:机器人 / 具身智能岗位

I'm a master's student in control engineering. I built a FOC joint controller, where I tuned the current loop to a [XX Hz] bandwidth, and I trained a locomotion policy that reached [XX%] success on the real robot. My background in motor control and motion planning matches this role well.

Robotics sits at the intersection of perception, control, and hardware. I enjoy turning algorithms into physical motion, and humanoid robots push both control and embodied AI to the limit — that is exactly where I want to grow.

FOC transforms the three-phase currents into a rotating d-q frame using the Clarke and Park transforms, so the AC currents become DC values. A PI controller then regulates the torque (q-axis) and the flux (d-axis) independently, and the result is converted back through the inverse transforms and SVPWM.

PID is a feedback-only controller with no explicit model — simple and fast. MPC solves a finite-horizon optimal control problem at every step using a model, so it can preview future references and explicitly handle constraints, at a much higher computational cost.

SLAM estimates the robot's pose and builds a map at the same time. The front end extracts and matches features to get relative poses between frames, and the back end performs global optimization — for example pose-graph or factor-graph optimization — plus loop closure to reduce accumulated drift.

It is a recursive state estimator. First it predicts the state and covariance using the motion model, then it updates them with the measurement, weighted by the Kalman gain, which balances the trust between the model and the sensor noise.

Impedance control makes the robot behave like a spring-mass-damper system. It regulates the relationship between force and motion — roughly F = M·x'' + B·x' + K·x — which is essential for safe contact and manipulation.

Forward kinematics computes the end-effector pose from the joint angles. Inverse kinematics computes the joint angles that achieve a desired pose, usually solved numerically with the Jacobian or analytically for simple arms.

Policies are trained in simulation for cheap and scalable data, then deployed on the real robot. The gap comes from physics, vision, and latency mismatch. Domain randomization, system identification, and fine-tuning with real data are the common ways to close it.

A VLA model maps vision and language instructions directly to robot actions, end to end, instead of the classic sense-plan-act pipeline. It generalizes better but needs large amounts of data and is less interpretable.

A harmonic drive uses a wave generator to deform a flexspline against a rigid circular spline, achieving a high reduction ratio — roughly 30 to 160 — with near-zero backlash. It is widely used in humanoid robot joints.

CAN is a robust, low-cost fieldbus for real-time control. EtherCAT is an Ethernet-based protocol with very low latency and synchronized distributed clocks, which is better for many-axis motion control.

In my FOC project the motor screamed at high speed. I scoped the phase-current waveform, found sampling noise near the PWM switching edge, moved the ADC sampling point and added filtering, and the oscillation disappeared. That taught me to always check the signal chain before tuning gains.

My strength is bridging theory and practice — I can derive a controller and also tune it on hardware. My weakness is that I sometimes over-optimize small details; I now set time-boxes and priorities to stay focused on the goal.

Yes — what is the hardest technical problem the team is solving right now? What would success look like in the first six months? And how far along is the product toward mass production?

// 一维卡尔曼(状态 x、方差 P、过程噪声 Q、观测噪声 R)
float kalman1d(float x, float P, float Q, float R, float z) {
    // 预测(一维 A=1,无控制输入)
    float x_pred = x;
    float P_pred = P + Q;
    // 更新(一维 H=1)
    float K = P_pred / (P_pred + R);
    x = x_pred + K * (z - x_pred);
    P = (1.0f - K) * P_pred;
    return x;   // 返回滤波后的状态
}

// 位置式(注意积分抗饱和 + 限幅)
u  = Kp*e + Ki*integral + Kd*(e - prev_e);
integral += e;  prev_e = e;   // 之后对 u 与 integral 做 anti-windup 限幅

// 增量式(输出 = 上次输出 + 增量)
du = Kp*(e - e1) + Ki*e + Kd*(e - 2*e1 + e2);
e2 = e1; e1 = e;               // 滑动保存历史误差
u  = u_prev + du;  u_prev = u;

// Clark(幅值不变):abc -> alpha/beta
I_alpha = I_a;
I_beta  = (I_a + 2.0f*I_b) / sqrtf(3.0f);   // 或 (I_b - I_c)/sqrt(3)

// Park:alpha/beta -> d/q
I_d =  I_alpha*cosf(th) + I_beta*sinf(th);
I_q = -I_alpha*sinf(th) + I_beta*cosf(th);

// 逆 Park:d/q -> alpha/beta
V_alpha = V_d*cosf(th) - V_q*sinf(th);
V_beta  = V_d*sinf(th) + V_q*cosf(th);

int svpwm_sector(float Va, float Vb) {
    float V1 = Vb;
    float V2 =  0.866f*Va - 0.5f*Vb;   // sqrt(3)/2 * Va - 1/2 * Vb
    float V3 = -0.866f*Va - 0.5f*Vb;   // -sqrt(3)/2 * Va - 1/2 * Vb
    int N = (V1 > 0) + ((V2 > 0) << 1) + ((V3 > 0) << 2);
    switch (N) {
        case 3: return 1; case 1: return 2; case 5: return 3;
        case 4: return 4; case 6: return 5; case 2: return 6;
    }
    return 0;
}

roll  = atan2f(2*(w*x + y*z), 1 - 2*(x*x + y*y));
pitch = asinf(clampf(2*(w*y - z*x), -1.0f, 1.0f));
yaw   = atan2f(2*(w*z + x*y), 1 - 2*(y*y + z*z));

def astar(grid, start, goal):
    open_h = [(h(start, goal), 0, start)]   # (f, g, 节点) 最小堆
    g = {start: 0}; parent = {}
    while open_h:
        f, cost, cur = heappop(open_h)
        if cur == goal: break
        for nxt in neighbors(cur):
            if grid[nxt] == 障碍: continue
            ng = cost + 1                    # 四邻接代价为 1
            if ng < g.get(nxt, inf):
                g[nxt] = ng; parent[nxt] = cur
                heappush(open_h, (ng + h(nxt, goal), ng, nxt))
    return reconstruct(parent, goal)         # 沿 parent 回溯路径

c = points.mean(axis=0)              # (3,)
C = (points - c).T @ (points - c) / len(points)   # 3x3 协方差
w, v = np.linalg.eig(C)              # 特征分解
axis = v[:, argmax(w)]               # 最大特征值 -> 主轴方向

// 欧拉(一阶)
y += h * f(t, y); t += h;

// RK4(四阶)
k1 = f(t,        y);
k2 = f(t + h/2,  y + h/2 * k1);
k3 = f(t + h/2,  y + h/2 * k2);
k4 = f(t + h,    y + h   * k3);
y += (h / 6.0) * (k1 + 2*k2 + 2*k3 + k4);  t += h;

k  = 2.0f * fs;
A  = k*k + 2.0f*zeta*wn*k + wn*wn;
b0 = wn*wn / A;
b1 = 2.0f*wn*wn / A;
b2 = wn*wn / A;
a1 = 2.0f*(wn*wn - k*k) / A;
a2 = (k*k - 2.0f*zeta*wn*k + wn*wn) / A;
// y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] - a1*y[n-1] - a2*y[n-2]

from collections import deque
def levelOrder(root):
    if not root: return []
    res, q = [], deque([root])
    while q:
        level = []
        for _ in range(len(q)):       # 每次恰好处理一层
            node = q.popleft()
            level.append(node.val)
            if node.left:  q.append(node.left)
            if node.right: q.append(node.right)
        res.append(level)
    return res