\Arduino与VUP通讯代码

最新推荐文章于 2022-10-24 19:12:19 发布
最新推荐文章于 2022-10-24 19:12:19 发布
阅读量251 收藏
点赞数
分类专栏： 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lmf666/article/details/115829296
版权 
/*
 * @Author: lavida
 * @version: 2.0
 * @Date: 2020-05-20 10:05:53
 * @LastEditTime: 2020-05-20 11:31:45
 * @Description: 规范了代码分区
 */

#define NINPUT 64
#define NOUTPUT 64
#define NBIT 512
#define NWORD 400
#define NDWORD 100
#define NFLOAT 100
#define TIMOUT 100
#define MAXDATA 256

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

unsigned char In[NINPUT];
unsigned char Out[NOUTPUT];
unsigned char Bit[NBIT];
unsigned short Word[NWORD];
unsigned long Dword[NDWORD];
float Real[NFLOAT];

unsigned long lasttimetimout;
unsigned ltramein;
unsigned char tramein[1200];
unsigned lasttime;
unsigned cycleps;

unsigned curtime;
unsigned etime;
unsigned atime;
unsigned long dsltime;
unsigned dstime;
unsigned rtime;

int run = 1;
int Step;

void inittimout(void);
int istimout(void);
void comintputcom(unsigned char c);
int comintischar(void);
int comintgetcom(void);
void rdebugsendtrame(unsigned char *data, unsigned len);
void rdebugprocesstrame(void);
void rdebuginit(void);
void rdebugprocess(void);
void prog(void);

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
double add1, add2, result0;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
 * @name: getinputs
 * @func: 获取 VUP 传递过来的数据
 */
void getinputs(void)
{
    /* USER CODE BEGIN 1 */
    add1 = Real[1];
    add2 = Real[2];
    /* USER CODE END 1 */
}

/**
 * @name: myFunctions
 * @func: 在此函数中编写主要业务功能
 */
void myFunctions(void)
{
    /* USER CODE BEGIN 2 */
    result0 = add1 + add2;
    /* USER CODE END 2 */
}

/**
 * @name: setoutputs
 * @func: 将开发板中的数据传递给 VUP
 */
void setoutputs(void)
{
    /* USER CODE BEGIN 3 */
    Real[3] = result0;
    /* USER CODE END 3 */
}

/**
 * @name: setup
 * @func: Arduino 初始化函数
 */
void setup()
{
    /* USER CODE BEGIN 4 */

    /* USER CODE END 4 */
    curtime = millis();
    rdebuginit();
}

/**
 * @name: loop
 * @func: Arduino 主循环函数
 */
void loop(void)
{
    /* USER CODE BEGIN 5 */

    /* USER CODE END 5 */
    rdebugprocess();
    getinputs();
    prog();
    setoutputs();
}

/* Connect Functions ---------------------------------------------------------*/

/*
 * @Tips: 下面是与 Arduino 通讯有关的函数实现，请勿修改！
 */

void prog(void)
{
    myFunctions();
    etime = millis();
    atime = (etime - curtime) + rtime;
    curtime = etime;
    dsltime = atime;
    dstime = dsltime;
    atime -= (unsigned)dsltime;
    rtime = atime;
}

void inittimout(void)
{
    lasttimetimout = millis();
}

int istimout(void)
{
    return (millis() - lasttimetimout >= TIMOUT) ? 1 : 0;
}

void comintputcom(unsigned char c)
{
    Serial.write(c);
}

int comintischar(void)
{
//Serial.available() 的意思是：返回串口缓冲区中当前剩余的字符个数。
//一般用这个函数来判断zd串口的缓冲区有无数据，当Serial.available()>0时，
//说明串口接收到了数据，可以读取；Serial.read()指从串口的缓冲区取出并读取一个Byte的数据，
//比如有设备通过串口向Arduino发送数据了，我们就可以用Serial.read()来读取发送的数据。
    if (Serial.available() > 0)
    {
        return 1;
    }
    return 0;
}

int comintgetcom(void)
{
    unsigned char c;
    c = Serial.read();
    return (int)c;
}

void rdebugsendtrame(unsigned char *data, unsigned len)
{
    unsigned char crc;
    unsigned count;
    crc = 'Z' + (unsigned char)(len & 0xff) + (unsigned char)(len >> 8);
    comintputcom('Z');
    comintputcom((unsigned char)(len & 0xff));
    comintputcom((unsigned char)(len >> 8));
    for (count = 0; count < len; count++)
    {
        comintputcom(data[count]);
        crc += data[count];
    }
    comintputcom((unsigned char)(~crc));
}

void rdebugprocesstrame(void)
{
    unsigned char data[MAXDATA + 1];
    if (ltramein > 0)
    {
        switch (tramein[0])
        {
        case 0:
        {
            if (ltramein == 1)
            {
                rdebugsendtrame((unsigned char *)"\x00", 1);
            }
            else
            {
                rdebugsendtrame((unsigned char *)"\xFF", 1);
            }
        }
        break;
        case 1:
        {
            if (ltramein != 2)
            {
                rdebugsendtrame((unsigned char *)"\xFF", 1);
            }
            else
            {
                switch (tramein[1])
                {
                case 0:
                {
                    if (run)
                    {
                        run = 0;
                        rdebugsendtrame((unsigned char *)"\x00", 1);
                    }
                    else
                    {
                        rdebugsendtrame((unsigned char *)"\xFE", 1);
                    }
                }
                break;
                case 1:
                {
                    if (!run)
                    {
                        run = 1;
                        rdebugsendtrame((unsigned char *)"\x00", 1);
                    }
                    else
                    {
                        rdebugsendtrame((unsigned char *)"\xFE", 1);
                    }
                }
                break;
                case 2:
                {
                    if (!run)
                    {
                        Step = 1;
                        rdebugsendtrame((unsigned char *)"\x00", 1);
                    }
                    else
                    {
                        rdebugsendtrame((unsigned char *)"\xFE", 1);
                    }
                }
                break;
                case 3:
                {
                    run = 0;
                    rdebugsendtrame((unsigned char *)"\x00", 1);
                }
                break;
                case 0x80:
                {
                    unsigned char srun[2];
                    srun[0] = 0;
                    if (run == 1)
                        srun[1] = 1;
                    else
                        srun[1] = 0;
                    rdebugsendtrame(srun, 2);
                }
                break;
                default:
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                }
                }
            }
        }
        break;
        case 2:
        {
            unsigned first, len;
            unsigned count;
            if (ltramein != 6)
            {
                rdebugsendtrame((unsigned char *)"\xFF", 1);
                break;
            }
            for (count = 0; count < MAXDATA; count++)
            {
                data[count] = 0;
            }
            first = tramein[2] + (tramein[3] << 8);
            len = tramein[4] + (tramein[5] << 8);
            switch (tramein[1])
            {
            case 0:
            {
                if (len + first > NINPUT || (len + 7) / 8 > MAXDATA)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                for (count = 0; count < len; count++)
                {
                    if (In[count + first])
                        data[1 + count / 8] |= 1 << (count & 7);
                }
                rdebugsendtrame(data, 1 + (len + 7) / 8);
            }
            break;
            case 1:
            {
                if (len + first > NOUTPUT || (len + 7) / 8 > MAXDATA)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                for (count = 0; count < len; count++)
                {
                    if (Out[count + first])
                        data[1 + count / 8] |= 1 << (count & 7);
                }
                rdebugsendtrame(data, 1 + (len + 7) / 8);
            }
            break;
            case 2:
            {
                if (len + first > NBIT || (len + 7) / 8 > MAXDATA)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                for (count = 0; count < len; count++)
                {
                    if (Bit[count + first])
                        data[1 + count / 8] |= 1 << (count & 7);
                }
                rdebugsendtrame(data, 1 + (len + 7) / 8);
            }
            break;
            case 3:
            {
                if (len + first > NWORD || len * sizeof(unsigned long) > MAXDATA)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                data[0] = 0;
                memcpy(&data[1], &Word[first], len * sizeof(unsigned));
                rdebugsendtrame(data, 1 + len * sizeof(unsigned));
            }
            break;
            case 4:
            {
                if (len + first > NDWORD || len * sizeof(unsigned long) > MAXDATA)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                data[0] = 0;
                memcpy(&data[1], &Dword[first], len * sizeof(unsigned long));
                rdebugsendtrame(data, 1 + len * sizeof(unsigned long));
            }
            break;
            case 5:
            {
                if (len + first > NFLOAT || len * sizeof(float) > MAXDATA)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                data[0] = 0;
                memcpy(&data[1], &Real[first], len * sizeof(float));
                rdebugsendtrame(data, 1 + len * sizeof(float));
            }
            break;
            default:
            {
                rdebugsendtrame((unsigned char *)"\xFF", 1);
            }
            }
        }
        break;
        case 3:
        {
            unsigned num;
            num = tramein[2] + (tramein[3] << 8);
            switch (tramein[1])
            {
            case 0:
            {
                if (ltramein != 5 || num >= NINPUT)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                In[num] = tramein[4] ? 1 : 0;
                rdebugsendtrame((unsigned char *)"\x00", 1);
            }
            break;
            case 1:
            {
                if (ltramein != 5 || num >= NOUTPUT)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                Out[num] = tramein[4] ? 1 : 0;
                rdebugsendtrame((unsigned char *)"\x00", 1);
            }
            break;
            case 2:
            {
                if (ltramein != 5 || num >= NBIT)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                Bit[num] = tramein[4] ? 1 : 0;
                rdebugsendtrame((unsigned char *)"\x00", 1);
            }
            break;
            case 3:
            {
                if (ltramein != 6 || num >= NWORD)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                memcpy(&Word[num], &tramein[4], 2);
                rdebugsendtrame((unsigned char *)"\x00", 1);
            }
            break;
            case 4:
            {
                if (ltramein != 8 || num >= NDWORD)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                memcpy(&Dword[num], &tramein[4], 4);
                rdebugsendtrame((unsigned char *)"\x00", 1);
            }
            break;
            case 5:
            {
                if (ltramein != 8 || num >= NDWORD)
                {
                    rdebugsendtrame((unsigned char *)"\xFF", 1);
                    break;
                }
                memcpy(&Real[num], &tramein[4], 4);
                rdebugsendtrame((unsigned char *)"\x00", 1);
            }
            break;
            default:
            {
                rdebugsendtrame((unsigned char *)"\xFF", 1);
            }
            }
        }
        break;
        case 10:
        {
            if (ltramein != 1)
            {
                rdebugsendtrame((unsigned char *)"\xFF", 1);
            }
            else
            {
                tramein[0] = 0;
                memcpy(&tramein[1], &cycleps, 2);
                rdebugsendtrame(tramein, 3);
            }
        }
        break;
        default:
        {
            rdebugsendtrame((unsigned char *)"\xFF", 1);
        }
        }
    }
}

void rdebuginit(void)
{
    Serial.begin(38400);
    lasttime = millis();
    rdebugsendtrame((unsigned char *)"\x00", 1);
}

void rdebugprocess(void)  //rdebugprocess程序
{
    static unsigned phase;  //步骤的标签
    static unsigned len;  //长度
    static unsigned char crc;
    if (!run)//运行的标记
        cycleps = 0;
    else
    {
        extern unsigned word[];
        unsigned ctime;
        unsigned long calc;
        ctime = millis();//计算得到当前的时间
        calc = ctime - lasttime;//当前的时间减去上一次的时间，得到时间差
        if (calc == 0)//如果时间差=0，那么时间差设置10000
            calc = 10000lu;
        else
        {
            calc = 10000lu / calc;//如果时间差不等于0，那么将
        }
        cycleps = calc;
        lasttime = ctime;
    }
    do
    {
        switch (phase)
        {//第0步
        case 0:
        {
            if (comintischar())//判断是不是z，是z，进行后面的程序
            {
                if (comintgetcom() == 'Z')
                {
                    phase++;
                }
                else
                {
                    return;
                }
            }
            else
            {
                return;
            }
            crc = 'Z';
            inittimout();//得到当前的时间
        }
        case 1:
        {
            if (comintischar())//如果有串口数据
            {
                len = comintgetcom();
                crc += len;
                phase++;
            }
            else
            {
                if (istimout())//如果超出设定的等待时间
                {
                    phase = 0;
                }
                return;
            }
            inittimout();//计算得到当前的时间
        }
        case 2:
        {
            if (comintischar())//如果有串口数据
            {
                len |= (unsigned)comintgetcom() << 8;
                crc += (len >> 8);
                ltramein = 0;
                phase++;
            }
            else
            {
                if (istimout())
                {
                    phase = 0;
                }
                return;
            }
            inittimout();
        }
        case 3:
        {
            if (comintischar())
            {
                tramein[ltramein] = comintgetcom();
                crc += tramein[ltramein++];
            }
            else
            {
                if (istimout())
                {
                    phase = 0;
                }
                return;
            }
            inittimout();
            if (ltramein == len)
                phase++;
            else
                break;
        }
        case 4:
        {
            if (comintischar())
            {
                int charin;
                charin = comintgetcom();
                if ((unsigned char)~crc == (unsigned char)charin)
                {
                    rdebugprocesstrame();
                }
                else
                {
                }
                phase = 0;
            }
            else
            {
                if (istimout())
                {
                    phase = 0;
                }
                return;
            }
        }
        }
    } while (1);
}
ooolmf
关注
专栏目录
arduino蓝牙通讯代码_Arduino蓝牙模块实现通信
weixin_40007016的博客
12-22 4324
蓝牙参数特点1.蓝牙核心模块使用HC-06从模块，引出接口包括VCC,GND,TXD,RXD,预留LED状态输出脚，单片机可通过该脚状态判断蓝牙是否已经连接2.led指示蓝牙连接状态，闪烁表示没有蓝牙连接，常亮表示蓝牙已连接并打开了端口3.输入电压3.6~6V，未配对时电流约30mA，配对后约10mA，输入电压禁止超过7V！4.可以直接连接各种单片机(51，AVR，PIC，ARM，MSP430等)...
arduino蓝牙通讯代码_在两块Arduino开发板之间实现蓝牙通信
weixin_39542093的博客
12-22 3246
HC-05蓝牙模块是任何Arduino项目必不可少的蓝牙模块！很容易进行连接以及在Arduino IDE中编写代码。在大多数项目中，我们通常将HC05连接至Arduino，并使用它与其他智能设备(如手机)进行无线通信。这非常简单，我们已经用它建立了许多有趣的项目，例如蓝牙控制机器人、蓝牙语音控制、蓝牙家庭自动化等。但是，您是否需要将两个HC-05连接在一起？将HC05相互连接并非易事，其中涉及一些...
arduino蓝牙通讯代码_arduino笔记二：arduino与手机蓝牙通讯
weixin_39541767的博客
12-22 1523
写在前面：学习过程中从中收获良多，感谢！1、arduino连接蓝牙模块蓝牙模块我们使用HC-06从模块，这个一般的开发套件都会配，或者直接网上买，也就十几块钱。就是下面这个东西：连接方法如下：VCC:接arduino的5V。GND:接arduino的GND。TXD:接arduino的RX。RXD:接arduino的TX。2、手机下载蓝牙串口app。首先推荐的是，arduino专用的蓝牙管理软件Am...
arduino板如何与python通讯？
河西~石头
04-11 9255
python中的串口通讯，pyserial的使用，python与arduino通讯
Arduino 串口发送数据代码
努力努力努力
08-14 1991
Arduino 串口发送数据代码
ESP8266与Arduino通讯
m0_52018129的博客
07-17 3779
Esp8266和Arduino的通讯问题 这是我的第一篇博客，有错误请多多包含，关于Esp8266和Arduino的通讯我是通过软串口的方式实现，这是我用的开发版是Mega 2560和 Esp8266-NodeMcu(被坑了一把不是乐鑫科技的),Mega 2560可以作为软串口引脚的有：10, 11, 12, 13, 14, 15, 50, 51, 52, 53, 62,63, 64, 65, 66, 67, 68, 69.ESP8266的软串口引脚貌似是GPIO引脚都可以用。关于软串口的库及使用可以点我
Arduino基础与进阶
让你爱上电路设计
10-24 1万+
内容包括Arduino详细介绍，开发环境搭建，第三方库加载方法(以定时器TimerOne为例)，通信教程，汽车模块BDU电池检测实例，知识产权保护等。
Unity3D与arduino串口通讯
weixin_44345862的博客
07-26 7651
一、Unity3D读取arduino发来的数据 arduino程序： int i =0; void setup() { // put your setup code here, to run once: Serial.begin(9600); } void loop() { // put your main code here, to run repeatedly: if(i ==250) i =...
树莓派与Arduino蓝牙通讯实践
热门推荐
NiYintang的博客
01-04 1万+
        最近在做一个农业机器人的项目，上位机采用的是树莓派3B，下位机采用的是Arduino Mega，一开始用的UDP协议进行数据交换，后来发现UDP传输数据不是很稳定，就决定使用串口通讯，由于树莓派3B集成了蓝牙模块，所以一切变得简单起来。 首先，在树莓派中进行环境搭建，依次执行下列命令： sudo apt-get update sudo apt-get install Ardu...
arduino lora通讯_Arduino+LoRa通讯测试
weixin_35812176的博客
01-17 2261
工具与材料：1、Arduino uno板一块；2、LoRa无线串口两块(1W/433MHz/SX1278);3、USB转TTL底板一块；4、面包板、接线；实验目的与内容：1、通过两个LoRa串口模板，实现Arduino与电脑之间通讯，可用于数据采集，物联网等领域；2、将LoRa板插入到USB转接板上，组成一个PC端的客户端。按引脚接线图示，将另一块LoRa板接入到Arduino板，形成一个数据发送...
arduino蜂鸣器音乐代码
03-27
如果你想使用Arduino和一个蜂鸣器播放简单的音乐，你可以使用tone()函数，这是Arduino提供的一个用于生成特定频率声音的函数。但是，请注意，tone()函数仅在某些Arduino板上可用，如Arduino Uno。 以下是一个简单的...
arduino蜂鸣器音乐代码.md
10-09
arduino蜂鸣器音乐代码
arduino蜂鸣器音乐代码.zip
03-27
用户只需在IDE中编写程序代码，将程序上传到Arduino电路板后，程序便会告诉Arduino电路板要做些什么。 Arduino开发板具有多种功能和特点，包括易于编程和使用、丰富的输入输出功能、可扩展性、跨平台兼容性以及社区...
matlab gui与arduino通讯代码
05-13
两者之间的交互
5110-微信小程序健身房私教预约微信小程序+ssm（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
Fast_integration_dependencies_in_spring_boot.是一个快速_fastdep.zip
最新发布
09-15
Fast_integration_dependencies_in_spring_boot.是一个快速_fastdep
05-Python数据类型-列表的相关运算
09-15
05_Python数据类型_列表的相关运算 文章对应的 jupyter notebook 源文件，可以用来做练习。欢迎下载使用。 目录如下： Python的基础数据类型 列表运算符 赋值和深浅拷贝 赋值 浅拷贝 深拷贝 附件
python字典介绍​.docx
09-15
python字典介绍​
5062-微信小程序传染病防控宣传系统的设计与实现+springboot（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
arduino自定义串口通讯协议代码
11-20
Arduino的串口通讯协议代码可以根据需求来自定义，用于实现Arduino与其他设备之间的通讯。下面是一个简单的自定义串口通讯协议代码示例： 首先，我们需要引入Arduino的串口库： ``` #include <SoftwareSerial.h> ``` 然后，定义一个SoftwareSerial对象，用于设定通讯的串口引脚和波特率： ``` SoftwareSerial mySerial(2, 3); // 这里的2和3分别代表串口的接收和发送引脚 const int baudRate = 9600; // 设置串口的波特率 ``` 在`setup()`函数中，初始化串口和其他设置： ``` void setup() { // 初始化串口通讯 Serial.begin(baudRate); mySerial.begin(baudRate); // 设置其他的配置，例如引脚模式、中断等 } ``` 在`loop()`函数中，可以编写自定义的通讯协议逻辑，例如发送和接收数据： ``` void loop() { // 发送数据 mySerial.write("Hello, Arduino!"); // 向其他设备发送数据 // 接收数据 if (mySerial.available() > 0) { // 判断是否有数据可读 int data = mySerial.read(); // 读取数据 Serial.println(data); // 打印接收到的数据 } // 其他的逻辑处理 delay(1000); // 延时1秒 } ``` 通过定义自定义的串口通讯协议代码，我们可以按照需求来制定数据的格式、传输方式和通讯规则，实现与其他设备之间的可靠通讯和数据交换。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值