机友分享｜ESP8266+机智云平台实现APP控制舵机旋转

Kara · 发表于 2023-8-9 16:56:46

本帖最后由 Kara 于 2023-8-9 17:42 编辑

机友分享｜esp8266+机智云平台实现APP控制舵机旋转
一、ESP8266模块简介
ESP8266是一款超低功耗的UART-WiFi 透传模块，拥有业内极富竞争力的封装尺寸和超低能耗技术，专为移动设备和物联网应用设计，可将用户的物理设备连接到Wi-Fi 无线网络上，进行互联网或局域网通信，实现联网功能。

1.1 模块特点

支持无线802.11 b/g/n 标准
支持STA/AP/STA+AP三种工作模式
内置TCP/IP协议栈，支持多路TCP Client连接
支持丰富的Socket AT指令
支持UART/GPIO数据通信接口
支持Smart Link 智能联网功能
支持远程固件升级(OTA)
内置32位MCU, 可兼作应用处理器
超低能耗，适合电池供电应用
3.3V 单电源供电

1.2 引脚介绍
ESP8266硬件接口丰富，可支持UART，IIC，PWM，GPIO，ADC等，适用于各种物联网应用场合。

1.3 主要功能和工作模式
*主要功能

ESP8266可以实现的主要功能包括：串口透传，PWM 调控，GPIO控制。
串口透传：数据传输，传输的可靠性好，最大的传输速率为：460800bps。
PWM 调控：灯光调节，三色LED 调节，电机调速等。
GPIO控制：控制开关，继电器等。

*工作模式ESP8266模块支持STA/AP/STA+AP 三种工作模式。

STA 模式：ESP8266模块通过路由器连接互联网，手机或电脑通过互联网实现对设备的远程控制。
AP 模式：ESP8266模块作为热点，实现手机或电脑直接与模块通信，实现局域网无线控制。
STA+AP 模式：两种模式的共存模式，即可以通过互联网控制可实现无缝切换，方便操作。

1.4 调试模块
*硬件接线

注意: 面板板处于通电状态

*发送AT+RST指令
接好线后，将USB转TTL模块接入电脑打开串口助手，发送AT+RST指令。

串口接收到模块返回的信息，调试完成。

二、机智云平台
机智云平台是机智云物联网公司经过多年行业内的耕耘及对物联网行业的深刻理解，而推出的面向个人、企业开发者的一站式智能硬件开发及云服务平台。平台提供了从定义产品、设备端开发调试、应用开发、产测、云端开发、运营管理、数据服务等覆盖智能硬件接入到运营管理全生命周期服务的能力。
机智云平台为开发者提供了自助式智能硬件开发工具与开放的云端服务。通过傻瓜化的自助工具、完善的SDK与API服务能力最大限度降低了物联网硬件开发的技术门槛，降低开发者的研发成本，提升开发者的产品投产速度，帮助开发者进行硬件智能化升级，更好的连接、服务最终消费者。

*文档中心：提供一些开发教程和资料，让快速掌握物联网开发技术变得非常简单。

*开发者中心：创建产品、APP和自动生成代码服务等，提供更高效、更便捷的开发平台服务与交互体验

三、基于机智云平台的物联网开发

3.1 开发流程

在平台开发者界面创建产品和小程序
将GAgent固件烧入WiFi模组中
平台自动生成MCU方案代码
将自动生成的代码移植到ST标准库（主要完成硬件功能设计、WiFi模块与MCU的通信）

3.2关键词介绍
*GAgent：机智云官方提供的固件，可将其烧录进ESP8266 WiFi模组；烧录后，模组原来的AT指令集失去作用，模组能够接入机智云平台，并自动完成模组与平台间的数据交换。GAgent配网方式有airlink和softap。

*MCU与WIFI模块的通信ESP8266用UART通信，并有应答机制；MCU与WIFI模块的通讯可以用MCU自带的USART(支持UART)资源。

四、实操内容
4.1 GAgent固件的烧写（ESP8266）
烧录的方法有两种，一是用烧录器烧录，二是用USB转TTL模块烧录。由于没有烧录器，下面介绍用USB转TTL烧录的方式。
1）下载GAgent固件包

下载好的固件包的内容，根据参数选择烧录的固件包

2）下载安可信ESP8266资料

下载链接：安信可ESP8266系列接入机智云方案及问题排查指引 - Gizwits

3）硬件接线（ESP-01s为例）
接线：

4）打开ESP8266资料中的烧录软件

一直点进去直到找到.exe文件

打开后是这样的图

查看芯片参数(之前调试的时候有)

参数配置

点击start

完成烧录

注意: 烧写失败有可能是线接触不良(Combine包比较大)，有时候需重试几次才能烧录成功。

4.2 检查GAgent固件是否烧录成功
1）进入机智云平台随便新建一个产品

随便加个数据点(不然调试助手会检测不到产品)

可以看到左上角有PK和PS

2）下载机智云的串口调试助手

打开串口调试助手

3）将EPS8266模块与usb-TTL连接

注意：ESP其他引脚都接VCC（手册上说悬空也行，但有的芯片必须得全接好才能正常工作）

4）进入模拟MCU、选择串口、SoftAP

点击SoftAp后，串口向模块发送进入SoftAP模式的信息，模块收到后会进行应答。若能接收到模块的信息则说明GAgent烧录成功。

5）打开手机WIFI界面可以看到XPG-GAgent开头的WiFi

4.3 创建产品
根据自己的需求，按照步骤完成产品的创建

4.4 机智云虚拟设备
1）下载中心下载机智云APP

2）开发者中心->虚拟设备->打开APP扫码绑定设备

3）APP上改变舵机角度，云端数据发生相应变化

4.5 MCU自动代码生成+代码移植到标准库(*)

1）自动生成代码服务

下载代码即可

2）自动生成代码说明a. 两个重要的包

自动生成代码中，Gizwits和Utils是我们需要的，一个建立起与机智云的通讯，一个是工具包。

b. 打开MDK-ARM文件夹，打开keil工程文件
可以看到，自动生成的代码是基于Hal库的，我们需要实现自己的功能，并将其移植到标准库中

c. 打开Gizwits中的gizwits_product.c

d. 机智云服务用到的三个外设

可以看到，需要用一个定时器(Timer)和两个串口(USART)

说明：

定时器也可以用TIM1、TIM3，同理串口也不一定要用USART1和USART2
USART1用于打印调试信息，这一部分功能可以删去，但相应要修改一些代码

e. 关于USART1在gizwits_product.c大概两百多行的位置，重写了fputc函数

然后再utils/common.h文件中可以看到GIZWITS_LOG（日志函数）就是printf

在自动生成的代码中，很多调试信息的打印都调用了GIZWITS_LOG

当完成USART1的初始化并重写fputc函数后, 将USART1的端口与usb转TTL模块连接后接入电脑，借助串口助手可以打印调试信息到串口助手

重写的方式如上(本质上就是用USART1发送数据)

f. 主要文件和接口

可参考官方文档: 独立MCU方案接入机智云 - Gizwits

3)代码移植 (需要根据需求进行修改)
*串口通信（Serial.c）

#include "STM32f10x.h"
#include "Server.h"
#include "gizwits_protocol.h"
/*
* WIFI模块通信初始化 USART2
*/
void Serial_WIFI_Init(uint32_t BoundRate)
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
// 配置GPIO
// Tx
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_2;
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// Rx
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// 配置USART
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate=BoundRate;
USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
USART_InitStructure.USART_Parity=USART_Parity_No; // 无奇偶校验
USART_InitStructure.USART_StopBits=USART_StopBits_1; // 一位停止位
USART_InitStructure.USART_WordLength=USART_WordLength_8b; // 传输字长
USART_Init(USART2, &USART_InitStructure);
// 打开USART中断
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); // 打开接收寄存器非空中断
// 配置NVIC
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel=USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3; // 抢占优先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority=1; // 响应优先级
NVIC_Init(&NVIC_InitStructure);
// 启动USART
USART_Cmd(USART2, ENABLE);
}
void USART2_IRQHandler(void)
{
uint8_t Data=0;
if(USART_GetITStatus(USART2, USART_IT_RXNE)!=RESET)
{
Data = USART_ReceiveData(USART2);
gizPutData(&Data, 1); // 解析数据
}
}
/*
* 调试端口USART1
*/
void Serial_DebugInit(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);
//TX PA9
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
GPIO_Init(GPIOA, &GPIO_InitStructure);
//RX PA10
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//Usart1 NVIC 配置
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //子优先级3
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure);
//USART 初始化设置
USART_InitStructure.USART_BaudRate = 9600;//串口波特率
USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
USART_Init(USART1, &USART_InitStructure); //初始化串口1
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
USART_Cmd(USART1, ENABLE);
}
void USART1_IRQHandler(void)
{
}

复制代码

*Timer.c

#include "stm32f10x.h"
#include "Serial.h"
#include "gizwits_product.h"
// TIM3
void Timer_TIM3Init(uint16_t PSC, uint16_t CNT)
{
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
TIM_InternalClockConfig(TIM3);
// TimeBase
TIM_TimeBaseInitTypeDef TimerBaseInitStructure;
TimerBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;
TimerBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up;
TimerBaseInitStructure.TIM_Period=CNT;
TimerBaseInitStructure.TIM_Prescaler=PSC;
TimerBaseInitStructure.TIM_RepetitionCounter=0;
TIM_TimeBaseInit(TIM1, &TimerBaseInitStructure);
TIM_ClearFlag(TIM1, TIM_FLAG_Update);
// 使能更新中断
TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel=TIM3_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2; // 抢占优先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority=3; // 响应优先级
NVIC_Init(&NVIC_InitStructure);
// 开启TIM
TIM_Cmd(TIM1, ENABLE);
}
/*
* TIM3 中断函数
*/
void TIM3_IRQHandler(void)
{
if(TIM_GetITStatus(TIM3, TIM_IT_Update))
{
gizTimerMs(); // 机智云计数
// 清除标志位
TIM_ClearITPendingBit(TIM3, TIM_IT_Update);
}
}

复制代码

*Key.c (用于配置模式)

#include "stm32f10x.h"
#include "delay.h"
#include "Server.h"
#include "gizwits_protocol.h"
// PA1作为按键输入
// 2023年4月18日16:32:06
/*
* 按键初始化函数下降沿触发配置为上拉输入
*/
void Key_Init(void)
{
// RCC 使能时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
// 配置GPIO
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1;
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// 配置AFIO
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource1); // PA1
// 配置EXTI
EXTI_InitTypeDef EXTI_InitStructure;
EXTI_InitStructure.EXTI_Line=EXTI_Line1;
EXTI_InitStructure.EXTI_LineCmd=ENABLE;
EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling; // 下降沿触发
EXTI_Init(&EXTI_InitStructure);
// 配置NVIC分组只需配置一次
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
// 配置NVIC
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel=EXTI1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0; // 抢占优先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority=0; // 响应优先级
NVIC_Init(&NVIC_InitStructure);
}
/*
* EXTI 中断函数
*/
void EXTI1_IRQHandler(void)
{
if(EXTI_GetITStatus(EXTI_Line1))
{
// 消抖
Delay_ms(40);
if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1)==0)
{
Serve_Angle += 30;
}
while(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1)==0);
if(Serve_Angle>180)
{
Serve_Angle = 0;
}
Server_SetAngle((float)Serve_Angle);
// 清除标志位
EXTI_ClearITPendingBit(EXTI_Line1);
}
}
// 机智云模式配置按钮 AirLink SoftAP Reset 三种模式
void Key_WIFIModeInit(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
// PB10 按下低电平配置成上拉输入
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10;
GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// PB12 PB13 按下高电平配置成下拉输入
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPD;
GPIO_InitStructure.GPIO_Pin=GPIO_Pin_12|GPIO_Pin_14;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// AFIO
GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource10);
GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource12);
GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource14);
// EXTI
// PB1 下降沿触发
EXTI_InitTypeDef EXTI_InitStructure;
EXTI_InitStructure.EXTI_Line=EXTI_Line10;
EXTI_InitStructure.EXTI_LineCmd=ENABLE;
EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling;
EXTI_Init(&EXTI_InitStructure);
// PB12 PB14 上升沿触发
EXTI_InitStructure.EXTI_Line=EXTI_Line12|EXTI_Line14;
EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Rising;
EXTI_Init(&EXTI_InitStructure);
// NVIC
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel=EXTI15_10_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0; // 抢占优先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority=1; // 响应优先级
NVIC_Init(&NVIC_InitStructure);
}
/*
* EXTI通道10-15中断函数 PB10 PB12 PB14 分别对应WIFI模块工作的三种模式
*/
void EXTI15_10_IRQHandler(void)
{
if(EXTI_GetITStatus(EXTI_Line10))
{
// 消抖
Delay_ms(40);
if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_10)==0)
{
gizwitsSetMode(WIFI_AIRLINK_MODE);
GIZWITS_LOG("AirLink mode\r\n");
}
while(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_10)==0);
// clear
EXTI_ClearITPendingBit(EXTI_Line10);
}
else if(EXTI_GetITStatus(EXTI_Line12))
{
// 消抖
Delay_ms(40);
if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_12)==1)
{
gizwitsSetMode(WIFI_SOFTAP_MODE);
GIZWITS_LOG("Soft AP mode\r\n");
}
while(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_12)==1);
// clear
EXTI_ClearITPendingBit(EXTI_Line12);
}
else if(EXTI_GetITStatus(EXTI_Line14))
{
// 消抖
Delay_ms(40);
if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_14)==1)
{
gizwitsSetMode(WIFI_RESET_MODE);
GIZWITS_LOG("Reset mode\r\n");
}
while(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_14)==1);
// clear
EXTI_ClearITPendingBit(EXTI_Line14);
}
}

复制代码

*gizwits_product.c (注释掉Hal库的内容, 替换成ST库，完成User Handle部分内容)

/**
****
* @file gizwits_product.c
* @brief Gizwits control protocol processing, and platform-related hardware initialization
* @author Gizwits
* @date 2017-07-19
* @version V03030000
* @copyright Gizwits
*
* @note 机智云.只为智能硬件而生
* Gizwits Smart Cloud for Smart Products
* 链接|增值ֵ|开放|中立|安全|自有|自由|生态
* www.gizwits.com
*
****/
#include <stdio.h>
#include <string.h>
// #include "hal_key.h"
#include "gizwits_product.h"
#include "common.h"
#include "LED.h"
#include "Server.h"
#include "AD.h"
static uint32_t timerMsCount;
//static uint32_t timerMsCount;
uint8_t aRxBuffer;
/** User area the current device state structure*/
dataPoint_t currentDataPoint;
//extern TIM_HandleTypeDef htim2;
//extern UART_HandleTypeDef huart1;
//extern UART_HandleTypeDef huart2;
/**@} */
/**@name Gizwits User Interface
* @{
*/
/**
* @brief Event handling interface
* Description:
* 1. Users can customize the changes in WiFi module status
* 2. Users can add data points in the function of event processing logic, such as calling the relevant hardware peripherals operating interface
* @param [in] info: event queue
* @param [in] data: protocol data
* @param [in] len: protocol data length
* @return NULL
* @ref gizwits_protocol.h
*/
int8_t gizwitsEventProcess(eventInfo_t *info, uint8_t *gizdata, uint32_t len)
{
uint8_t i = 0;
dataPoint_t *dataPointPtr = (dataPoint_t *)gizdata;
moduleStatusInfo_t *wifiData = (moduleStatusInfo_t *)gizdata;
protocolTime_t *ptime = (protocolTime_t *)gizdata;
#if MODULE_TYPE
gprsInfo_t *gprsInfoData = (gprsInfo_t *)gizdata;
#else
moduleInfo_t *ptModuleInfo = (moduleInfo_t *)gizdata;
#endif
if((NULL == info) || (NULL == gizdata))
{
return -1;
}
for(i=0; i<info->num; i++)
{
switch(info->event[i])
{
case EVENT_Angle:
currentDataPoint.valueAngle = dataPointPtr->valueAngle;
GIZWITS_LOG("Evt:EVENT_Angle %4f\n",currentDataPoint.valueAngle);
//user handle
Serve_Angle=currentDataPoint.valueAngle;
Server_SetAngle(currentDataPoint.valueAngle); // 设置电机角度
break;
case WIFI_SOFTAP:
break;
case WIFI_AIRLINK:
break;
case WIFI_STATION:
break;
case WIFI_CON_ROUTER:
break;
case WIFI_DISCON_ROUTER:
break;
case WIFI_CON_M2M:
break;
case WIFI_DISCON_M2M:
break;
case WIFI_RSSI:
GIZWITS_LOG("RSSI %d\n", wifiData->rssi);
break;
case TRANSPARENT_DATA:
GIZWITS_LOG("TRANSPARENT_DATA \n");
//user handle , Fetch data from [data] , size is [len]
break;
case WIFI_NTP:
GIZWITS_LOG("WIFI_NTP : [%d-%d-%d %02d:%02d:%02d][%d] \n",ptime->year,ptime->month,ptime->day,ptime->hour,ptime->minute,ptime->second,ptime->ntp);
break;
case MODULE_INFO:
GIZWITS_LOG("MODULE INFO ...\n");
#if MODULE_TYPE
GIZWITS_LOG("GPRS MODULE ...\n");
//Format By gprsInfo_t
GIZWITS_LOG("moduleType : [%d] \n",gprsInfoData->Type);
#else
GIZWITS_LOG("WIF MODULE ...\n");
//Format By moduleInfo_t
GIZWITS_LOG("moduleType : [%d] \n",ptModuleInfo->moduleType);
#endif
break;
default:
break;
}
}
return 0;
}
/**
* User data acquisition
* Here users need to achieve in addition to data points other than the collection of data collection, can be self-defined acquisition frequency and design data filtering algorithm
* @param none
* @return none
*/
void userHandle(void)
{
currentDataPoint.valueLED = LED_Info();//Add Sensor Data Collection
currentDataPoint.valueAD_Voltage = AD_Voltage;//Add Sensor Data Collection
}
/**
* Data point initialization function
* In the function to complete the initial user-related data
* @param none
* @return none
* @note The developer can add a data point state initialization value within this function
*/
void userInit(void)
{
memset((uint8_t*)¤tDataPoint, 0, sizeof(dataPoint_t));
/** Warning !!! DataPoint Variables Init , Must Within The Data Range **/
/*
currentDataPoint.valueLED = ;
currentDataPoint.valueAD_Voltage = ;
currentDataPoint.valueAngle = ;
*/
}
/**
* @brief Millisecond timing maintenance function, milliseconds increment, overflow to zero
* @param none
* @return none
*/
void gizTimerMs(void)
{
timerMsCount++;
}
/**
* @brief Read millisecond count
* @param none
* @return millisecond count
*/
uint32_t gizGetTimerCount(void)
{
return timerMsCount;
}
/**
* @brief MCU reset function
* @param none
* @return none
*/
void mcuRestart(void)
{
__set_FAULTMASK(1);
NVIC_SystemReset();
}
/**@} */
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */
/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/* Place your implementation of fputc here */
/* e.g. write a character to the USART1 and Loop until the end of transmission */
// HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF);
USART_SendData(USART1, (uint8_t)ch);
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE)==RESET);
return ch;
}
///**
// * @brief Period elapsed callback in non blocking mode
// * @param htim : TIM handle
// * @retval None
// */
//void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
//{
// if(htim==&htim2)
// {
// keyHandle();
// gizTimerMs();
// }
//}
///**
//* @brief Timer TIM3 init function
//* @param none
//* @return none
//*/
//void timerInit(void)
//{
// HAL_TIM_Base_Start_IT(&htim2);
//}
///**
// * @brief This function handles USART IDLE interrupt.
// */
//void HAL_UART_RxCpltCallback(UART_HandleTypeDef*UartHandle)
//{
// if(UartHandle->Instance == USART2)
// {
// gizPutData((uint8_t *)&aRxBuffer, 1);
// HAL_UART_Receive_IT(&huart2, (uint8_t *)&aRxBuffer, 1);//开启下一次接收中断
// }
//}
///**
//* @brief USART init function
//* Serial communication between WiFi modules and device MCU
//* @param none
//* @return none
//*/
//void uartInit(void)
//{
// HAL_UART_Receive_IT(&huart2, (uint8_t *)&aRxBuffer, 1);//开启下一次接收中断
//}
/**
* @brief Serial port write operation, send data to WiFi module
*
* @param buf : buf address
* @param len : buf length
*
* @return : Return effective data length;-1，return failure
*/
int32_t uartWrite(uint8_t *buf, uint32_t len)
{
uint8_t crc[1] = {0x55};
uint32_t i = 0;
if(NULL == buf)
{
return -1;
}
for(i=0; i<len; i++)
{
// HAL_UART_Transmit_IT(&huart2, (uint8_t *)&buf[i], 1);
// while (huart2.gState != HAL_UART_STATE_READY);//Loop until the end of transmission
// if(i >=2 && buf[i] == 0xFF)
// {
// HAL_UART_Transmit_IT(&huart2, (uint8_t *)&crc, 1);
// while (huart2.gState != HAL_UART_STATE_READY);//Loop until the end of transmission
// }
USART_SendData(USART2, (uint8_t)buf[i]);
while(USART_GetFlagStatus(USART2, USART_FLAG_TXE)==RESET);
if(i>=2 && buf[i] == 0xFF)
{
USART_SendData(USART2, crc[0]);
while(USART_GetFlagStatus(USART2, USART_FLAG_TXE)==RESET);
}
}
#ifdef PROTOCOL_DEBUG
GIZWITS_LOG("MCU2WiFi[%4d:%4d]: ", gizGetTimerCount(), len);
for(i=0; i<len; i++)
{
GIZWITS_LOG("%02x ", buf[i]);
if(i >=2 && buf[i] == 0xFF)
{
GIZWITS_LOG("%02x ", 0x55);
}
}
GIZWITS_LOG("\n");
#endif
return len;
}