\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 4326
蓝牙参数特点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 3251
HC-05蓝牙模块是任何Arduino项目必不可少的蓝牙模块！很容易进行连接以及在Arduino IDE中编写代码。在大多数项目中，我们通常将HC05连接至Arduino，并使用它与其他智能设备(如手机)进行无线通信。这非常简单，我们已经用它建立了许多有趣的项目，例如蓝牙控制机器人、蓝牙语音控制、蓝牙家庭自动化等。但是，您是否需要将两个HC-05连接在一起？将HC05相互连接并非易事，其中涉及一些...
arduino蓝牙通讯代码_arduino笔记二：arduino与手机蓝牙通讯
weixin_39541767的博客
12-22 1525
写在前面：学习过程中从中收获良多，感谢！1、arduino连接蓝牙模块蓝牙模块我们使用HC-06从模块，这个一般的开发套件都会配，或者直接网上买，也就十几块钱。就是下面这个东西：连接方法如下：VCC:接arduino的5V。GND:接arduino的GND。TXD:接arduino的RX。RXD:接arduino的TX。2、手机下载蓝牙串口app。首先推荐的是，arduino专用的蓝牙管理软件Am...
arduino板如何与python通讯？
河西~石头
04-11 9258
python中的串口通讯，pyserial的使用，python与arduino通讯
Arduino 串口发送数据代码
努力努力努力
08-14 1991
Arduino 串口发送数据代码
ESP8266与Arduino通讯
m0_52018129的博客
07-17 3781
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 7655
一、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 2262
工具与材料：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
两者之间的交互
网易招聘的scrapy spider
09-18
网易招聘的scrapy spider
ACM计算两整数相加的多语言代码示例与注解
最新发布
09-18
内容概要：提供了基于不同编程语言的一个简单的 ACN（以计算两个整数的和为例）源代码，涉及三种语言：C++, Java 和 Python。每个示例都包含了详细的步骤来演示用户输入是如何接收和进行运算以及结果显示出来的。 适用人群：编程初学者、有一定编程经验希望熟悉多种语言实现方式的技术爱好者。 使用场景及目标：帮助理解不同编程语言基本操作方法，包括输入获取、数据处理、输出结果展示及其语法差异等知识点的运用。 其他补充：由于例子较为简易，便于作为教学案例或是新手练习之用，亦可用于快速对比几种主流编程语言的基础应用形式和技术特点。
java-ssm+vue健身房管理系统实现源码(项目源码-说明文档)
09-18
会员管理页面提供给管理员的功能有：对会员信息的一个管理，不同会员看到的页面是不一样的，会员信息也是不同 健身房信息管理页面提供给管理员的功能有：查看已发布的健身房区域数据，修改健身房区域信息或更换健身房区域内容，健身房区域信息作废，即可删除。 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：ssm 前端技术：Vue 关键技术：springboot、SSM、vue、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
51Proteus仿真LCD1602+定时计数器实现可调电子时钟的编程
09-18
51Proteus仿真LCD1602+定时计数器实现可调电子时钟的编程
【高创新】基于侏儒猫鼬优化算法DMO-Transformer-BiLSTM实现故障识别Matlab实现.rar
09-18
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
arduino自定义串口通讯协议代码
11-20
Arduino的串口通讯协议代码可以根据需求来自定义，用于实现Arduino与其他设备之间的通讯。下面是一个简单的自定义串口通讯协议代码示例： 首先，我们需要引入Arduino的串口库： ``` #include ``` 然后，定义一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值