中控杯记 | WEDM's Blog in ZJU

1. 丝杆

// 定义步进电机控制引脚
// stepPin 用于发送步进脉冲信号，控制步进电机的步数
const int stepPin = 3;
// dirPin 用于控制步进电机的转动方向
const int dirPin = 6;
// enablePin 用于使能或禁用步进电机，低电平使能
const int enablePin = 8;

// 定义初始和最大的脉冲间隔（微秒）
// initialDelay 是电机启动时的脉冲间隔，值越大电机启动越慢
const int initialDelay = 50;
// minDelay 是电机能达到的最小脉冲间隔，值越小电机速度越快
const int minDelay = 20;
// 定义加速和减速的步长
// delayStep 决定了脉冲间隔每次变化的量，值越大加速和减速越明显
const int delayStep = 50;

// 定义正转和反转的持续时间（毫秒）
const unsigned long forwardDuration = 5000; // 正转 5 秒
const unsigned long reverseDuration = 5000; // 反转 5 秒

// 记录开始时间
unsigned long startTime;

// setup 函数在程序开始时只运行一次，用于初始化设置
void setup() {
  // 将步进脉冲引脚设置为输出模式
  pinMode(stepPin, OUTPUT);
  // 将方向引脚设置为输出模式
  pinMode(dirPin, OUTPUT);
  // 将使能引脚设置为输出模式
  pinMode(enablePin, OUTPUT);
  // 使能步进电机，低电平有效
  digitalWrite(enablePin, LOW);
}

// loop 函数会不断循环执行
void loop() {
  // 正转阶段
  digitalWrite(dirPin, LOW); // 设置为正转方向，假设 LOW 为正转
  startTime = millis(); // 记录正转开始时间
  while (millis() - startTime < forwardDuration) {
    // 加速阶段
    for (int delayTime = initialDelay; delayTime >= minDelay; delayTime -= delayStep) {
      stepMotor(delayTime);
    }
    // 减速阶段
    for (int delayTime = minDelay; delayTime <= initialDelay; delayTime += delayStep) {
      stepMotor(delayTime);
    }
  }

  // 反转阶段
  digitalWrite(dirPin, HIGH); // 设置为反转方向，假设 HIGH 为反转
  startTime = millis(); // 记录反转开始时间
  while (millis() - startTime < reverseDuration) {
    // 加速阶段
    for (int delayTime = initialDelay; delayTime >= minDelay; delayTime -= delayStep) {
      stepMotor(delayTime);
    }
    // 减速阶段
    for (int delayTime = minDelay; delayTime <= initialDelay; delayTime += delayStep) {
      stepMotor(delayTime);
    }
  }
}

// stepMotor 函数用于控制步进电机的一次步进动作
// delayTime 是脉冲间隔，单位为微秒
void stepMotor(int delayTime) {
  // 发送低电平脉冲
  digitalWrite(stepPin, LOW);
  // 保持低电平一段时间，时间长度由 delayTime 决定
  delayMicroseconds(delayTime);
  // 发送高电平脉冲
  digitalWrite(stepPin, HIGH);
  // 保持高电平一段时间，时间长度由 delayTime 决定
  delayMicroseconds(delayTime);
}

2. 机械臂

// 定义步进电机控制引脚
const int stepPin = 3;
const int dirPin = 6;
const int enablePin = 8;

// 定义初始和最大的脉冲间隔（微秒）
const int initialDelay = 100;
const int minDelay = 40;
// 定义加速和减速的步长
const int delayStep = 100;

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(enablePin, OUTPUT);
  digitalWrite(enablePin, LOW);
  digitalWrite(dirPin, LOW);
}

void loop() {
  // 加速阶段
  for (int delayTime = initialDelay; delayTime >= minDelay; delayTime -= delayStep) {
    stepMotor(delayTime);
  }
  // 减速阶段
  for (int delayTime = minDelay; delayTime <= initialDelay; delayTime += delayStep) {
    stepMotor(delayTime);
  }
}

void stepMotor(int delayTime) {
  digitalWrite(stepPin, LOW);
  delayMicroseconds(delayTime);
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(delayTime);
}

3.模组进退

// 定义步进电机控制引脚
const int stepPin = 3;
const int dirPin = 6;
const int enablePin = 8;

// 定义初始和最大的脉冲间隔（微秒）
const int initialDelay = 100;
const int minDelay = 40;
// 定义加速和减速的步长
const int delayStep = 100;

// 定义定时转向的时间间隔（毫秒）
const unsigned long turnInterval = 2500;
// 记录上次转向的时间
unsigned long lastTurnTime = 0;

// 定义一个标志变量来控制电机的转动方向
bool isForward = true;

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(enablePin, OUTPUT);
  digitalWrite(enablePin, LOW);
  // 初始设置为正转方向
  digitalWrite(dirPin, LOW);
}

void loop() {
  unsigned long currentTime = millis();

  // 判断是否到达转向时间
  if (currentTime - lastTurnTime >= turnInterval) {
    // 切换转动方向
    isForward = !isForward;
    lastTurnTime = currentTime;
  }

  // 根据方向标志设置转动方向
  if (isForward) {
    digitalWrite(dirPin, LOW);
  } else {
    digitalWrite(dirPin, HIGH);
  }

  // 加速阶段
  for (int delayTime = initialDelay; delayTime >= minDelay; delayTime -= delayStep) {
    stepMotor(delayTime);
  }
  // 减速阶段
  for (int delayTime = minDelay; delayTime <= initialDelay; delayTime += delayStep) {
    stepMotor(delayTime);
  }
}

void stepMotor(int delayTime) {
  digitalWrite(stepPin, LOW);
  delayMicroseconds(delayTime);
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(delayTime);
}

4.轮胎转动

// 双引脚PWM调速方案
#define MOTOR_PWM 4 // 必须使用PWM引脚（带~符号）
#define MOTOR_DIR 5

void setup() {
  pinMode(MOTOR_PWM, OUTPUT);
  pinMode(MOTOR_DIR, OUTPUT);
  stopMotor();
}

void loop() {
  // 正向加速
  setMotor(255, HIGH);  // 全速正转
  delay(2000);
  
  // 线性减速
  for(int i=255; i>=0; i--){
    setMotor(i, HIGH);
    delay(20);
  }
  
  // 反向中速
  setMotor(150, LOW);  // 70%速度反转
  delay(2000);
  stopMotor();
  delay(1000);
}

// 电机控制函数
void setMotor(int speed, bool direction) {
  speed = constrain(speed, 0, 255);  // 速度限幅
  digitalWrite(MOTOR_DIR, direction);
  analogWrite(MOTOR_PWM, speed);
}

// 停止电机
void stopMotor() {
  analogWrite(MOTOR_PWM, 0);
}

#### 四个引脚控俩轮
// 四引脚PWM调速方案
#define MOTOR_PWM_1 4 // 必须使用PWM引脚（带~符号）
#define MOTOR_DIR_1 5
#define MOTOR_PWM_2 6 // 新增引脚
#define MOTOR_DIR_2 7 // 新增引脚

void setup() {
  pinMode(MOTOR_PWM_1, OUTPUT);
  pinMode(MOTOR_DIR_1, OUTPUT);
  pinMode(MOTOR_PWM_2, OUTPUT);
  pinMode(MOTOR_DIR_2, OUTPUT);
  stopMotor();
}

void loop() {
  // 正向加速
  setMotor(150, HIGH);
  delay(1000);
  
  // 停止
  stopMotor();
  delay(1000);
  
  // 反向加速
  setMotor(150, LOW);
  delay(1000);
  
  stopMotor();
  delay(1000);
}

// 电机控制函数
void setMotor(int speed, bool direction) {
  speed = constrain(speed, 0, 150);  // 速度限幅
  digitalWrite(MOTOR_DIR_1, diQrection);
  analogWrite(MOTOR_PWM_1, speed);
  digitalWrite(MOTOR_DIR_2, direction);
  analogWrite(MOTOR_PWM_2, speed);
}

// 停止电机
void stopMotor() {
  analogWrite(MOTOR_PWM_1, 0);
  analogWrite(MOTOR_PWM_2, 0);
}