0.基础知识
- 如果该引脚通过pinMode()设置为输出模式（OUTPUT），您可以通过digitalWrite()语句将该引脚设置为HIGH（5伏特）或LOW（0伏特/GND）。
1.舵机
arduino控制多个舵机，舵机库(Servo)的使用
https://blog.csdn.net/wengxiezhen2671/article/details/105346386
1.ESP8266+Blinker 控制两个舵机
#include <Servo.h>
#define BLINKER_WIFI
#include <Blinker.h>
char auth[] = "c6a323f3c622";
char ssid[] = "Liu";
char pswd[] = "88888888";
BlinkerButton Button1("btn1");
BlinkerButton Button2("btn2");
Servo myservo1,myservo2;
BlinkerSlider Slider1("servo1_max"); //滑块1 控制舵机到滑块指定的角度
BlinkerSlider Slider2("servo2_max"); //滑块1 控制舵机到滑块指定的角度
int servo1_max,a1;
int servo2_max,a2;
void button1_callback(const String & state)
{
BLINKER_LOG("get button state: ", servo1_max);
myservo1.write(0);
Blinker.vibrate();
}
void button2_callback(const String & state)
{
BLINKER_LOG("get button state: ", servo2_max);
myservo2.write(0);
Blinker.vibrate();
}
void slider1_callback(int32_t value)//这个是滑块程序1
{
servo1_max = value*2;
a1= map(servo1_max,0,180,1000,2000);
myservo1.writeMicroseconds(a1);
Blinker.vibrate(); //使手机震动
Blinker.delay(1000);
BLINKER_LOG("get slider value: ", value);
}
void slider2_callback(int32_t value)//这个是滑块程序2
{
servo2_max = value*2;
a2= map(servo2_max,0,180,1000,2000);
myservo2.writeMicroseconds(a2);
Blinker.vibrate(); //使手机震动
Blinker.delay(1000);
BLINKER_LOG("get slider value: ", value);
}
void setup()
{
Serial.begin(115200);
BLINKER_DEBUG.stream(Serial);
Blinker.begin(auth, ssid, pswd);//以上关于8266芯片的初始化
Button1.attach(button1_callback);
Button2.attach(button2_callback);
Slider1.attach(slider1_callback);
Slider2.attach(slider2_callback);
myservo1.attach(5); //将舵机设置在D1引脚
myservo2.attach(2); //将舵机设置在D4引脚
}
void loop()
{
Blinker.run();
}
2.直流电机
（1）ardinuo uno + 静态
const byte IN4 = 4;
const byte IN3 = 3;
const byte IN2 = 2;
const byte IN1 = 1;
void Lshun(){
digitalWrite(IN4,LOW);
digitalWrite(IN3,HIGH);
}
void LNI(){
digitalWrite(IN3,LOW);
digitalWrite(IN4,HIGH);
}
void Rshun(){
digitalWrite(IN2,LOW);
digitalWrite(IN1,HIGH);
}
void RNI(){
digitalWrite(IN1,LOW);
digitalWrite(IN2,HIGH);
}
void setup() {
pinMode(IN4,OUTPUT); //声明电机控制引脚为数字引脚
pinMode(IN3,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN1,OUTPUT);
}
void loop() {
Lshun();
//LNI();
Rshun();---------------++
//RNI();
}
（2）ESP8266 + 直流电机
#define BLINKER_WIFI
#include <Blinker.h>
char auth[] = "79f6a45ea586";
char ssid[] = "Liu";
char pswd[] = "88888888";
// 新建组件对象
BlinkerButton Button1("Lopen");
void L() //正转
{
digitalWrite(5,HIGH); //D1
digitalWrite(4,LOW); //D2
}
void LClose() //关
{
digitalWrite(5,LOW); //D1
digitalWrite(4,LOW); //D2
}
// 按下按键即会执行该函数
void button1_callback(const String & state) {
BLINKER_LOG("get button state: ", state);
if (state=="on") {
L();
// 反馈开关状态
Button1.print("on");
} else if(state=="off"){
LClose() ;
// 反馈开关状态
Button1.print("off");
}
}void button1_callback(const String & state) {
BLINKER_LOG("get button state: ", state);
digitalWrite(LED, !digitalRead(LED));
if(state == "on")
{
digitalWrite(LED,LOW);
Button1.print("on");
}
else if(state == "off")
{
digitalWrite(LED,HIGH);
Button1.print("off");
}
}
void setup() {
// 初始化串口
Serial.begin(115200);
// 初始化有LED的IO
pinMode(5, OUTPUT);
digitalWrite(5, LOW);
pinMode(4,OUTPUT);
digitalWrite(4, LOW);
// 初始化blinker
Blinker.begin(auth, ssid, pswd);
Button1.attach(button1_callback);
}
void loop() {
Blinker.run();
}
直流电机调速
analogWrite(enA, 255);
//For PWM maximum possible values are 0 to 255
//Arduino输出引脚9和3均启用PWM。
//在Arduino UNO控制器中，5号引脚和6号引脚的PWM频率为980Hz。在一些基于ATmega168和ATmega328的Arduino控制器中，analogWrite()函数支持以下引脚: 3, 5, 6, 9, 10, 11。
//在调用analogWrite()函数前，您无需使用pinMode()函数来设置该引脚。
3.压力传感器
const int senpin = A0;
int value = 0;
void setup()
{
//pinMode();
Serial.begin(9600);
}
void loop()
{
value = analogRead(senpin);
Serial.println(value);
value = map(value,0,10000);
delay(1000);
}
4.湿度传感器
/*#define BLINKER_WIFI
#include <Blinker.h>
#include <DHT.h>
char auth[] = "0623a7f425da";
char ssid[] = "Liu";
char pswd[] = "88888888";
BlinkerNumber HUMI("humi");
#define DHTPIN A0
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
DHT dht(DHTPIN, DHTTYPE);
float humi_read = 0;
void heartbeat()
{
HUMI.print(humi_read);
}
void setup()
{
Serial.begin(9600);
BLINKER_DEBUG.stream(Serial);
BLINKER_DEBUG.debugAll();
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, LOW);
Blinker.begin(auth, ssid, pswd);
Blinker.attachHeartbeat(heartbeat);
dht.begin();
}
void loop()
{
Blinker.run();
float h = dht.readHumidity();
if (isnan(h))
{
BLINKER_LOG("Failed to read from DHT sensor!");
}
else
{
BLINKER_LOG("Humidity: ", h, " %");
humi_read = h;
}
Blinker.delay(2000);
}*/
#define soilPin A0
//存储中间值
int soilValue;
//定义土壤湿度
int soilMoisture;
void setup()
{
Serial.begin(9600);
//这句代码写不写都可
//pinMode(soilPin, INPUT);
}
void loop()
{
//读取土壤传感器上的电压值
soilValue = analogRead(soilPin);
//把电压值按照[0,1023]映射到[100,0]
soilMoisture = map(soilValue,0,1023,100,0);
//每隔一秒输出一次值
delay(1000);
Serial.print("soilMositure: ");
Serial.print(soilMoisture);
Serial.println("%");
}
5.Blinker点灯APP
(1)按键类型
- 普通按键
每次按下该组件，都会发送值为tap的消息，如：
{"btn-abc":"tap"}
-
开关按键
按键组件本身会保存开关状态，默认为off，当按下时会发送值为on的消息，如：
{"btn-abc":"on"}
保存的状态为on时，按下会发送值为off的消息：
{"btn-abc":"off"}
设备端可以发送指令改变当前按键的开关状态
- 自定义
可以自定义按下按键发送的指令内容，如
{"btn-abc":"自定义的内容"}
当用户按下按键时，这些指令会经由中介服务器转发到设备，设备上运行的blinker支持库可以解析这些指令，并执行开发者自定义的动作。
(2)按键与状态反馈
数据组件
Number1.print(counter);
按键组件(改变UI状态)
blinker提供了改写心跳包内容的方法，使用此方法可将一些数据放置在心跳包中返回，该方法可用于数据同步、状态查询。
blinker设备设计原则：设备端不主动发送数据，一切反馈都是由客户端（APP）发起。这样设计可以节约服务器资源，避免浪费。
示例程序:
#define BLINKER_WIFI
#include <Blinker.h>
char auth[] = "Your Device Secret Key";
char ssid[] = "Your WiFi network SSID or name";
char pswd[] = "Your WiFi network WPA password or WEP key";
// 新建组件对象
BlinkerButton Button1("btn-abc");
// 按下按键即会执行该函数
void button1_callback(const String & state) {
BLINKER_LOG("get button state: ", state);
}
// 心跳包函数
void heartbeat() {
Button1.icon("fas fa-lightbulb");
Button1.color("#fddb00");
Button1.text("关灯","打开啦");
Button1.print("on");
}
void setup() {
// 初始化串口
Serial.begin(115200);
// 初始化有LED的IO
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, HIGH);
// 初始化blinker
Blinker.begin(auth, ssid, pswd);
Button1.attach(button1_callback);
//注册一个心跳包
Blinker.attachHeartbeat(heartbeat);
}
void loop() {
Blinker.run();
}
使用以上示例，可在进入设备控制页面后，初始化界面上的UI。
蚯蚓
ESP8266-1
/*************************************************************************************/
/******************************* ESP8266 NodeMcu ***********************************/
/***具体功能： ***/
/* (1).控制直流电机1，钻头（Blinker实现开关） ***/
/* (2).控制直流电机2，3，转向（Blinker实现每按一次转动某一小的角度）（控制每按一次电机通电200ms）**/
/* 包括正反转4个函数 **/
/* (3).反馈湿度传感器的数值，（Blinker心跳包显示） **/
#define BLINKER_WIFI
#include <Blinker.h>
//#define A0 A0 //湿度传感器模拟输出口
const int D0 = 16; //钻头电机1
const int D1 = 5; //钻头电机2
const int D2 = 4; //上下转向1
const int D3 = 0; //上下转向2
const int D4 = 2; //左右转向1
const int D5 = 14; //左右转向2
char auth[] = "0623a7f425da";
char ssid[] = "Liu";
char pswd[] = "88888888";
BlinkerButton ButtonZhuan("ZhuanSwitch");
BlinkerButton Button2_1("up");
BlinkerButton Button2_2("down");
BlinkerButton Button3_1("left");
BlinkerButton Button3_2("right");
BlinkerNumber HUMI("humi"); //定义湿度数据键名
//************************************//
int humi_read = 0; //温湿度变量
//心跳函数
void heartbeat()
{
HUMI.print(humi_read); //点灯输出湿度
}
//**************** 转向 ********************//
void button2_1_callback(const String & state)
{
if(state=="press"){
up();
}
else if(state == "pressup"){
Stop();
}
}
void button2_2_callback(const String & state)
{
if(state=="press"){
down();
}
else if(state == "pressup"){
Stop();
}
}
void button3_1_callback(const String & state)
{
if(state=="press"){
left();
}
else if(state == "pressup"){
Stop();
}
}
void button3_2_callback(const String & state)
{
if(state=="press"){
right();
}
else if(state == "pressup"){
Stop();
}
}
//***************钻头*******************//
void buttonZhuan_callback(const String &state)
{
BLINKER_LOG("get button state:",state);
if(state == "on")
{
digitalWrite(D0,LOW);
digitalWrite(D1,HIGH);
ButtonZhuan.print("on");
}
else if(state == "off")
{
digitalWrite(D0,HIGH);
digitalWrite(D1,LOW);
ButtonZhuan.print("off");
}
}
void up(){ //向上
digitalWrite(D2,HIGH);
digitalWrite(D3,LOW);
Blinker.delay(100);
}
void down(){ //向下
digitalWrite(D3,HIGH);
digitalWrite(D2,LOW);
Blinker.delay(100);
}
void right(){ //向右
digitalWrite(D4,HIGH);
digitalWrite(D5,LOW);
Blinker.delay(100);
}
void left(){ //向左
digitalWrite(D5,HIGH);
digitalWrite(D4,LOW);
Blinker.delay(100);
}
void Stop(){ //停止
digitalWrite(D2,LOW);
digitalWrite(D3,LOW);
digitalWrite(D4,LOW);
digitalWrite(D5,LOW);
Blinker.delay(100);
}
void setup()
{
Serial.begin(115200);
BLINKER_DEBUG.stream(Serial);
Blinker.attachHeartbeat(heartbeat); //心跳包
Blinker.begin(auth, ssid, pswd);//以上关于8266芯片的初始化
pinMode(A0,INPUT);
pinMode(D0,OUTPUT); digitalWrite(D0, LOW);
pinMode(D1,OUTPUT); digitalWrite(D1, LOW);
pinMode(D2,OUTPUT); digitalWrite(D2, LOW);
pinMode(D3,OUTPUT); digitalWrite(D3, LOW);
pinMode(D4,OUTPUT); digitalWrite(D4, LOW);
pinMode(D5,OUTPUT); digitalWrite(D5, LOW);
Button2_1.attach(button2_1_callback); //向上组件
Button2_2.attach(button2_2_callback); //向下组件
Button3_1.attach(button3_1_callback); //向左组件
Button3_2.attach(button3_2_callback); //向右组件
ButtonZhuan.attach(buttonZhuan_callback); //钻头组件
}
void loop()
{
Blinker.run();
float h0 = analogRead(A0);
float h = map(h0,300,1024,100,0);
BLINKER_LOG("Humidity: ", h, " %"); //打印输出调试信息
humi_read = h;
Blinker.delay(1000);
}
ESP8266—2
第一版
/*********************************************************************************************/
/*********************************** ardinuo uno *********************************************/
/* 具体功能： ****/
/*
4个直流电机
(两个伸缩，两个膨胀)
*/
const int PINshen1_1 = 2;
const int PINshen1_2 = 3;
const int PINshen2_1 = 4;
const int PINshen2_2 = 5;
const int PINpeng1_1 = 6;
const int PINpeng1_2 = 7;
const int PINpeng2_1 = 8;
const int PINpeng2_2 = 9;
const int fsrpeng1_Pin = A0; // A0 接口接压力传感器
const int fsrpeng2_Pin = A1; // A1 接口接压力传感器
/************把压力传到A0,A1口************/
const int MinUp = 0 ,MaxDown = 0;
int peng1_Reading;
int peng2_Reading;
/********* 电机 **********/
void dianjizhuan(int pin1,int pin2)
{
pinMode(pin1,HIGH);
pinMode(pin2,LOW );
}
void dianjiStop()
{
pinMode(2,LOW);
pinMode(3,LOW);
pinMode(4,LOW);
pinMode(5,LOW);
pinMode(6,LOW);
pinMode(7,LOW);
pinMode(8,LOW);
pinMode(9,LOW);
}
/********** 单元类 ***********/
class UNIT
{
public:
int pin1,pin2,pin3,pin4;
void pengzhangUp(int Reading);
void pengzhangDown(int Reading);
void shen();
void suo();
};
/************* 膨胀 *************/
void UNIT::pengzhangUp(int Reading)
{
if(Reading < MinUp)
{
dianjizhuan(pin1,pin2);
}
else
dianjiStop();
}
void UNIT::pengzhangDown(int Reading)
{
if(Reading > MaxDown)
{
dianjizhuan(pin2,pin1);
}
else
dianjiStop();
}
/*********** 伸缩 ****************/
void UNIT::shen()
{
dianjizhuan(pin3,pin4);
delay(5000); //电机转动5秒
}
void UNIT::suo()
{
dianjizhuan(pin4,pin3);
delay(5000); //电机转动5秒
}
/************ 初始化 ***************/
UNIT unit1,unit2;
void setup(void)
{
Serial.begin(9600);
unit1.pin1 = PINshen1_1,unit1.pin2 =PINshen1_2,unit1.pin3 =PINpeng1_1,unit1.pin4 =PINpeng1_2;
unit2.pin1 = PINshen2_1,unit2.pin2 =PINshen2_2,unit2.pin3 =PINpeng2_1,unit2.pin4 =PINpeng2_2;
}
void loop(void)
{
peng1_Reading = analogRead(fsrpeng1_Pin);
peng2_Reading = analogRead(fsrpeng2_Pin);
/******* 步骤一(第一单元膨胀机构膨胀) *******/
while(peng1_Reading>MinUp )
unit1.pengzhangUp(peng1_Reading);
/******* 步骤二(第一单元伸缩机构伸) *******/
unit1.shen();
/******* 步骤三(第一单元膨胀机构收缩) *******/
while(peng1_Reading>MaxDown )
unit1.pengzhangDown(peng1_Reading);
/******* 步骤四(第二单元膨胀) *******/
while(peng2_Reading>MinUp)
unit2.pengzhangUp(peng2_Reading);
/******* 步骤五(第一单元伸缩机构缩/第二单元伸缩机构伸) ********/
unit1.suo();
unit2.shen();
/******* 步骤六(第一单元膨胀机构膨胀) *******/
while(peng1_Reading>MinUp )
unit1.pengzhangUp(peng1_Reading);
/******* 步骤七(第二单元膨胀机构收缩) *******/
while(peng2_Reading > MaxDown )
unit2.pengzhangDown(peng2_Reading);
/******* 步骤八(第二单元伸缩机构缩) *******/
unit2.suo();
}
/*************压力数据传回终端************/
/*Serial.print("Analog reading = ");
Serial.print(fsrReading);
if (fsrReading < 10) {
Serial.println(" - No pressure");
} else if (fsrReading < 200) {
Serial.println(" - Light touch");
} else if (fsrReading < 500) {
Serial.println(" - Light squeeze");
} else if (fsrReading < 800) {
Serial.println(" - Medium squeeze");
} else {
Serial.println(" - Big squeeze");
}
delay(1000);
*/
第二版
/*********************************************************************************************/
/*********************************** ardinuo uno *********************************************/
/* 具体功能： ****/
/*
4个直流电机
(两个伸缩，两个膨胀)
*/
const int PINshen1_1 = 2;
const int PINshen1_2 = 3;
const int PINshen2_1 = 4;
const int PINshen2_2 = 5;
const int PINpeng1_1 = 6;
const int PINpeng1_2 = 7;
const int PINpeng2_1 = 8;
const int PINpeng2_2 = 9;
const int fsrpeng1_Pin = A0; // A0 接口接压力传感器
const int fsrpeng2_Pin = A1; // A1 接口接压力传感器
/************把压力传到A0,A1口************/
const int MinUp = 500 ,MaxDown = 0;
int peng1_Reading;
int peng2_Reading;
double tpinHIGH1,tpinHIGH2; //记录第一、二单元膨胀时间(高电平时间)
double tya; //记录压力传感器大于max的时间
bool Step1=false,Step2=false,Step3=false,Step4=false, //用来进行哪个步骤
Step5=false,Step6=false,Step7=false,Step8=false;
//int steppeng = 1; //当为奇数时即为第一单元膨胀，为偶数时为第二单元膨胀
//int stepshen = 1; //当为奇数时即为第一单元伸缩，为偶数时为第二单元伸缩
//int PengNo1,PengNo2;
/********* 电机 **********/
void dianjizhuan(int pin1,int pin2)
{
digitalWrite(pin1,HIGH);
digitalWrite(pin2,LOW );
}
void dianjiStop()
{
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
return false;
}
/********** 单元类 ***********/
class UNIT
{
public:
int pin1,pin2,pin3,pin4;
void pengzhangUp(int Reading);
void pengzhangDown(int Reading);
void shen();
void suo();
};
/************* 膨胀 *************/
void UNIT::pengzhangUp(int Reading)
{
if(Reading < MinUp)
{
tya = 0; //每次小于max之后都会先把 大于max的时间置为零
dianjizhuan(pin1,pin2);
delay(5); //延迟5ms
if(Step1 == true)
tpinHIGH1 +=1; //记录膨胀电机高电平时间
else
tpinHIGH2 +=1;
}
else{
dianjiStop();
delay(5);
tya += 1; //每次都会记录大于max的时间+5毫秒
}
if(tya >= 200) //就是持时间在1秒以上时，跳到下一个步骤，
{
dianjiStop();
if(Step1 == true) // if( (stepshen++)%2 == 1 ) //奇数时即为第一单元伸缩，为偶数时为第二单元伸缩
Step1 = false,Step2 = true ;
else if(Step4 == true)
Step4 = false,Step5 = true ;
else
Step7 = false,Step8 = true ;
}
}
/************** 收缩 *************/
void UNIT::pengzhangDown(int Reading)
{
dianjizhuan(pin2,pin1);
if(Step3 == true)
{
delay(tpinHIGH1);
tpinHIGH1 = 0;
Step3 = false,Step4 = true;
}
else
{ //其实是step7 = true
delay(tpinHIGH2);
tpinHIGH2 = 0;
Step7 = false,Step8 = true;
}
}
/*********** 伸缩 ****************/
void UNIT::shen()
{
dianjizhuan(pin3,pin4);
delay(5000); //电机转动5秒
}
void UNIT::suo()
{
dianjizhuan(pin4,pin3);
delay(5000); //电机转动5秒
}
/************ 初始化 ***************/
UNIT unit1,unit2;
void setup(void)
{
Serial.begin(9600);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
unit1.pin1 = PINshen1_1,unit1.pin2 =PINshen1_2,unit1.pin3 =PINpeng1_1,unit1.pin4 =PINpeng1_2;
unit2.pin1 = PINshen2_1,unit2.pin2 =PINshen2_2,unit2.pin3 =PINpeng2_1,unit2.pin4 =PINpeng2_2;
}
void loop(void)
{
peng1_Reading = analogRead(fsrpeng1_Pin);
peng2_Reading = analogRead(fsrpeng2_Pin);
/******* 步骤一(第一单元膨胀机构膨胀) *******/
if(Step1 == true)
{
unit1.pengzhangUp(peng1_Reading);
}
/******* 步骤二(第一单元伸缩机构伸) *******/
if(Step2 == true)
{
unit1.shen();
Step2 == false,Step3 == true;
}
/******* 步骤三(第一单元膨胀机构收缩) *******/
if(Step3 == true)
{
unit1.pengzhangDown(peng1_Reading);
}
/******* 步骤四(第二单元膨胀) *******/
if(Step4 == true)
{
unit2.pengzhangUp(peng2_Reading);
}
/******* 步骤五(第一单元伸缩机构缩/第二单元伸缩机构伸) ********/
if(Step5 = true)
{
unit1.suo();
unit2.shen();
Step5 == false,Step6 == true;
}
/******* 步骤六(第一单元膨胀机构膨胀) *******/
if(Step6 == true)
{
unit1.pengzhangUp(peng1_Reading);
}
/******* 步骤七(第二单元膨胀机构收缩) *******/
if(Step7 == true)
{
unit2.pengzhangDown(peng2_Reading);
}
/******* 步骤八(第二单元伸缩机构缩) *******/
if(Step8 == true)
{
unit2.suo();
Step8 = false,Step1 = true;
}
}
第三版
/*********************************************************************************************/
/*********************************** ardinuo uno *********************************************/
/* 具体功能： ****/
/*
4个直流电机
(两个伸缩，两个膨胀)
*/
const int PINshen1_1 = 2;
const int PINshen1_2 = 3;
const int PINshen2_1 = 4;
const int PINshen2_2 = 5;
const int PINpeng1_1 = 6;
const int PINpeng1_2 = 7;
const int PINpeng2_1 = 8;
const int PINpeng2_2 = 9;
const int fsrpeng1_Pin = A0; // A0 接口接压力传感器
const int fsrpeng2_Pin = A1; // A1 接口接压力传感器
/************把压力传到A0,A1口************/
const int MinUp = 400 ,MaxDown = 0;
int peng1_Reading=0;
int peng2_Reading=0;
int value,sensorPin;
//unsigned long time1;
//unsigned long time2; //
int tpinHIGH1,tpinHIGH2; //记录第一、二单元膨胀时间(高电平时间)
int tya; //记录压力传感器大于 MinUp 的时间
bool Step1=true,Step2=false,Step3=false,Step4=false, //用来进行哪个步骤
Step5=false,Step6=false,Step7=false,Step8=false;
/********* 电机 **********/
void dianjizhuan(int pin1,int pin2)
{
digitalWrite(pin1,HIGH);
digitalWrite(pin2,LOW );
}
void dianjiStop()
{
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
}
/********** 单元类 ***********/
class UNIT
{
public:
int pin1,pin2,pin3,pin4;
void pengzhangUp(int Reading); //膨胀
void pengzhangDown(int Reading); //收缩
void shen();
void suo();
};
/************* 膨胀 *************/
void UNIT::pengzhangUp(int Reading)
{
if(Reading < MinUp)
{
tya = 0; //每次小于MinUp之后都会先把大于 MinUp 的时间置为零
dianjizhuan(pin1,pin2);
delay(5); //延迟5ms
if(Step1 == true) //用来区分是第一个膨胀还是第二个膨胀
tpinHIGH1 +=1; //累计膨胀电机高电平时间
else
tpinHIGH2 +=1;
}
else{
dianjiStop();
delay(5);
tya += 1; //每次都会记录大于max的时间+5毫秒
}
if(tya >= 200) //就是持时间在200ms*5=1秒以上时，跳到下一个步骤，
{
dianjiStop();
if(Step1 == true) //用来区分是第一个伸缩还是第二个伸缩
Step1 = false,Step2 = true ;
else if(Step4 == true)
Step4 = false,Step5 = true ;
else
Step7 = false,Step8 = true ;
}
}
/************** 收缩 *************/
void UNIT::pengzhangDown(int Reading)
{
dianjizhuan(pin2,pin1);
if(Step3 == true) //此if.......else用来判断是第一个单元的膨胀机构收缩，还是第二个单元的膨胀机构收缩
{
delay(tpinHIGH1*5);
tpinHIGH1 = 0;
Step3 = false,Step4 = true;
}
else
{ //其实是step7 = true
delay(tpinHIGH2*5);
tpinHIGH2 = 0;
Step7 = false,Step8 = true;
}
}
/*********** 伸缩 ****************/
void UNIT::shen()
{
dianjizhuan(pin3,pin4);
delay(1000); //电机转动1秒
dianjiStop();
}
void UNIT::suo()
{
dianjizhuan(pin4,pin3);
delay(1000); //电机转动1秒
dianjiStop();
}
/************ 初始化 ***************/
UNIT unit1,unit2;
void setup(void)
{
Serial.begin(9600);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
unit1.pin1 = PINshen1_1,unit1.pin2 =PINshen1_2,unit1.pin3 =PINpeng1_1,unit1.pin4 =PINpeng1_2;
unit2.pin1 = PINshen2_1,unit2.pin2 =PINshen2_2,unit2.pin3 =PINpeng2_1,unit2.pin4 =PINpeng2_2;
}
void loop(void)
{
peng1_Reading = analogRead(fsrpeng1_Pin);
peng2_Reading = analogRead(fsrpeng2_Pin);
Serial.println(peng1_Reading);
//value = map(value, 0, 1023, 0, 255); //Map value 0-1023 to 0-255 (PWM)
/******* 步骤一(第一单元膨胀机构膨胀) *******/
if(Step1 == true)
{
unit1.pengzhangUp(peng1_Reading);
dianjiStop();
}
/******* 步骤二(第一单元伸缩机构伸) *******/
if(Step2 == true)
{
unit1.shen();
Step2 = false,Step3 = true;
}
/******* 步骤三(第一单元膨胀机构收缩) *******/
if(Step3 == true)
{
unit1.pengzhangDown(peng1_Reading);
}
/******* 步骤四(第二单元膨胀) *******/
if(Step4 == true)
{
unit2.pengzhangUp(peng2_Reading);
}
/******* 步骤五(第一单元伸缩机构缩/第二单元伸缩机构伸) ********/
if(Step5 = true)
{
unit1.suo();
unit2.shen();
Step5 = false,Step6 = true;
}
/******* 步骤六(第一单元膨胀机构膨胀) *******/
if(Step6 == true)
{
unit1.pengzhangUp(peng1_Reading);
}
/******* 步骤七(第二单元膨胀机构收缩) *******/
if(Step7 == true)
{
unit2.pengzhangDown(peng2_Reading);
}
/******* 步骤八(第二单元伸缩机构缩) *******/
if(Step8 == true)
{
unit2.suo();
Step8 = false,Step1 = true;
}
}
第四版
/*********************************************************************************************/
/*********************************** ardinuo uno *********************************************/
/* 具体功能： ****/
/*
4个直流电机
(两个伸缩，两个膨胀)
*/
const int PINshen1_1 = 2;
const int PINshen1_2 = 3;
const int PINshen2_1 = 4;
const int PINshen2_2 = 5;
const int PINpeng1_1 = 6;
const int PINpeng1_2 = 7;
const int PINpeng2_1 = 8;
const int PINpeng2_2 = 9;
const int fsrpeng1_Pin = A0; // A0 接口接压力传感器
const int fsrpeng2_Pin = A1; // A1 接口接压力传感器
/************把压力传到A0,A1口************/
const int MinUp = 400 ,MaxDown = 0;
int peng1_Reading=0;
int peng2_Reading=0;
int value,sensorPin;
unsigned long previousMillis = 0;
unsigned long currentMillis;
int tpinHIGH1,tpinHIGH2; //记录第一、二单元膨胀时间(高电平时间)
int tya; //记录压力传感器大于 MinUp 的时间
bool Step1=true,Step2=false,Step3=false,Step4=false, //用来进行哪个步骤
Step5=false,Step6=false,Step7=false,Step8=false;
/********* 电机 **********/
void dianjizhuan(int pin1,int pin2)
{
digitalWrite(pin1,HIGH);
digitalWrite(pin2,LOW );
}
void dianjiStop()
{
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
}
/********** 单元类 ***********/
class UNIT
{
public:
int pin1,pin2,pin3,pin4;
void pengzhangUp(int Reading); //膨胀
void pengzhangDown(int Reading); //收缩
void shen();
void suo();
};
/************* 膨胀 *************/
void UNIT::pengzhangUp(int Reading)
{
if(Reading < MinUp)
{
tya = 0; //每次小于MinUp之后都会先把大于 MinUp 的时间置为零
dianjizhuan(pin1,pin2);
if( currentMillis - previousMillis == 5 )//延迟5ms delay(5);
{
previousMillis = currentMillis;
if(Step1 == true) //用来区分是第一个膨胀还是第二个膨胀
tpinHIGH1 +=1; //累计膨胀电机高电平时间
else
tpinHIGH2 +=1;
}
previousMillis = currentMillis;
}
else{
dianjiStop();
if( currentMillis - previousMillis == 5 )//延迟5ms delay(5);
{
previousMillis = currentMillis;
tya += 1; //每次都会记录大于max的时间+5毫秒
}
previousMillis = currentMillis;
}
if(tya >= 200) //就是持时间在200ms*5=1秒以上时，跳到下一个步骤，
{
dianjiStop();
if(Step1 == true) //用来区分是第一个伸缩还是第二个伸缩
Step1 = false,Step2 = true ;
else if(Step4 == true)
Step4 = false,Step5 = true ;
else
Step7 = false,Step8 = true ;
}
}
/************** 收缩 *************/
void UNIT::pengzhangDown(int Reading)
{
dianjizhuan(pin2,pin1);
if(Step3 == true) //此if.......else用来判断是第一个单元的膨胀机构收缩，还是第二个单元的膨胀机构收缩
{
if(currentMillis - previousMillis == tpinHIGH1*5) //delay(tpinHIGH1*5);
{
tpinHIGH1 = 0;
Step3 = false,Step4 = true;
}
}
else
{ //其实是step7 = true
if(currentMillis - previousMillis == tpinHIGH1*5) //delay(tpinHIGH2*5);
{
tpinHIGH2 = 0;
Step7 = false,Step8 = true;
}
}
previousMillis = currentMillis;
}
/*********** 伸缩 ****************/
void UNIT::shen()
{
dianjizhuan(pin3,pin4);
if(currentMillis - previousMillis == 1000) //delay(1000); 电机转动1秒
{
previousMillis = currentMillis;
dianjiStop();
}
}
void UNIT::suo()
{
dianjizhuan(pin4,pin3);
if(currentMillis - previousMillis == 1000) //delay(1000); 电机转动1秒
{
previousMillis = currentMillis;
dianjiStop();
}
}
/************ 初始化 ***************/
UNIT unit1,unit2;
void setup(void)
{
Serial.begin(9600);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
unit1.pin1 = PINshen1_1,unit1.pin2 =PINshen1_2,unit1.pin3 =PINpeng1_1,unit1.pin4 =PINpeng1_2;
unit2.pin1 = PINshen2_1,unit2.pin2 =PINshen2_2,unit2.pin3 =PINpeng2_1,unit2.pin4 =PINpeng2_2;
}
void loop(void)
{
peng1_Reading = analogRead(fsrpeng1_Pin);
peng2_Reading = analogRead(fsrpeng2_Pin);
currentMillis = millis();
Serial.println(peng1_Reading);
//value = map(value, 0, 1023, 0, 255); //Map value 0-1023 to 0-255 (PWM)
/******* 步骤一(第一单元膨胀机构膨胀) *******/
if(Step1 == true)
{
unit1.pengzhangUp(peng1_Reading);
dianjiStop();
}
/******* 步骤二(第一单元伸缩机构伸) *******/
if(Step2 == true)
{
unit1.shen();
Step2 = false,Step3 = true;
}
/******* 步骤三(第一单元膨胀机构收缩) *******/
if(Step3 == true)
{
unit1.pengzhangDown(peng1_Reading);
}
/******* 步骤四(第二单元膨胀) *******/
if(Step4 == true)
{
unit2.pengzhangUp(peng2_Reading);
}
/******* 步骤五(第一单元伸缩机构缩/第二单元伸缩机构伸) ********/
if(Step5 = true)
{
unit1.suo();
unit2.shen();
Step5 = false,Step6 = true;
}
/******* 步骤六(第一单元膨胀机构膨胀) *******/
if(Step6 == true)
{
unit1.pengzhangUp(peng1_Reading);
}
/******* 步骤七(第二单元膨胀机构收缩) *******/
if(Step7 == true)
{
unit2.pengzhangDown(peng2_Reading);
}
/******* 步骤八(第二单元伸缩机构缩) *******/
if(Step8 == true)
{
unit2.suo();
Step8 = false,Step1 = true;
}
}
终版
膨胀模块
void UNIT::pengzhangUp(int Reading)
{
if(Reading < MinUp)
{
tiao:
tya1 = 0; //每次小于max之后都会先把 大于max的时间置为零
dianjizhuan(pin1,pin2);
delay(5); //延迟5ms
tpinHIGH1 +=1; //记录膨胀电机高电平时间
}
else{
dianjiStop();
delay(5);
tya1 += 1; //每次都会记录大于max的时间+5毫秒
}
if(tyal >= 200) //就是持时间在1秒以上时，跳到下一个步骤，
{
if( (stepshen++)%2 == 1 ) //奇数时即为第一单元伸缩，为偶数时为第二单元伸缩
Step1 = false,Step2 = true ;
else
Step3 = false,Step4 = true ;
}
}
实验
步骤一：
/*********************************************************************************************/
/*********************************** ardinuo uno *********************************************/
/* 具体功能： ****/
/*
4个直流电机
(两个伸缩，两个膨胀)
(膨胀机构中加两个压力传感器，防止超限)
问题：previousMillis_1 的初始化
1.最开始的时候初始化 weither == flase 一次，然后每次使用膨胀前再false 一次
*/
const int PINshen1_1 = 2;
const int PINshen1_2 = 3;
const int PINshen2_1 = 4;
const int PINshen2_2 = 5;
const int PINpeng1_1 = 6;
const int PINpeng1_2 = 7;
const int PINpeng2_1 = 8;
const int PINpeng2_2 = 9;
int currentMillis; //读取当前时间
bool Whether1;
bool NO1_IForNO_1 = true;
bool NO1_IForNO_2 = true;
bool NO1_IForNO_3 = true;
bool NO1_IForNO_4 = true;
bool NO1_IForNO_5 = true;
bool NO1_IForNO_6 = true;
bool NO1_IForNO_7 = true;
bool NO1_IForNO_8 = true;
bool Step1=true,Step2=false,Step3=false,Step4=false, //用来进行哪个步骤
Step5=false,Step6=false,Step7=false,Step8=false;
/********* 电机 **********/
void dianjizhuan(int pin1,int pin2)
{
digitalWrite(pin1,HIGH);
digitalWrite(pin2,LOW );
}
void dianjiStop()
{
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
digitalWrite(8,LOW);
digitalWrite(9,LOW);
}
/********** 单元类 ***********/
class UNIT
{
public:
int pin1,pin2; //膨胀
int pin3,pin4; //伸缩
unsigned long pengzhang_time; //膨胀电机的时间
unsigned long shensuo_time; //伸缩电机的时间
void pengzhangUp(int currentMillis); //膨胀（传入两个参数: 检测膨胀力度的传感器，检测齿条是否完全收进去的传感器）
void pengzhangDown(int currentMillis); //收缩（传入一个参数:检测齿条是否完全收进去的传感器）
void shen(int currentMillis);
void suo(int currentMillis);
};
/************* 膨胀 *************/
void UNIT::pengzhangUp(int currentMillis)
{
pengzhang_time = currentMillis; //把开始使用电机的时间记录下来
dianjizhuan(pin1,pin2);
}
/************** 收缩 *************/
void UNIT::pengzhangDown(int currentMillis)
{
pengzhang_time = currentMillis; //把开始使用电机的时间记录下来
dianjizhuan(pin2,pin1);
}
/*********** 伸缩 ****************/
void UNIT::shen(int currentMillis)
{
shensuo_time = currentMillis; //把开始使用电机的时间记录下来
dianjizhuan(pin3,pin4);
}
void UNIT::suo(int currentMillis)
{
shensuo_time = currentMillis; //把开始使用电机的时间记录下来
dianjizhuan(pin4,pin3);
}
/************ 初始化 ***************/
UNIT unit1,unit2;
void setup(void)
{
Serial.begin(9600);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
unit1.pin1 = PINshen1_1,unit1.pin2 =PINshen1_2,unit1.pin3 =PINpeng1_1,unit1.pin4 =PINpeng1_2;
unit2.pin1 = PINshen2_1,unit2.pin2 =PINshen2_2,unit2.pin3 =PINpeng2_1,unit2.pin4 =PINpeng2_2;
Whether1 = false;
}
void loop(void)
{
/******* 步骤一(第一单元膨胀机构膨胀) *******/
if(Step1 == true)
{
Serial.println("步骤一(第一单元膨胀机构膨胀)");
currentMillis = millis(); //读取当前的时间
if(NO1_IForNO_1 == true)
{
unit1.pengzhangUp(currentMillis);
NO1_IForNO_1 = false;
NO1_IForNO_2 = true;
}
if(currentMillis - unit1.pengzhang_time >= 1000)
{
dianjiStop();
Step1 = false;
Step2 = true;
}
}
/******* 步骤二(第一单元伸缩机构伸) *******/
if(Step2 == true)
{
Serial.println("步骤二(第一单元伸缩机构伸)");
currentMillis = millis(); //读取当前的时间
if(NO1_IForNO_2 == true)
{
unit1.shen(currentMillis);
NO1_IForNO_2 = false;
NO1_IForNO_3 = true;
}
if(currentMillis - unit1.shensuo_time >= 1000)
{
dianjiStop();
Step2 = false;
Step3 = true;
}
}
/******* 步骤三(第一单元膨胀机构收缩) *******/
if(Step3 == true)
{
Serial.println("步骤三(第一单元膨胀机构收缩)");
currentMillis = millis(); //读取当前的时间
if(NO1_IForNO_3 == true)
{
unit1.pengzhangDown(currentMillis);
NO1_IForNO_3 = false;
NO1_IForNO_4 = true;
}
if(currentMillis - unit1.pengzhang_time >= 1000)
{
dianjiStop();
Step3 = false;
Step4 = true;
}
}
/******* 步骤四(第二单元膨胀) *******/
if(Step4 == true)
{
Serial.println("步骤四(第二单元膨胀)");
currentMillis = millis(); //读取当前的时间
if(NO1_IForNO_4 == true)
{
unit2.pengzhangUp(currentMillis);
NO1_IForNO_4= false;
NO1_IForNO_5 = true;
}
if(currentMillis - unit2.pengzhang_time >= 1000)
{
dianjiStop();
Step4 = false;
Step5 = true;
}
}
/******* 步骤五(第一单元伸缩机构缩/第二单元伸缩机构伸) ********/
if(Step5 == true)
{
Serial.println("步骤五(第一单元伸缩机构缩/第二单元伸缩机构伸)");
currentMillis = millis(); //读取当前的时间
if(NO1_IForNO_5 == true)
{
unit1.suo(currentMillis);
unit2.shen(currentMillis);
NO1_IForNO_5 = false;
NO1_IForNO_6 = true;
}
if(currentMillis - unit1.shensuo_time >= 1000)
{
dianjiStop();
Step5 = false;
Step6 = true;
}
}
/******* 步骤六(第一单元膨胀机构膨胀) *******/
if(Step6 == true)
{
Serial.println("步骤六(第一单元膨胀机构膨胀)");
currentMillis = millis(); //读取当前的时间
if(NO1_IForNO_6 == true)
{
unit1.pengzhangUp(currentMillis);
NO1_IForNO_6 = false;
NO1_IForNO_7 = true;
}
if(currentMillis - unit1.pengzhang_time >= 1000)
{
dianjiStop();
Step6 = false;
Step7 = true;
}
}
/******* 步骤七(第二单元膨胀机构收缩) *******/
if(Step7 == true)
{
Serial.println("步骤七(第二单元膨胀机构收缩)");
currentMillis = millis(); //读取当前的时间
if(NO1_IForNO_7 == true)
{
unit2.pengzhangDown(currentMillis);
NO1_IForNO_7 = false;
NO1_IForNO_8 = true;
}
if(currentMillis - unit2.pengzhang_time >= 1000)
{
dianjiStop();
Step7 = false;
Step8 = true;
}
}
/******* 步骤八(第二单元伸缩机构缩) *******/
if(Step8 == true)
{
Serial.println("步骤八(第二单元伸缩机构缩)");
currentMillis = millis(); //读取当前的时间
if(NO1_IForNO_8 == true)
{
unit2.suo(currentMillis);
NO1_IForNO_8 = false;
NO1_IForNO_1 = true;
}
if(currentMillis - unit2.shensuo_time >= 1000)
{
Serial.println("**************************************)");
dianjiStop();
Step8 = false;
Step1 = true;
}
}
}
步骤二：
7.串口通信
Serial.begin(); //开启串行通信接口并设置通信波特率
Serial.end(); //关闭通信串口
Serial.available();//判断串口缓冲器是否有数据装入
Serial.read(); //读取串口数据
Serial.peek(); //返回下一字节(字符)输入数据，但不删除它
Serial.flush(); //清空串口缓存
Serial.print(); //写入字符串数据到串口
Serial.println(); //写入字符串数据+换行到串口
Serial.write(); //写入二进制数据到串口
Serial.SerialEvent();//read时触发的事件函数
Serial.readBytes(buffer,length);//读取固定长度的二进制流
Serial.println(incomingByte, DEC);//打印接到数据十进制表示的ascii码。 HEX 十六进制表示