ELEKTRONIKA
ROBOTIKA

Pemilihan MCU yang tepat sangat kritis. Robot kompleks sering menggunakan arsitektur berlapis: MCU kecil untuk real-time HAL, SBC (Single Board Computer) untuk komputasi tinggi.

Topologi H-Bridge

L298N — Arduino Wiring & Code

// L298N dual H-bridge dengan PWM speed control
#define IN1 7; #define IN2 8; #define ENA 9;
#define IN3 10; #define IN4 11; #define ENB 6;

void driveMotors(int L, int R) {
  // L, R: -255 to +255
  digitalWrite(IN1, L >= 0); digitalWrite(IN2, L < 0);
  digitalWrite(IN3, R >= 0); digitalWrite(IN4, R < 0);
  analogWrite(ENA, constrain(abs(L), 0, 255));
  analogWrite(ENB, constrain(abs(R), 0, 255));}

void setup() {
  int pins[] = {IN1,IN2,ENA,IN3,IN4,ENB};
  for(auto p : pins) pinMode(p, OUTPUT);
  TCCR1B = (TCCR1B & 0xF8) | 0x01; // Pin 9,10 → 31.37kHz PWM
  TCCR2B = (TCCR2B & 0xF8) | 0x01; // Pin 11,6  → 31.37kHz PWM
}

import numpy as np

def clarke(ia, ib, ic):
    alpha = ia
    beta  = (ia + 2*ib) / np.sqrt(3)
    return alpha, beta

def park(alpha, beta, theta):
    d =  alpha*np.cos(theta) + beta*np.sin(theta)
    q = -alpha*np.sin(theta) + beta*np.cos(theta)
    return d, q

def inv_park(d, q, theta):
    alpha = d*np.cos(theta) - q*np.sin(theta)
    beta  = d*np.sin(theta) + q*np.cos(theta)
    return alpha, beta

class FOCController:
    def __init__(self, kp=1.0, ki=100, dt=0.0001):
        self.kp=kp; self.ki=ki; self.dt=dt
        self.id_i=0; self.iq_i=0

    def step(self, ia, ib, ic, theta, iq_ref, id_ref=0):
        alpha, beta = clarke(ia, ib, ic)
        d, q = park(alpha, beta, theta)
        ed = id_ref - d; eq = iq_ref - q
        self.id_i += ed * self.dt; self.iq_i += eq * self.dt
        vd = self.kp*ed + self.ki*self.id_i
        vq = self.kp*eq + self.ki*self.iq_i
        valpha, vbeta = inv_park(vd, vq, theta)
        return vd, vq, valpha, vbeta  # → SVPWM

Aturan PCB untuk Robot

Trace Width & Current Capacity

def trace_width_mm(I_A, dT_C=10, layer='ext'):
    """IPC-2221 trace width (1oz copper)"""
    k = 0.048 if layer=='ext' else 0.024
    area_mil2 = (I_A / (k * dT_C**0.44))**(1/0.725)
    width_mm  = (area_mil2 / 1.378) / 25.4  # 1oz=1.378mil/mil²
    return round(width_mm, 2)

print(f"5A → {trace_width_mm(5):.2f}mm")

Decoupling Capacitor Placement

LiPo Battery Management

Power Tree Robot Tipikal

# Power distribution architecture:
# LiPo 4S (16.8V max, 14.8V nom)
#     |
#     +---[BMS/fuse 30A]---+
#     |                   |
# [Motor Driver]    [Step-down DC-DC]
# (raw Vbat)         LM2596/XL4016
#                   |           |
#                [12V 3A]     [5V 5A]
#               (servo/fans)   |
#                          [3.3V LDO]
#                         (MCU, sensors)
# Jetson Orin: butuh 9-20V 4A dedicated line (tidak share dgn motor!)

Regulasi Tegangan — Komponen

// Arduino: Monitor voltage baterai via ADC (voltage divider)
// 16.8V max → 100k:22k divider → max 3.0V pada ADC pin
#define VBAT_PIN A0
#define R1 100000.0  // 100k
#define R2  22000.0  // 22k
#define VCUTOFF 12.0   // 3S cutoff 12V

float readBattery() {
  int raw = analogRead(VBAT_PIN);
  float vadc = raw * (5.0 / 1023.0);
  return vadc * (R1 + R2) / R2;
}

void checkBattery() {
  float v = readBattery();
  if (v < VCUTOFF) {
    Serial.println("WARNING: Battery low! Shutting down.");
    // Emergency stop motors
  }
  Serial.printf("Vbat: %.2fV (%.0f%%)\n", v, map(v*100,1200,1680,0,100));
}

I2C Protocol

// Arduino: Scan I2C bus — temukan semua device
#include <Wire.h>

void i2c_scan() {
  Wire.begin();
  Serial.println("I2C Scan:");
  for (uint8_t addr = 0x01; addr < 0x7F; addr++) {
    Wire.beginTransmission(addr);
    if (Wire.endTransmission() == 0)
      Serial.printf("Found: 0x%02X\n", addr);
  }
}

// MPU6050 IMU via I2C:
#include <MPU6050_tockn.h>
MPU6050 mpu(Wire);

void setup() {
  Wire.begin(); Wire.setClock(400000);
  mpu.begin(); mpu.calcGyroOffsets(true);
}

float getYaw() {
  mpu.update();
  return mpu.getAngleZ(); // degrees
}

SPI Protocol

// Arduino: ICM42688 IMU via SPI (lebih cepat dari I2C)
#include <SPI.h>
#define CS_PIN 10

uint8_t spi_read(uint8_t reg) {
  digitalWrite(CS_PIN, LOW);
  SPI.transfer(reg | 0x80);  // MSB=1 for read
  uint8_t val = SPI.transfer(0x00);
  digitalWrite(CS_PIN, HIGH);
  return val;
}

void spi_write(uint8_t reg, uint8_t val) {
  digitalWrite(CS_PIN, LOW);
  SPI.transfer(reg & 0x7F);  // MSB=0 for write
  SPI.transfer(val);
  digitalWrite(CS_PIN, HIGH);
}

Multi-node CAN Bus untuk Robot

// Arduino Mega + MCP2515: CAN Bus node
#include <mcp2515.h>
MCP2515 can(10);  // CS pin 10

void setup() {
  can.reset();
  can.setBitrate(CAN_500KBPS, MCP_8MHZ);
  can.setNormalMode();
}

// Kirim data sensor via CAN:
void sendSensorData(float dist, float yaw) {
  struct can_frame frame;
  frame.can_id  = 0x101;  // Node ID: sensor
  frame.can_dlc = 8;     // 8 bytes data
  uint16_t d_mm = (uint16_t)(dist * 1000);
  int16_t y_10  = (int16_t)(yaw * 10);
  memcpy(&frame.data[0], &d_mm, 2);
  memcpy(&frame.data[2], &y_10, 2);
  can.sendMessage(&frame);
}

// Terima perintah motor:
void receiveCAN() {
  struct can_frame f;
  if (can.readMessage(&f) == MCP2515::ERROR_OK) {
    if (f.can_id == 0x200) {  // Motor command
      int16_t L, R;
      memcpy(&L, &f.data[0], 2);
      memcpy(&R, &f.data[2], 2);
      driveMotors(L, R);
    }
  }
}

ADC — Analog Sensor Digitalisasi

// Arduino: Averaging + low-pass filter untuk sensor analog
class AnalogSensor {
  int pin; float val=0; float alpha=0.1;
public:
  AnalogSensor(int p, float a=0.15) : pin(p), alpha(a) {}
  float read() {
    float raw = 0;
    for (int i=0; i<8; i++) raw += analogRead(pin);
    raw /= 8.0;
    val = alpha * raw + (1-alpha) * val;  // EMA filter
    return val;
  }
  float voltage() { return read() * (5.0/1023.0); }
};

// ADS1115 external 16-bit ADC via I2C (jauh lebih akurat):
#include <ADS1X15.h>
ADS1115 ads(0x48);

void setup() {
  Wire.begin(); ads.begin();
  ads.setGain(1);  // ±4.096V range, 0.125mV/bit
}

float readForce() {
  int16_t raw = ads.readADC(0);
  float v = raw * 0.0001250;  // 0.125mV/bit
  return (v - 0.5) / (4.5 - 0.5) * 100;  // FSR 0-100N
}

EMI Mitigation untuk Robot

TVS Diode Clamping Circuit

// Proteksi reverse polarity + overvoltage input:
// VIN+ ---[P-MOSFET gate ke GND]--- VBAT+
// (P-FET mengalir jika Vgs negatif → proteksi reverse polarity)
//
// Komponen proteksi PCB robot:
// - TVS SMAJ15A (15V): proteksi spike pada motor power rail
// - BAT54 Schottky: proteksi back-EMF render diode
// - Ferrite bead BLM21: 600Ω@100MHz pada VCC MCU
// - 100nF + 10µF pada setiap regulasi tegangan output

// Logic level shift 5V→3.3V (voltage divider):
// GPIO_5V ---[1kΩ]---+---[2.2kΩ]--- GND
//                   |
//              GPIO_3V3  (= 5V × 2.2/(1+2.2) = 3.44V max ✓)
// Atau: gunakan BSS138 N-FET bidirectional level shifter

Ground Strategy

Skema Blok Robot Wheeled Lengkap

============================================
 POWER DOMAIN        COMPUTE DOMAIN
============================================
 LiPo 3S 5000mAh
   |
   +--[BMS 20A fuse]
   |         |
   |    [Buck XL4016 → 5V 5A]
   |         |           |
   |    [RPi 5 SBC]  [AMS1117 → 3.3V]
   |    (ROS2/Nav)      |
   |         |        [MCU 3.3V sensors]
   |    [USB Serial]
   |         |
   |    [Arduino Mega]  ← encoder ISR, PID, sensor poll
   |         |
   |    [L298N/BTS7960] ← PWM from Arduino
   |         |
   +----[DC Motors] ← back-EMF diode protection
============================================
 SENSOR DOMAIN
============================================
 Arduino ← [I2C] ← MPU6050 (IMU)
         ← [UART] ← RPLiDAR A1
         ← [GPIO] ← HC-SR04 × 5 (sonar)
         ← [ADC]  ← Sharp IR × 2
         ← [INT]  ← Encoder A/B × 2 (quadrature)
 RPi 5   ← [USB]  ← RPLiDAR (raw scan → /scan)
         ← [CSI]  ← Camera V3 (→ /camera/image)

// Arduino Mega: Complete sensor hub + ROS serial bridge
// Publishes: distances, IMU, battery, encoder
#include <Wire.h>
#include <NewPing.h>
#include <MPU6050_tockn.h>

#define N_SONAR 5
NewPing sonar[N_SONAR] = {
  NewPing(22,23,200), NewPing(24,25,200), NewPing(26,27,200),
  NewPing(28,29,200), NewPing(30,31,200)
};
MPU6050 mpu(Wire);

volatile long encL=0, encR=0;
void isrL() { encL++; }
void isrR() { encR++; }

void setup() {
  Serial.begin(115200);
  Wire.begin(); Wire.setClock(400000);
  mpu.begin(); mpu.calcGyroOffsets(true);
  attachInterrupt(digitalPinToInterrupt(2), isrL, RISING);
  attachInterrupt(digitalPinToInterrupt(3), isrR, RISING);
  TCCR1B = (TCCR1B & 0xF8) | 0x01;  // 31kHz PWM
}

unsigned long t_pub=0;
void loop() {
  mpu.update();
  if (millis() - t_pub >= 50) {  // 20Hz publish
    t_pub = millis();
    // Sonar
    Serial.print("S:");
    for (int i=0; i<N_SONAR; i++) {
      unsigned int us = sonar[i].ping_median(3);
      float d = (us==0) ? 200 : us/US_ROUNDTRIP_CM;
      Serial.print(d); Serial.print(",");
    }
    // IMU + encoder
    Serial.printf("I:%.2f,%.2f,%.2f,E:%ld,%ld\n",
      mpu.getAngleX(), mpu.getAngleY(), mpu.getAngleZ(),
      encL, encR);
  }
  // Receive motor command from RPi
  if (Serial.available() >= 8) {
    float v, w;
    Serial.readBytes((char*)&v, 4);
    Serial.readBytes((char*)&w, 4);
    int L = (v - w * 0.115) / 0.5 * 255;
    int R = (v + w * 0.115) / 0.5 * 255;
    driveMotors(constrain(L,-255,255), constrain(R,-255,255));
  }
}