Christopher Greenblatt

☀️ Atlanta, GA

Partly Cloudy • Feels like 75°F

Portfolio Project Analytics

// Direct PWM control for servo positioning
class ServoController {
private:
    uint8_t pin;
    uint16_t currentPulse;
    uint16_t targetPulse;
    
public:
    void setPosition(float angle) {
        // Convert angle to pulse width (1000-2000 μs)
        targetPulse = map(angle, 0, 180, 1000, 2000);
    }
    
    void update() {
        // Smooth movement interpolation
        if (currentPulse != targetPulse) {
            int16_t diff = targetPulse - currentPulse;
            currentPulse += constrain(diff, -MAX_STEP, MAX_STEP);
        }
        
        // Generate PWM signal
        analogWrite(pin, pulseToPWM(currentPulse));
    }
    
private:
    uint8_t pulseToPWM(uint16_t pulse) {
        // Convert microseconds to PWM value
        return map(pulse, 1000, 2000, 
                   PWM_MIN, PWM_MAX);
    }
};

// 3D inverse kinematics calculation
struct Point3D { float x, y, z; };
struct JointAngles { float base, shoulder, elbow, wrist; };

class InverseKinematics {
private:
    float L1, L2, L3; // Link lengths
    
public:
    JointAngles solve(Point3D target) {
        JointAngles angles;
        
        // Base rotation (around Z-axis)
        angles.base = atan2(target.y, target.x);
        
        // 2D problem in X-Z plane
        float r = sqrt(target.x*target.x + target.y*target.y);
        float z = target.z;
        
        // Distance to target
        float d = sqrt(r*r + z*z);
        
        // Law of cosines for elbow angle
        float cosElbow = (L1*L1 + L2*L2 - d*d) / (2*L1*L2);
        angles.elbow = acos(constrain(cosElbow, -1, 1));
        
        // Shoulder angle calculation
        float alpha = atan2(z, r);
        float beta = acos((L1*L1 + d*d - L2*L2) / (2*L1*d));
        angles.shoulder = alpha + beta;
        
        return angles;
    }
};

// Main control loop with timing constraints
class RobotController {
private:
    ServoController servos[6];
    InverseKinematics ik;
    unsigned long lastUpdate;
    const uint16_t UPDATE_INTERVAL = 20; // 50Hz update rate
    
public:
    void controlLoop() {
        unsigned long currentTime = millis();
        
        if (currentTime - lastUpdate >= UPDATE_INTERVAL) {
            // Read current position feedback
            Point3D currentPos = readEndEffectorPosition();
            
            // Calculate next waypoint in trajectory
            Point3D nextTarget = trajectoryPlanner.getNextPoint();
            
            // Solve inverse kinematics
            JointAngles targetAngles = ik.solve(nextTarget);
            
            // Apply safety limits and update servos
            for (int i = 0; i < 6; i++) {
                float safeAngle = applySafetyLimits(targetAngles.angles[i], i);
                servos[i].setPosition(safeAngle);
                servos[i].update();
            }
            
            // Monitor for emergency conditions
            if (emergencyStop.triggered()) {
                halt();
                return;
            }
            
            lastUpdate = currentTime;
        }
    }
};