交流论坛

//============================BJTU==============================
// 智能小车红外遥控实验 --初始
//===============================================================
#include
// 定义引脚
int Left_motor = 8; //左电机驱动：输出0 电机正转 输出1，电机反转，同时控制左前轮和左后轮。
int Left_motor_pwm = 9; //左电机PWM调速。
int Right_motor_pwm = 10; //右电机PWM调速
int Right_motor = 11; //右电机驱动：输出0 电机正转 输出1，电机反转，同时控制右前轮和右后轮。
int pwm_value = 100; //调整电机速度，实际验证80到255可用。


const int remoteControlPin = A4; // 红外遥控接收引脚
const int buzzerPin = A3; // 蜂鸣器引脚
long car_cmd; //小车收到的红外遥控指令变量

const long forward_car = 0xE718FF00;//按键,前进
const long back_car = 0xAD52FF00;//按键，后退
const long left_car = 0xF30CFF00;//按键，左转
const long right_car = 0xB54AFF00;//按键，右转
const long stop_car = 0xE31CFF00;//按键，停车
const long spin_left_car = 0xF708FF00;//按键，原地左转
const long spin_right_car = 0xA55AFF00;//按键，原地右转
const long beep_car = 0xBD42FF00;//按键，喇叭
const long acceleration_car = 0xA15EFF00;//按键,加速
const long deceleration_car = 0xE916FF00;//按键,减速

long car_state;//car state。

void setup() {
//初始化电机驱动IO为输出方式
pinMode(Left_motor, OUTPUT); // PIN 8
pinMode(Left_motor_pwm, OUTPUT); // PIN 9 (PWM)
pinMode(Right_motor_pwm, OUTPUT); // PIN 10 (PWM)
pinMode(Right_motor, OUTPUT); // PIN 11
pinMode(remoteControlPin, INPUT); // 红外遥控接收引脚 A4
pinMode(buzzerPin, OUTPUT); // 蜂鸣器输出 A3
IrReceiver.begin(remoteControlPin, ENABLE_LED_FEEDBACK); // Start 红外接收功能
}

// 小车前进函数
void run() {
digitalWrite(Right_motor, LOW); // 右电机前进
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, LOW); // 左电机前进
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 小车刹车函数
void brake() {
digitalWrite(Right_motor_pwm, LOW); // 右电机PWM 调速输出0
analogWrite(Right_motor_pwm, 0); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor_pwm, LOW); //左电机PWM 调速输出0
analogWrite(Left_motor_pwm, 0); //PWM比例0~255调速，左右轮差异略增减
}

// 小车左转函数
void left() {
digitalWrite(Right_motor, LOW); // 右电机前进
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, LOW); // 左电机前进
analogWrite(Left_motor_pwm, 0); //PWM比例0~255调速，左右轮差异略增减
}

// 小车左旋转函数
void spin_left() {
digitalWrite(Right_motor, LOW); // 右电机前进
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, HIGH); // 左电机后退
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 小车右旋转函数
void right() {
digitalWrite(Right_motor, LOW); // 右电机不转
analogWrite(Right_motor_pwm, 0); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, LOW); // 左电机前进
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 小车右转圈函数
void spin_right() {
digitalWrite(Right_motor, HIGH); // 右电机后退
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, LOW); // 左电机前进
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 小车后退函数
void back() {
digitalWrite(Right_motor, HIGH); // 右电机后退
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, HIGH); // 左电机后退
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 检测红外遥控信号
void detectRemoteControl() {
if (IrReceiver.decode()) { //如果接收到红外按键信号
car_cmd = IrReceiver.decodedIRData.decodedRawData; //赋值
}
IrReceiver.resume(); // Enable receiving of the next value
}

// 发出 “滴” 的一声，持续 200 毫秒
void beep() {
digitalWrite(buzzerPin, HIGH);
delay(200);
digitalWrite(buzzerPin, LOW);
}

// 每按一次加速键，速度加10，并且响一声
void acceleration() {
if(pwm_value <= 240){
pwm_value = pwm_value + 10;
beep();
}
if(car_state == forward_car )//前进
run();
if (car_state == back_car)//后退
back();//后退
if (car_state = left_car)//左转
left();//左转
if (car_state == right_car)//右转
right();//右转
if (car_state == spin_left_car)//原地左转
spin_left();//原地左转
if (car_state ==spin_right_car)//原地右转
spin_right();//原地右转
}

// 每按一次减速键，速度减10，并且响一声
void deceleration() {
if(pwm_value >= 10){
pwm_value = pwm_value - 10;
beep();
}
if(car_state == forward_car )//前进
run();
if (car_state == back_car)//后退
back();//后退
if (car_state = left_car)//左转
left();//左转
if (car_state == right_car)//右转
right();//右转
if (car_state == spin_left_car)//原地左转
spin_left();//原地左转
if (car_state ==spin_right_car)//原地右转
spin_right();//原地右转
}


//主循环函数
void loop() {
//放入红外遥控检测函数 //检测红外遥控
detectRemoteControl();

if(car_cmd == forward_car ){//前进
run();
}
if (car_cmd == back_car){//后退
back();//后退
//car_state = car_cmd;
}
if (car_cmd = left_car){//左转
left();//左转
//car_state = car_cmd;
}
if (car_cmd == right_car){//右转
right();//右转
//car_state = car_cmd;
}
if (car_cmd == spin_left_car){//原地左转
spin_left();//原地左转
//car_state = car_cmd;
}
if (car_cmd ==spin_right_car){//原地右转
spin_right();//原地右转
//car_state = car_cmd;
}
if (car_cmd == stop_car)//停车
brake();//停车
if (car_cmd == beep_car)//喇叭
beep();//喇叭
// if (car_cmd == acceleration_car)//加速
// acceleration();//加速
// if (car_cmd == deceleration_car)//减速
// deceleration();//减速
}

//============================BJTU==============================
// 智能小车红外遥控实验
//===============================================================
#include
// 定义引脚

// 超声波模块引脚定义
const int trigPin = A0; // Trig 触发脚(P2.1)
const int echoPin = A1; // Echo回声脚(P2.0)

//moto引脚定义
int Left_motor = 8; //左电机驱动：输出0 电机正转 输出1，电机反转，同时控制左前轮和左后轮。
int Left_motor_pwm = 9; //左电机PWM调速。
int Right_motor_pwm = 10; //右电机PWM调速
int Right_motor = 11; //右电机驱动：输出0 电机正转 输出1，电机反转，同时控制右前轮和右后轮。
int pwm_value = 100; //调整电机速度，实际验证80到255可用。

// 距离参数（单位：厘米）
const int followDistance = 40; // 目标跟随距离
const int minDistance = 15; // 最小安全距离
const int maxDistance = 80; // 最大有效距离


const int remoteControlPin = A4; // 红外遥控接收引脚
const int buzzerPin = A3; // 蜂鸣器引脚
long car_cmd; //小车收到的红外遥控指令变量
long car_state;
int mode_volue = 1; //

//0xF30CFF00--按键1 0xE718FF00--按键2 0xA15EFF00--按键3 0xF708FF00--按键4 0xE31CFF00--按键5
//0xA55AFF00--按键6 0xBD42FF00--按键7 0xAD52FF00--按键8 0xB54AFF00--按键9 0xE916FF00--按键0
//0xE619FF00--按键100 0xF20DFF00--按键200 0xF807FF00--按键- 0xEA15FF00--按键+ 0xF609FF00--按键EQ
const long forward_car = 0xE718FF00;//按键2,前进
const long back_car = 0xAD52FF00;//按键8，后退
const long left_car = 0xF708FF00;//按键4，左转
const long right_car = 0xA55AFF00;//按键6，右转
const long stop_car = 0xE31CFF00;//按键5，停车
const long spin_left_car = 0xF30CFF00;//按键1，原地左转
const long spin_right_car = 0xA15EFF00;//按键3，原地右转
const long beep_car = 0xE916FF00;//按键0，蜂鸣
const long high_speed_car = 0xF20DFF00;//按键200，高速
const long low_speed_car = 0xE619FF00;//按键100，高速
const long switch_mode = 0xF609FF00;//红外遥控 or 超声


void setup() {
// 初始化超声波引脚
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);

//初始化电机驱动IO为输出方式
pinMode(Left_motor, OUTPUT); // PIN 8
pinMode(Left_motor_pwm, OUTPUT); // PIN 9 (PWM)
pinMode(Right_motor_pwm, OUTPUT); // PIN 10 (PWM)
pinMode(Right_motor, OUTPUT); // PIN 11
pinMode(remoteControlPin, INPUT); // 红外遥控接收引脚 A4
pinMode(buzzerPin, OUTPUT); // 蜂鸣器输出 A3
IrReceiver.begin(remoteControlPin, ENABLE_LED_FEEDBACK); // Start 红外接收功能
Serial.begin(9600); // 用于调试
}

// 小车前进函数
void moveForward() {
digitalWrite(Right_motor, LOW); // 右电机前进
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, LOW); // 左电机前进
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 小车刹车函数
void brake() {
digitalWrite(Right_motor_pwm, LOW); // 右电机PWM 调速输出0
analogWrite(Right_motor_pwm, 0); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor_pwm, LOW); //左电机PWM 调速输出0
analogWrite(Left_motor_pwm, 0); //PWM比例0~255调速，左右轮差异略增减
}

// 小车左转函数
void left() {
digitalWrite(Right_motor, LOW); // 右电机前进
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, LOW); // 左电机前进
analogWrite(Left_motor_pwm, 0); //PWM比例0~255调速，左右轮差异略增减
}

// 小车原地左转函数
void spin_left() {
digitalWrite(Right_motor, LOW); // 右电机前进
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, HIGH); // 左电机后退
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 小车右转函数
void right() {
digitalWrite(Right_motor, LOW); // 右电机不转
analogWrite(Right_motor_pwm, 0); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, LOW); // 左电机前进
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 小车原地右转函数
void spin_right() {
digitalWrite(Right_motor, HIGH); // 右电机后退
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, LOW); // 左电机前进
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 小车后退函数
void moveBackward() {
digitalWrite(Right_motor, HIGH); // 右电机后退
analogWrite(Right_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor, HIGH); // 左电机后退
analogWrite(Left_motor_pwm, pwm_value); //PWM比例0~255调速，左右轮差异略增减
}

// 检测红外遥控信号
void detectRemoteControl() {
if (IrReceiver.decode()) { //如果接收到红外按键信号
car_cmd = IrReceiver.decodedIRData.decodedRawData; //赋值
}
IrReceiver.resume(); // Enable receiving of the next value
}

// 发出 “滴” 的一声，持续 200 毫秒
void beep() {
digitalWrite(buzzerPin, HIGH);
delay(200);
digitalWrite(buzzerPin, LOW);
}

// 每按一次加速键，速度加10，并且响一声
void acceleration() {
if(pwm_value <= 240){
pwm_value = pwm_value + 10;
beep();
}
if(car_state == forward_car )//前进
moveForward();
if (car_state == back_car)//后退
moveBackward();//后退
if (car_state == left_car)//左转
left();//左转
if (car_state == right_car)//右转
right();//右转
if (car_state == spin_left_car)//原地左转
spin_left();//原地左转
if (car_state ==spin_right_car)//原地右转
spin_right();//原地右转
}

// 每按一次减速键，速度减10，并且响一声
void deceleration() {
if(pwm_value >= 10){
pwm_value = pwm_value - 10;
beep();
}
if(car_state == forward_car )//前进
moveForward();
if (car_state == back_car)//后退
moveBackward();//后退
if (car_state == left_car)//左转
left();//左转
if (car_state == right_car)//右转
right();//右转
if (car_state == spin_left_car)//原地左转
spin_left();//原地左转
if (car_state ==spin_right_car)//原地右转
spin_right();//原地右转
}

// 红外遥控 or 超声跟随
void switch_carMode() {

if(car_cmd == switch_mode){ //红外遥控 or 超声跟随 or ......
if(mode_volue == 1){
mode_volue=2;//超声跟随
beep();
}
else{
mode_volue=1;//红外遥控
beep();
beep();
}
}

}


// 获取超声波测量距离
int getDistance() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

long duration = pulseIn(echoPin, HIGH);
int distance = duration * 0.034 / 2; // 计算距离（厘米）

return distance;
}

void follow_mode() {

int distance = getDistance();
Serial.print("Distance: ");
Serial.println(distance);
if (distance <= maxDistance && distance >= minDistance) {
if (distance > followDistance + 5) {
// 目标距离过远，向前移动
moveForward();
Serial.println("Moving Forward");
}
else if (distance < followDistance - 5) {
// 目标距离过近，向后移动
moveBackward();
Serial.println("Moving Backward");
}
else {
// 保持适当距离，停止移动
brake();
Serial.println("Stopped");
}
}
else {
// 超出有效范围，停止移动
brake();
Serial.println("Out of range");
}
delay(100); // 控制循环速度
}

void remote_mode() {
if(car_cmd == forward_car){//前进
moveForward();//前进
car_state = car_cmd;
}
if(car_cmd == back_car){//后退
moveBackward();//后退
car_state = car_cmd;
}
if(car_cmd == left_car){//左转
left();//左转
car_state = car_cmd;
}
if(car_cmd == right_car){//右转
right();//右转
car_state = car_cmd;
}
if(car_cmd == stop_car)//停车
brake();//停车
if (car_cmd == spin_left_car){//原地左旋转
spin_left();//原地左旋转
car_state = car_cmd;
}
if (car_cmd == spin_right_car){//原地右旋转
spin_right();//原地右旋转
car_state = car_cmd;
}
if (car_cmd == beep_car)//蜂鸣
beep();//蜂鸣
// if (car_cmd == high_speed_car)//高速
// {pwm_value = 250;//高速，蜂鸣三声
// beep();//蜂鸣
// beep();//蜂鸣
// beep();//蜂鸣
// }
// if (car_cmd == low_speed_car)//低速
// {pwm_value = 100;//低速，蜂鸣两声
// beep();//蜂鸣
// beep();//蜂鸣
// }
if (car_cmd == high_speed_car)//加速
acceleration();//加速
if (car_cmd == low_speed_car)//减速
deceleration();//减速
}

//主循环函数
void loop() {
detectRemoteControl(); //检测红外遥控

switch_carMode();

if(mode_volue == 1){
follow_mode();//超声跟随
}
if(mode_volue == 2){
remote_mode();//遥控
}

}

//============================ BJTU ===========================
// 智能小车超声波实验
//===============================================================
#include int Echo = A1; // Echo回声脚(P2.0)
int Trig =A0; // Trig 触发脚(P2.1)

int Front_Distance = 0;//
int Left_Distance = 0;
int Right_Distance = 0;

int Left_motor=8; //左电机(IN3) 输出0 前进 输出1 后退
int Left_motor_pwm=9; //左电机PWM调速

int Right_motor_pwm=10; // 右电机PWM调速
int Right_motor=11; // 右电机后退(IN1) 输出0 前进 输出1 后退

int key=A2;//定义按键 A2 接口
int beep=A3;//定义蜂鸣器 A3 接口
const int remoteControlPin = A4; // 红外遥控接收引脚
long car_cmd=-1; //小车收到的红外遥控指令变量

int servopin=2;//设置舵机驱动脚到数字口2
int myangle;//定义角度变量
int pulsewidth;//定义脉宽变量
int val;
const long angle_car = 0xE718FF00;//按键2,前进
int angle_value=0;
unsigned long lastPulse = 0; // 舵机PWM计时

void setup()
{
//Serial.begin(9600); // 初始化串口
//初始化电机驱动IO为输出方式
pinMode(Left_motor,OUTPUT); // PIN 8
pinMode(Left_motor_pwm,OUTPUT); // PIN 9 (PWM)
pinMode(Right_motor_pwm,OUTPUT);// PIN 10 (PWM)
pinMode(Right_motor,OUTPUT);// PIN 11 (PWM)
pinMode(key,INPUT);//定义按键接口为输入接口
pinMode(beep,OUTPUT);
pinMode(remoteControlPin, INPUT); // 红外遥控接收引脚 A4

//初始化超声波引脚
pinMode(Echo, INPUT); // 定义超声波输入脚
pinMode(Trig, OUTPUT); // 定义超声波输出脚
pinMode(servopin,OUTPUT);//设定舵机接口为输出接口
IrReceiver.begin(remoteControlPin, ENABLE_LED_FEEDBACK); // Start 红外接收功能
//servopulse(servopin,angle_value);//模拟产生PWM
Serial.begin(9600); // 用于调试

}

// 检测红外遥控信号
void detectRemoteControl() {
if (IrReceiver.decode()) { //如果接收到红外按键信号
car_cmd = IrReceiver.decodedIRData.decodedRawData; //赋值
}
IrReceiver.resume(); // Enable receiving of the next value
}

//=======================智能小车的基本动作=========================
//void run(int time) // 前进
void run() // 前进
{
digitalWrite(Right_motor,LOW); // 右电机前进
analogWrite(Right_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor,LOW); // 左电机前进
analogWrite(Left_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
//delay(time * 100); //执行时间，可以调整

}

void brake(int time) //刹车，停车
{
digitalWrite(Right_motor_pwm,LOW); // 右电机PWM 调速输出0
analogWrite(Right_motor_pwm,0);//PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor_pwm,LOW); //左电机PWM 调速输出0
analogWrite(Left_motor_pwm,0);//PWM比例0~255调速，左右轮差异略增减
delay(time * 100);//执行时间，可以调整
}

void left(int time) //左转(左轮不动，右轮前进)
//void left() //左转(左轮不动，右轮前进)
{
digitalWrite(Right_motor,LOW); // 右电机前进
analogWrite(Right_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor,LOW); // 左电机前进
analogWrite(Left_motor_pwm,0);//PWM比例0~255调速，左右轮差异略增减
delay(time * 100); //执行时间，可以调整
}

void spin_left(int time) //左转(左轮后退，右轮前进)
{
digitalWrite(Right_motor,LOW); // 右电机前进
analogWrite(Right_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor,HIGH); // 左电机后退
analogWrite(Left_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
delay(time * 100); //执行时间，可以调整
}

void right(int time)
//void right() //右转(右轮不动，左轮前进)
{
digitalWrite(Right_motor,LOW); // 右电机不转
analogWrite(Right_motor_pwm,0);//PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor,LOW); // 左电机前进
analogWrite(Left_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
delay(time * 100); //执行时间，可以调整
}

void spin_right(int time) //右转(右轮后退，左轮前进)
{
digitalWrite(Right_motor,HIGH); // 右电机后退
analogWrite(Right_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor,LOW); // 左电机前进
analogWrite(Left_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
delay(time * 100); //执行时间，可以调整
}

void back(int time) //后退
{
digitalWrite(Right_motor,HIGH); // 右电机后退
analogWrite(Right_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
digitalWrite(Left_motor,HIGH); // 左电机后退
analogWrite(Left_motor_pwm,150);//PWM比例0~255调速，左右轮差异略增减
delay(time * 100); //执行时间，可以调整
}
//==========================================================

void keysacn()//按键扫描
{
int val;
val=digitalRead(key);//读取数字7 口电平值赋给val
while(!digitalRead(key))//当按键没被按下时，一直循环
{
val=digitalRead(key);//此句可省略，可让循环跑空
}
while(digitalRead(key))//当按键被按下时
{
delay(10); //延时10ms
val=digitalRead(key);//读取数字7 口电平值赋给val
if(val==HIGH) //第二次判断按键是否被按下
{
digitalWrite(beep,HIGH); //蜂鸣器响
while(!digitalRead(key)) //判断按键是否被松开
digitalWrite(beep,LOW); //蜂鸣器停止
}
else
digitalWrite(beep,LOW); //蜂鸣器停止
}
}

float Distance_test() // 量出前方距离
{
digitalWrite(Trig, LOW); // 给触发脚低电平2μs
delayMicroseconds(2);
digitalWrite(Trig, HIGH); // 给触发脚高电平10μs，这里至少是10μs
delayMicroseconds(10);
digitalWrite(Trig, LOW); // 持续给触发脚低电
float Fdistance = pulseIn(Echo, HIGH); // 读取高电平时间(单位：微秒)
Fdistance= Fdistance/58; //为什么除以58等于厘米， Y米=（X秒*344）/2
// X秒=（ 2*Y米）/344 ==》X秒=0.0058*Y米 ==》厘米=微秒/58
//Serial.print("Distance:"); //输出距离（单位：厘米）
//Serial.println(Fdistance); //显示距离
//Distance = Fdistance;
return Fdistance;
}


void servopulse(int servopin,int myangle)/*定义一个脉冲函数，用来模拟方式产生PWM值舵机的范围是0.5MS到2.5MS 1.5MS 占空比是居中周期是20MS*/
{
pulsewidth=(myangle*11)+500;//将角度转化为500-2480 的脉宽值 这里的myangle就是0-180度 所以180*11+50=2480 11是为了换成90度的时候基本就是1.5MS
digitalWrite(servopin,HIGH);//将舵机接口电平置高 90*11+50=1490uS 就是1.5ms
delayMicroseconds(pulsewidth);//延时脉宽值的微秒数 这里调用的是微秒延时函数
digitalWrite(servopin,LOW);//将舵机接口电平置低
// delay(20-pulsewidth/1000);//延时周期内剩余时间 这里调用的是ms延时函数
delay(20-(pulsewidth*0.001));//延时周期内剩余时间 这里调用的是ms延时函数
}

void front_detection()
{
//此处循环次数减少，为了增加小车遇到障碍物的反应速度
for(int i=0;i<=5;i++) //产生PWM个数，等效延时以保证能转到响应角度
{
servopulse(servopin,90);//模拟产生PWM
}
Front_Distance = Distance_test();
//Serial.print("Front_Distance:"); //输出距离（单位：厘米）
// Serial.println(Front_Distance); //显示距离
//Distance_display(Front_Distance);
}

void left_detection()
{
for(int i=0;i<=15;i++) //产生PWM个数，等效延时以保证能转到响应角度
{
servopulse(servopin,175);//模拟产生PWM
}
Left_Distance = Distance_test();
//Serial.print("Left_Distance:"); //输出距离（单位：厘米）
//Serial.println(Left_Distance); //显示距离
}

void right_detection()
{
for(int i=0;i<=15;i++) //产生PWM个数，等效延时以保证能转到响应角度
{
servopulse(servopin,5);//模拟产生PWM
}
Right_Distance = Distance_test();
//Serial.print("Right_Distance:"); //输出距离（单位：厘米）
//Serial.println(Right_Distance); //显示距离
}
//===========================================================

void generateServoPWM(int myangle) {
unsigned long currentTime = micros();
int pulseWidth = map(myangle, 0, 180, 500, 2500); // 计算高电平时间

if (currentTime - lastPulse >= 20000) { // 20ms周期
digitalWrite(servopin, HIGH);
lastPulse = currentTime;
} else if (currentTime - lastPulse >= pulseWidth) {
digitalWrite(servopin, LOW);
}
}


void loop()
{
detectRemoteControl();
if (car_cmd == angle_car){//增加角度
car_cmd = 0;
angle_value = angle_value+10;
angle_value = constrain(angle_value, 0, 180); // 限制角度范围
Serial.println(angle_value);
//if (angle_value == 190)
//angle_value=0;
generateServoPWM(angle_value);//模拟产生PWM
}

}