gitea/g0b1vetx-board
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

引入mqtt 引入cjson

Browse Source
This commit is contained in:
2584532475@qq.com committed 2023-11-30 08:10:01 +08:00
1 parent a69c1a58d6
commit f8591b8b99
86 files changed
+12141 -2157
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Application/cfgthread.c
+123
View File
@@ -0,0 +1,123 @@
#include "main.h"
#include "os-app.h"
#include <stdio.h>
#include <rtthread.h>
#include "usart-board.h"
#include "data.h"
#include "easyflash.h"
#include <string.h>
ALIGN (RT_ALIGN_SIZE)
static char thread_stack[1024];
static struct rt_thread thread;
void cfg_rx_done (void)
{
rt_event_send (gUartEvents, EVENT_UART_CONFIG_RX);
}
extern void shell_recover (void);
static char tx_buff[1024];
static void thread_entry (void * argument)
{
int tx_size ;
g_DebugDrv.rxdone = cfg_rx_done;
rt_kprintf ("%s was start!\r\n", __FILE__);
rt_kprintf ("config input\r\n");
g_ifconfig = 1;
char * p;
char key[32], value[32];
while (1)
{
if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_CONFIG_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL))
{
if (rt_memcmp ("config=envs\r\n", g_DebugDrv.rx_buffer, g_DebugDrv.rx_size) == 0) // 读取配置
{
MX_UART_PutBuffer (&g_DebugDrv, "config:\r\n", rt_strlen ("config:\r\n"));
ef_print_env();
}
if (rt_memcmp ("config=exit\r\n", g_DebugDrv.rx_buffer, g_DebugDrv.rx_size) == 0)
{
break;
}
if (rt_memcmp ("config=fact\r\n", g_DebugDrv.rx_buffer, g_DebugDrv.rx_size) == 0)
{
ef_env_set_default();
printf ("config fact\r\n");
}
if (rt_memcmp ("\r\nconfig\r\n", g_DebugDrv.rx_buffer, g_DebugDrv.rx_size) == 0)
{
MX_UART_PutBuffer (&g_DebugDrv, "config input\r\n", rt_strlen ("config input\r\n"));
}
if (rt_memcmp ("config=set\r\n", g_DebugDrv.rx_buffer, rt_strlen ("config=set\r\n")) == 0)
{
p = g_DebugDrv.rx_buffer;
p = strtok (p, "\r\n");
while (1)
{
if (p)
{
rt_memset (key, 0, 32);
rt_memset (value, 0, 32);
for (int i = 0; i < rt_strlen (p); i++)
{
if (p[i] == '=')
{
rt_sprintf (key, "%*.s", i, p);
rt_sprintf (value, "%*.s", rt_strlen (p) - i - 1, &p[i + 1]);
}
}
if (ef_get_env (key) != NULL)
{
ef_set_env (key, value);
}
p = strtok (NULL, "\r\n");
}
else
{
break;
}
}
//ef_save_env();
printf ("config succ\r\n");
}
if (rt_memcmp ("\r\nreboot\r\n", g_DebugDrv.rx_buffer, g_DebugDrv.rx_size) == 0)
{
HAL_NVIC_SystemReset();
}
MX_UART_Clear (&g_DebugDrv);
}
rt_thread_delay (10);
}
shell_recover();
g_ifconfig = 0;
rt_kprintf ("config exit\r\n");
}
//char * WriteEasyFlash(char *p)
//{
// if ()
//}
void CFGThreadStart (void)
{
/* 创建线程1，名称是thread1，入口是thread1_entry*/
rt_thread_init (&thread, "cfgthread",
thread_entry, RT_NULL,
&thread_stack[0],
sizeof (thread_stack),
CFG_THREAD_PRIORITY, CFG_THREAD_TIMESLICE);
rt_thread_startup (&thread);
return ;
}
Application/disctrlthread.c
+458
View File
@@ -0,0 +1,458 @@
#include "main.h"
#include "os-app.h"
#include <stdio.h>
#include <rtthread.h>
#include "usart-board.h"
#include "disdefine.h"
#include "data.h"
#include "easyflash.h"
ALIGN (RT_ALIGN_SIZE)
static char thread_stack[4096];
static struct rt_thread thread;
static struct
{
char userpwd[8];
char syspwd[8];
} s_driver;
static void view_rx_done (void)
{
rt_event_send (gUartEvents, EVENT_UART_VIEW_RX);
//rt_kprintf ("m4851_rx_done!\r\n");
}
static int DisPreparePacket (DisDataType_t ddtt, char *buf, int maxLen)
{
int tx_size = 0;
buf[tx_size++] = 0x5A;
buf[tx_size++] = 0xA5;
buf[tx_size++] = 0x00; // 数据长度
switch (ddtt.type)
{
case DIS_TYPE_WD_INT:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
buf[tx_size++] = ddtt.Int.Byte[3]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[2]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[1]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[0]; // 寄存器数据高位
break;
}
case DIS_TYPE_WD_FLOAT:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
buf[tx_size++] = ddtt.Float.Byte[3]; // 寄存器数据高位
buf[tx_size++] = ddtt.Float.Byte[2]; // 寄存器数据高位
buf[tx_size++] = ddtt.Float.Byte[1]; // 寄存器数据高位
buf[tx_size++] = ddtt.Float.Byte[0]; // 寄存器数据高位
break;
}
case DIS_TYPE_SWPAGE:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = 0x00;
buf[tx_size++] = 0x84;
buf[tx_size++] = 0x5a;
buf[tx_size++] = 0x01;
buf[tx_size++] = ddtt.Int.Byte[1]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[0]; // 寄存器数据高位
break;
}
case DIS_TYPE_RD:
{
buf[tx_size++] = 0x83;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
buf[tx_size++] = ddtt.Len;
break;
}
// 10 70 05 30 30 30 30 30 30 30 31 FF FF
case DIS_TYPE_WD_BYTES:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
for (int i = 0; i < ddtt.Len; i++)
{
buf[tx_size++] = ddtt.bytes[i];
}
break;
}
case DIS_TYPE_WD_ICON:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
buf[tx_size++] = ddtt.Int.Byte[1]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[0]; // 寄存器数据高位
// for(int i =0;i <tx_size;i++)
// {
// dbg_printf("%X ",buf[i]);
// }
break;
}
default:
break;
}
buf[2] = tx_size - 3;
return tx_size;
}
static void disctrl_handle (char *data, int length)
{
DisDataType_t ddtt;
int index = 0, a = 0, tx_size ;
uint16_t cmd, addr;
char txbuf[100];
cmd = data[index++];
addr = ( (uint16_t) data[index] << 8) + (uint16_t) data[index + 1];
index += 2; // 去掉地址
index++;
if (cmd == 0x83) // 屏幕上报的数据
{
switch (addr)
{
// 5A A5 06 83 20 10 01 00 00
case DIS_CMD_BTN_SLOP: // 开度提闸界面 - 执行
{
// 读取闸门高度
ddtt.type = DIS_TYPE_RD;
ddtt.Addr.addr = DIS_CNUM_SLSET;
ddtt.Len = 2;
// tx_size = DisPreparePacket (ddtt, txbuf, 100);
// MX_UART_PutBuffer (&g_ViewDrv, txbuf, tx_size);
break;
}
case DIS_CMD_BTN_STOP: //急停
{
break;
}
case DIS_CMD_BTN_DUP: // 调试界面上升
{
// if (s_user_role != 1)
// break;
// log1_printf ("DIS_CMD_BTN_DUP\r\n");
// SluiceSetDCMotor (SMMotor, SLUICE_OPEN);
// sSluiceDebug = SluiceUp;
// s_debug_tx_timer = 1000;
break;
}
case DIS_CMD_BTN_DDOWN: // 调试界面下降
{
// if (s_user_role != 1)
// break;
// log1_printf ("DIS_CMD_BTN_DDOWN\r\n");
// SluiceSetDCMotor (SMMotor, SLUICE_CLOSE);
// sSluiceDebug = SluiceDown;
// s_debug_tx_timer = 1000;
break;
}
case DIS_CMD_BTN_DSTOP: // 调试界面停止
{
// if (s_user_role != 1)
// break;
// SluiceDCMotorStop (SMMotor);
// log1_printf ("DIS_CMD_BTN_DSTOP\r\n");
// sSluiceDebug = SluiceStop;
// s_debug_tx_timer = 0;
break;
}
case DIS_CMD_BTN_DUNLOCK: // 调试界面解锁
{
// if (s_user_role != 1)
// break;
// RelayOpenDoor();
// s_unlock_timerout = 5000;
// log1_printf ("DIS_CMD_BTN_DUNLOCK\r\n");
break;
}
case DIS_CMD_BTN_CALC: // 调试界面计算
{
// if (s_user_role != 1)
// break;
// int prec = (s_MaxEcode - s_MinEcode) / SysInfo.SlMaxOpen;
// SysSetEcodeData (s_MaxEcode, s_MinEcode, prec);
break;
}
case DIS_CMD_BTN_FACT:
{
// if (s_user_role != 1)
// break;
// SysFactory();
break;
}
case DIS_CMD_BTN_REST:
{
// if (s_user_role != 1)
// break;
// HAL_NVIC_SystemReset();
break;
}
// 5A A5 0A 83 10 30 03 30 31 32 33 FF FF
case DIS_CNUM_PASS:
{
rt_kprintf ("%s\r\n", &data[index]);
if ( (rt_memcmp (&data[index], (char *) s_driver.userpwd, 6) == 1)) // 用户密码
{
ddtt.type = DIS_TYPE_SWPAGE;
ddtt.Int.Int = 0x0004;
FifoWrite (&g_DisFifo, (unsigned char *) &ddtt, sizeof (ddtt));
log1_printf ("Login Success\r\n");
s_user_role = 0;
}
if ( (ty_compare_arry (&data[index], "898909", 6) == 1))
{
ddtt.type = DIS_TYPE_SWPAGE;
ddtt.Int.Int = 0x0004;
FifoWrite (&g_DisFifo, (unsigned char *) &ddtt, sizeof (ddtt));
log1_printf ("Login Success\r\n");
s_user_role = 1;
}
break;
}
// 设置闸门开度
case DIS_CNUM_SLSET:
{
//if (s_user_role != 1)
// break;
// a = (uint16_t) data[index + 2] * 256 + (uint16_t) data[index + 3];
// SluSetValveHeigthPercent (a);
// log1_printf ("DIS_CMD_NUM_SLSET:%d\r\n", a);
break;
}
// 83 10 70 05 30 30 30 31 30 30 30 31 FF FF
case DIS_CASCII_DEVID: // 设置设备编码
{
// if (s_user_role != 1)
// break;
// char addr[4];
// if (length != 14)
// {
// DisWriteDevid ( (char *) SysInfo.Addr, QUEUE);
// break;
// }
// dbg_printf ("Addr:%s\r\n", &data[index]);
// // 存储数据
// hexstr_to_hexbyte (&data[index], addr, 8);
// dbg_printf ("Addr:%X%X%X%X\r\n", addr[0], addr[1], addr[2], addr[3]);
// // 存储数据
// SysSetAddr (addr);
break;
}
// 83 10 80 05 31 2E 31 2E 31 2E 31 FF FF 2E
//设置远程ip
case DIS_CASCII_IP:
{
// if (s_user_role != 1)
// break;
// // memset()
// SysSetRemoteIp ( (char *) &data[index], length - 7);
// // hexstr_to_hexbyte (&data[index], addr, 4);
break;
}
case DIS_CASCII_PORT:
{
// if (s_user_role != 1)
// break;
// if (length != 8)
// {
// // DisWriteDevid (SysInfo.Addr, QUEUE);
// DisWriteIpPort (SysInfo.remotePort, QUEUE);
// return;
// }
// union
// {
// uint32_t Int;
// uint8_t Byte[4];
// } Int;
// Int.Byte[3] = data[index++];
// Int.Byte[2] = data[index++];
// Int.Byte[1] = data[index++];
// Int.Byte[0] = data[index++];
// SysSetRemotePort (Int.Int);
// dbg_printf ("port:%d\r\n", Int.Int);
break;
}
case DIS_CASCII_PASS:
{
// if (s_user_role != 1)
// break;
// if (length != 12)
// {
// DisWritePass (SysInfo.LoginPass, QUEUE);
// return;
// }
// // 校验密码的合法性,只能出现数字
// for (int i = 0; i < 6; i++)
// {
// if (data[index + i] > '9' || data[index + i] < '0')
// {
// DisWritePass (SysInfo.LoginPass, QUEUE);
// return;
// }
// }
// SysSetLoginPass ( (char *) &data[index], length - 6);
break;
}
case DIS_CASCII_SLTYPE: // 闸门类型，包括伺服驱动器，直流驱动器
{
// if (s_user_role != 1)
// break;
// if (length != 8)
// {
// break;
// }
break;
}
case DIS_CSPEED_SLSPEED: // 提闸速度，分为10级，直流驱动器提闸速度似乎没什么用，太小了都提不动
{
break;
}
//lcd:[83 10 D0 01 00 5A ]
case DIS_CNUM_SLHEIGHT:
{
// if (s_user_role != 1)
// break;
// union
// {
// uint32_t Int;
// uint8_t Byte[4];
// } Int;
// Int.Byte[3] = data[index++];
// Int.Byte[2] = data[index++];
// Int.Byte[1] = data[index++];
// Int.Byte[0] = data[index++];
// SysSetSlMaxOpen (Int.Int);
// int prec = (s_MaxEcode - s_MinEcode) / SysInfo.SlMaxOpen;
// SysSetEcodeData (s_MaxEcode, s_MinEcode, prec);
// dbg_printf ("Height:%d\r\n", Int.Int);
break;
}
default:
break;
}
}
else // 0x82
{
//rt_kprintf("0x82\r\n");
switch (addr)
{
case DIS_CMD_DOW_SUCC:
{
// dbg_printf("DIS_CMD_DOW_SUCC\r\n");
break;
}
default:
break;
}
}
}
extern struct
{
uint32_t sopen; // 单位mm
uint32_t gopen; // 单位mm
uint32_t lload;
uint32_t rload;
uint32_t lastopen;
uint32_t count;
} Sluice1Data, Sluice2Data;
static void thread_entry (void * argument)
{
char tx_buf[128];
rt_kprintf ("%s was start!\r\n", __FILE__);
g_ViewDrv.rxdone = view_rx_done;
g_ViewDrv.BaudRate = 115200;
MX_UART_Init (&g_ViewDrv);
char * p ;
p = ef_get_env ("user_pass");
rt_kprintf (s_driver.userpwd, "%s", p);
p = ef_get_env ("sys_pass");
rt_kprintf (s_driver.syspwd, "%s", p);
while (1)
{
rt_thread_mdelay (10);
if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_VIEW_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 300, RT_NULL)) // 数据接受失败，上报异常状态
{
for (int i = 0; i < g_ViewDrv.rx_size; i++)
{
if (g_ViewDrv.rx_buffer[i] == 0x5A)
{
if ( (g_ViewDrv.rx_buffer[i] == 0x5A) || (g_ViewDrv.rx_buffer[i + 1] != 0xA5)) // 如果是1
{
int dataLen = g_ViewDrv.rx_buffer[i + 2];
disctrl_handle (&g_ViewDrv.rx_buffer[i + 3], dataLen);
}
}
}
// if ((g_ViewDrv.rx_buffer[i] == 0x5A)
// {
// if (ty_compare_arry (&rxbuf[i], (char *) c_dis_cmd_head, 2) == 1) // 如果是1
// {
// dataLen = rxbuf[i + 2];
// HandleDisBus (&rxbuf[i + 3], dataLen);
// }
// }
// if ( (g_ViewDrv.rx_buffer[0] != 0x5A) || (g_ViewDrv.rx_buffer[0] != 0x5A))
// {
// rt_kprintf ("Header Error \r\n");
// }
// else
// {
// disctrl_handle(g_ViewDrv.rx_buffer,g_ViewDrv.rx_size);
// }
//rt_kprintf ("data timeout\r\n");
MX_UART_Clear (&g_ViewDrv);
}
}
}
void DisCtrlThreadStart (void)
{
/* 创建线程1，名称是thread1，入口是thread1_entry*/
rt_thread_init (&thread, "disctrl_thread",
thread_entry, RT_NULL,
&thread_stack[0],
sizeof (thread_stack),
DISCTRL_THREAD_PRIORITY, DISCTRL_THREAD_TIMESLICE);
rt_thread_startup (&thread);
return ;
}
Application/disdefine.h
+126
View File
@@ -0,0 +1,126 @@
#ifndef _DIS_DEFINE_H
#define _DIS_DEFINE_H
#include <stdint.h>
#define DIS_CNUM_SLOP 0X1000 // 闸门开度设定实际值
#define DIS_CNUM_SPEED 0X1010 // 瞬时流速读取值
#define DIS_CNUM_FLOW 0X1020 // 瞬时流量读取值
#define DIS_CNUM_PASS 0X1030 // 登录密码读取值
#define DIS_CNUM_SLSET 0X1040 // 闸门开度设置
#define DIS_CNUM_TTFLOW 0X1050 // 累计流量读取值
#define DIS_CNUM_SLGET 0X1060 // 闸门高度反馈
#define DIS_CASCII_DEVID 0x1070 // 设备编码参数设置
#define DIS_CASCII_IP 0x1080 // 远程地址
#define DIS_CASCII_PORT 0x1090 // 远程端口
#define DIS_CASCII_PASS 0x10A0 // 登录密码
#define DIS_CASCII_SLTYPE 0x10B0 // 闸门类型
#define DIS_CNUM_SLSPEED 0x10C0 // 闸门速度
#define DIS_CNUM_SLHEIGHT 0x10D0 // 闸门高度
#define DIS_CNUM_SLLOAD 0x10E0 // 荷重仪类型
#define DIS_CNUM_SLLOADKEY 0x10F0 //荷重仪
#define DIS_CNUM_FLOW_ADDR 0x1110 // 流量计类型
#define DIS_CNUM_FLOW_BUTE 0x1120 // 流量计类型
#define DIS_CNUM_FLOW_MAX 0x1130 // 流量计类型
#define DIS_CNUM_MAX_CODE 0x1140 // 最大编码
#define DIS_CNUM_MIN_CODE 0x1150 // 最小编码
#define DIS_CNUM_COF_CODE 0x1160 // 编码比例
#define DIS_CNUM_FLOW_TYPE 0x1170 // 流量计类型
// 调试界面
#define DIS_CNUM_DBG_ECODE 0x1180 //当前编码
#define DIS_CNUM_DBG_OPEN 0x1190 //闸门开度
#define DIS_CNUM_DBG_VOL 0x11A0 //母线电压
#define DIS_CNUM_DBG_CUR 0x11B0 //当前电流
#define DIS_CNUM_DBG_ERR 0x11C0 //报警代码
// 按钮
#define DIS_CMD_BTN_SLOP 0X2010 // 开度提闸界面 - 执行
#define DIS_CMD_BTN_SMAX 0X2020 // 开度提闸界面 - 全开
#define DIS_CMD_BTN_OP 0X2030 // 菜单 开度提闸
#define DIS_CMD_BTN_FL 0X2040 // 菜单 流量提闸
#define DIS_CMD_BTN_PA 0X2050 // 菜单 参数设置
#define DIS_CMD_BTN_DB 0X2070 // 菜单 设备调试
#define DIS_CMD_BTN_ST 0X2080 // 菜单 设备状态
// #define DIS_CMD_BTN_STOP 0X2090 // 急停
#define DIS_CMD_BTN_DUP 0X20B0 // 调试 上
#define DIS_CMD_BTN_DDOWN 0X20C0 // 调试 下
#define DIS_CMD_BTN_DSTOP 0X20D0 // 菜单 停止
#define DIS_CMD_BTN_DUNLOCK 0X20E0 // 菜单 开锁
#define DIS_CMD_BTN_SETMAX 0X20F0 // 菜单 设为最大
#define DIS_CMD_BTN_FACT 0X2100 // 菜单 恢复出厂设置
#define DIS_CMD_BTN_REST 0X2110 // 菜单 重启
#define DIS_CMD_BTN_SETMIN 0X2120 // 菜单 设为最小
// 动态图标
#define DIS_CSTE_FLOW 0X3000 // 流量计状态
#define DIS_CSTE_LOAD 0X3010 // 荷重仪状态
#define DIS_CSTE_PLUS 0X3020 // 编码器状态
#define DIS_CSTE_NET 0X3030 // 网络状态
#define DIS_CSTE_MOTOR 0X3040 // 电机状态
#define DIS_CMD_DOW_SUCC 0X4F4A // "OK"
#define MOTOR_STE_STOP 0 // 电机停止
#define MOTOR_STE_DOWN 1 // 电机下
#define MOTOR_STE_UP 2 // 电机上
#define DIS_TYPE_WD_INT 0x00
#define DIS_TYPE_WD_FLOAT 0x01
#define DIS_TYPE_RD 0x02
#define DIS_TYPE_SWPAGE 0x03
#define DIS_TYPE_WD_BYTES 0x04
#define DIS_TYPE_WD_ICON 0x05
#define DIS_STE_INVALID 0 // 无效的
#define DIS_STE_SUCCSEE 1 // 成功 绿色
#define DIS_STE_ERROR 2 // 错误 红色
// 类型定义
typedef struct DisDataType_t
{
uint8_t RW;
uint8_t type;// 0:32整 ，1:32浮点，2:切换页面
uint8_t Len;
uint8_t bytes[32];
union // 2:切换页面，地址无效
{
uint16_t addr;
uint8_t Byte[2];
} Addr;
union //如果是切换页面，显示为页面ID
{
uint32_t Int;
uint8_t Byte[4];
} Int;
union
{
float Float;
uint8_t Byte[4];
} Float;
} DisDataType_t;
#endif
Application/displaythread.c
+667
View File
@@ -0,0 +1,667 @@
#include "main.h"
#include "os-app.h"
#include <stdio.h>
#include <rtthread.h>
#include "usart-board.h"
#include "disdefine.h"
#include "data.h"
#include <ef_api.h>
ALIGN (RT_ALIGN_SIZE)
static char thread_stack[4096];
static struct rt_thread display_thread;
static rt_timer_t timer;
static struct
{
char userpwd[8];
char syspwd[8];
char device_id[10];
int identity;
} s_driver;
static void view_rx_done (void)
{
rt_event_send (gUartEvents, EVENT_UART_VIEW_RX);
//rt_kprintf ("m4851_rx_done!\r\n");
}
static void view_tx_data (uint8_t * data, uint16_t length)
{
rt_event_send (gUartEvents, EVENT_UART_VIEW_RX);
//rt_kprintf ("m4851_rx_done!\r\n");
}
static int timerout_timer = 0;
static void timerouter (void * parameter)
{
TypeIndexMail_t mail;
timerout_timer ++;
if (timerout_timer > 100) // 超过90s 没有收到数据，重启网络
{
mail.Type = MAIL_VIEW_FLUSH;
rt_mb_send (gViewMail, * ( (uint32_t*) &mail));
timerout_timer = 0;
}
}
static int DisPreparePacket (DisDataType_t ddtt, char *buf, int maxLen)
{
int tx_size = 0;
buf[tx_size++] = 0x5A;
buf[tx_size++] = 0xA5;
buf[tx_size++] = 0x00; // 数据长度
switch (ddtt.type)
{
case DIS_TYPE_WD_INT:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
buf[tx_size++] = ddtt.Int.Byte[3]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[2]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[1]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[0]; // 寄存器数据高位
break;
}
case DIS_TYPE_WD_FLOAT:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
buf[tx_size++] = ddtt.Float.Byte[3]; // 寄存器数据高位
buf[tx_size++] = ddtt.Float.Byte[2]; // 寄存器数据高位
buf[tx_size++] = ddtt.Float.Byte[1]; // 寄存器数据高位
buf[tx_size++] = ddtt.Float.Byte[0]; // 寄存器数据高位
break;
}
case DIS_TYPE_SWPAGE:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = 0x00;
buf[tx_size++] = 0x84;
buf[tx_size++] = 0x5a;
buf[tx_size++] = 0x01;
buf[tx_size++] = ddtt.Int.Byte[1]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[0]; // 寄存器数据高位
break;
}
case DIS_TYPE_RD:
{
buf[tx_size++] = 0x83;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
buf[tx_size++] = ddtt.Len;
break;
}
// 10 70 05 30 30 30 30 30 30 30 31 FF FF
case DIS_TYPE_WD_BYTES:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
for (int i = 0; i < ddtt.Len; i++)
{
buf[tx_size++] = ddtt.bytes[i];
}
break;
}
case DIS_TYPE_WD_ICON:
{
buf[tx_size++] = 0x82;
buf[tx_size++] = ddtt.Addr.Byte[1]; // 寄存器地址高位
buf[tx_size++] = ddtt.Addr.Byte[0]; // 寄存器地址高位
buf[tx_size++] = ddtt.Int.Byte[1]; // 寄存器数据高位
buf[tx_size++] = ddtt.Int.Byte[0]; // 寄存器数据高位
break;
}
default:
break;
}
buf[2] = tx_size - 3;
return tx_size;
}
static void disctrl_handle (char *data, int length)
{
DisDataType_t ddtt;
int index = 0, a = 0, tx_size ;
uint16_t cmd, addr;
char txbuf[100];
char setstr[32];
TypeIndexMail_t mail;
cmd = data[index++];
addr = ( (uint16_t) data[index] << 8) + (uint16_t) data[index + 1];
index += 2; // 去掉地址
index++;
if (cmd == 0x83) // 屏幕上报的数据
{
rt_kprintf ("command:%04X\r\n", addr);
switch (addr)
{
//
// 5A A5 06 83 20 10 01 00 00
case DIS_CMD_BTN_SLOP: // 开度提闸界面 - 执行
{
mail.Type = MAIL_VIEW_READSL;
rt_mb_send (gViewMail, * ( (uint32_t*) &mail));
//rt_event_send (gUIEvents, EVENT_VIEW_READSL);
break;
}
case DIS_CMD_BTN_DUP: // 调试界面上升
{
mail.Type = MAIL_SLUICE_SUP;
mail.index = 0;
rt_mb_send (gSluiceMail, * ( (uint32_t*) &mail));
break;
}
case DIS_CMD_BTN_DDOWN: // 调试界面下降
{
mail.Type = MAIL_SLUICE_SDW;
mail.index = 0;
rt_mb_send (gSluiceMail, * ( (uint32_t*) &mail));
break;
}
case DIS_CMD_BTN_DSTOP: // 调试界面停止
{
mail.Type = MAIL_SLUICE_STP;
mail.index = 0;
rt_mb_send (gSluiceMail, * ( (uint32_t*) &mail));
break;
}
case DIS_CMD_BTN_DUNLOCK: // 调试界面解锁
{
if (s_driver.identity == 0) // 用户无此权限
{
break;
}
rt_event_send (gCtrlEvents, EVENT_CTRL_SET_UNLOCK); // 开锁
break;
}
case DIS_CMD_BTN_FACT:
{
if (s_driver.identity == 0)
{
break;
}
ef_env_set_default();
break;
}
case DIS_CMD_BTN_REST:
{
if (s_driver.identity == 0)
{
break;
}
HAL_NVIC_SystemReset();
break;
}
case DIS_CMD_BTN_SETMAX: // 设置为最大值
{
// 将最大值写入flash
rt_sprintf (setstr, "%d", SluiceData[0].ecode);
ef_set_env ("max_ecode", setstr);
break;
}
case DIS_CMD_BTN_SETMIN: // 设置为最小值
{
rt_sprintf (setstr, "%d", SluiceData[0].ecode);
ef_set_env ("min_ecode", setstr);
break;
}
// 5A A5 0A 83 10 30 03 30 31 32 33 FF FF
case DIS_CNUM_PASS:
{
if ( (rt_memcmp (&data[index], (char *) s_driver.userpwd, 6) == 0)) // 用户密码
{
s_driver.identity = 0;
ddtt.type = DIS_TYPE_SWPAGE;
ddtt.Int.Int = 0x0004;
tx_size = DisPreparePacket (ddtt, txbuf, 100);
MX_UART_PutBuffer (&g_ViewDrv, txbuf, tx_size);
}
if ( (rt_memcmp (&data[index], (char *) s_driver.syspwd, 6) == 0)) // 用户密码
{
s_driver.identity = 1;
ddtt.type = DIS_TYPE_SWPAGE;
ddtt.Int.Int = 0x0004;
tx_size = DisPreparePacket (ddtt, txbuf, 100);
MX_UART_PutBuffer (&g_ViewDrv, txbuf, tx_size);
}
break;
}
// 设置提闸开度
case DIS_CNUM_SLSET:
{
a = (uint16_t) data[index + 2] * 256 + (uint16_t) data[index + 3];
SluiceData[0].sopen = a * 10;
//SluiceData[gMqttDrv.rx_index].sopen = datak / 10;
mail.Type = MAIL_SLUICE_OPT;
mail.index = 0;
rt_mb_send (gSluiceMail, * ( (uint32_t*) &mail));
//rt_event_send (gCtrlEvents, EVENT_CTRL_SET_OPT_SLU);
break;
}
// 83 10 70 05 30 30 30 31 30 30 30 31 FF FF
case DIS_CASCII_DEVID: // 设置设备编码
{
if (s_driver.identity == 0) // 验证身份，不是管理员不允许修改参数
{
break;
}
//char addr[11];
//rt_sprintf(addr, "%*.s", 10, &data[index]);
ef_save_string ("device_id", &data[index], 10);
break;
}
case DIS_CASCII_PASS:
{
if (s_driver.identity == 0)
{
break;
}
// if (s_user_role != 1)
// break;
// if (length != 12)
// {
// DisWritePass (SysInfo.LoginPass, QUEUE);
// return;
// }
// // 校验密码的合法性,只能出现数字
// for (int i = 0; i < 6; i++)
// {
// if (data[index + i] > '9' || data[index + i] < '0')
// {
// DisWritePass (SysInfo.LoginPass, QUEUE);
// return;
// }
// }
// SysSetLoginPass ( (char *) &data[index], length - 6);
break;
}
// case DIS_CSPEED_SLSPEED: // 提闸速度，分为10级，直流驱动器提闸速度似乎没什么用，太小了都提不动
// {
// break;
// }
case DIS_CNUM_SLHEIGHT: // 修改最大开度
{
if (s_driver.identity == 0)
{
break;
}
union
{
uint32_t Int;
uint8_t Byte[4];
} Int;
Int.Byte[3] = data[index++];
Int.Byte[2] = data[index++];
Int.Byte[1] = data[index++];
Int.Byte[0] = data[index++];
rt_sprintf (setstr, "%d", Int.Int);
ef_set_env ("max_open", setstr);
break;
}
default:
break;
}
}
else // 0x82
{
switch (addr)
{
case DIS_CMD_DOW_SUCC:
{
// dbg_printf("DIS_CMD_DOW_SUCC\r\n");
break;
}
default:
break;
}
}
}
// 更新累计流量
static void dis_write_ttflow (uint32_t ttflow)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.Addr.addr = DIS_CNUM_TTFLOW;
ddtt.type = DIS_TYPE_WD_INT;
ddtt.Int.Int = ttflow;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 更新瞬时流量
static void dis_write_mmflow (float mmFlow)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.Addr.addr = DIS_CNUM_FLOW;
ddtt.type = DIS_TYPE_WD_FLOAT;
ddtt.Float.Float = mmFlow;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 更新瞬时流速
static void dis_write_mmspeed (float mmSpeed)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.Addr.addr = DIS_CNUM_SPEED;
ddtt.type = DIS_TYPE_WD_FLOAT;
ddtt.Float.Float = mmSpeed;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 更新闸门开度
void dis_write_open (float open)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.Addr.addr = DIS_CNUM_SLGET;
ddtt.type = DIS_TYPE_WD_FLOAT;
ddtt.Float.Float = open;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 更新闸门荷重
void dis_write_load (float load)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.type = DIS_TYPE_WD_FLOAT;
ddtt.Addr.addr = DIS_CNUM_SLLOADKEY;
ddtt.Float.Float = load;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 更新编码器值
void dis_write_code (uint32_t ecode)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.Addr.addr = DIS_CNUM_DBG_ECODE;
ddtt.type = DIS_TYPE_WD_INT;
ddtt.Int.Int = ecode;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 闸门最大开度
void dis_write_slmaxopen (uint32_t ecode)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.Addr.addr = DIS_CNUM_SLHEIGHT;
ddtt.type = DIS_TYPE_WD_INT;
ddtt.Int.Int = ecode;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 发送给屏幕设备编号
// 参数1:设备编号
// 参数2:是否通过队列写入
static void dis_write_divice_id (char * id)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.type = DIS_TYPE_WD_BYTES;
ddtt.Addr.addr = DIS_CASCII_DEVID;
ddtt.Len = 10;
char * c = ef_get_env ("device_id");
rt_memcpy (ddtt.bytes, c, 10);
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 发送给屏幕设备编号
// 参数1:设备编号
// 参数2:是否通过队列写入
static void dis_write_ipaddr (char *ipaddr)
{
DisDataType_t ddtt;
char tx_buf[128], p;
// 2、 IP地址
ddtt.type = DIS_TYPE_WD_BYTES;
ddtt.Addr.addr = DIS_CASCII_IP;
ddtt.Len = strlen (ipaddr);
rt_sprintf (ddtt.bytes, "%s", ipaddr);
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 发送给屏幕设备编号
// 参数1:端口
// 参数2:是否通过队列写入
void dis_write_ipport (int port)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.type = DIS_TYPE_WD_INT;
ddtt.Addr.addr = DIS_CASCII_PORT;
ddtt.Int.Int = port;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 发送给屏幕登录密码
// 参数1:端口
// 参数2:是否通过队列写入
void dis_write_usrpwd (char *pass)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.type = DIS_TYPE_WD_BYTES;
ddtt.Addr.addr = DIS_CASCII_PASS;
ddtt.Len = strlen (pass);
rt_sprintf ( (char *) ddtt.bytes, "%s", pass);
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 修改网络状态
void dis_write_net_ste (int ste)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.type = DIS_TYPE_WD_ICON;
ddtt.Addr.addr = DIS_CSTE_NET;
ddtt.Int.Int = ste;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 修改电机状态
void dis_write_motor_ste (int ste, int isqueue)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.type = DIS_TYPE_WD_ICON;
ddtt.Addr.addr = DIS_CSTE_MOTOR;
ddtt.Int.Int = ste;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 修改编码器状态
static void dis_write_plus_ste (int ste)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.type = DIS_TYPE_WD_ICON;
ddtt.Addr.addr = DIS_CSTE_PLUS;
ddtt.Int.Int = ste;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 切换页面
static void dis_write_page (uint32_t Page)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.type = DIS_TYPE_SWPAGE;
ddtt.Int.Int = Page;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
// 修改编码器状态
void diw_write_load_ste (int ste)
{
DisDataType_t ddtt;
char tx_buf[128], p;
ddtt.type = DIS_TYPE_WD_ICON;
ddtt.Addr.addr = DIS_CSTE_LOAD;
ddtt.Int.Int = ste;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
}
static void thread_entry (void * argument)
{
char tx_buf[128], p;
DisDataType_t ddtt;
rt_kprintf ("%s was start!\r\n", __FILE__);
g_ViewDrv.rxdone = view_rx_done;
g_ViewDrv.BaudRate = 115200;
MX_UART_Init (&g_ViewDrv);
TypeIndexMail_t mail;
timer = rt_timer_create ("distimer", timerouter, RT_NULL, 10, RT_TIMER_FLAG_PERIODIC); // 异常检测定时器
char * s ;
s = ef_get_env ("user_pass");
rt_sprintf (s_driver.userpwd, "%s", s);
s = ef_get_env ("sys_pass");
rt_sprintf (s_driver.syspwd, "%s", s);
s_driver.identity = 0;
s = ef_get_env ("max_open");
int32_t max_open = atoi (s);
// 载入参数
dis_write_divice_id ( (char *) s_driver.device_id);
dis_write_ipaddr ("mqtt.zyjzjs.cn");
dis_write_ipport (1883);
dis_write_usrpwd ( (char *) s_driver.userpwd);
dis_write_slmaxopen (max_open);
dis_write_page (1); // 初始化完成，跳转到第一页显示
dis_write_plus_ste (0);
dis_write_net_ste (0);
dis_write_load (0);
dis_write_code (SluiceData[0].ecode);
rt_timer_start (timer);
while (1)
{
if (rt_mb_recv (gViewMail, (rt_ubase_t*) &mail, RT_WAITING_NO) == RT_EOK)
{
switch (mail.Type)
{
case MAIL_VIEW_FLUSH:
// 刷新闸门开度
dis_write_open ( (float) SluiceData[0].gopen / 10);
dis_write_load (0);
dis_write_mmflow (0);
dis_write_mmspeed (0);
dis_write_ttflow (0);
dis_write_code (SluiceData[0].ecode);
break;
case MAIL_VIEW_READSL:
ddtt.type = DIS_TYPE_RD;
ddtt.Addr.addr = DIS_CNUM_SLSET;
ddtt.Len = 2;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
break;
case MAIL_VIEW_LOGIN: // 登录
break;
case MAIL_VIEW_NET_STE:
ddtt.type = DIS_TYPE_WD_ICON;
ddtt.Addr.addr = DIS_CSTE_NET;
ddtt.Int.Int = mail.index;
p = DisPreparePacket (ddtt, tx_buf, 128);
MX_UART_PutBuffer (&g_ViewDrv, tx_buf, p);
break;
default:
break;
}
}
// 更新网络状态
if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_VIEW_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 300, RT_NULL)) // 数据接受失败，上报异常状态
{
for (int i = 0; i < g_ViewDrv.rx_size; i++)
{
if (g_ViewDrv.rx_buffer[i] == 0x5A)
{
if ( (g_ViewDrv.rx_buffer[i] == 0x5A) && (g_ViewDrv.rx_buffer[i + 1] == 0xA5)) // 如果是1
{
int dataLen = g_ViewDrv.rx_buffer[i + 2];
disctrl_handle (&g_ViewDrv.rx_buffer[i + 3], dataLen);
}
}
}
MX_UART_Clear (&g_ViewDrv);
}
rt_thread_mdelay (10);
}
}
void DisThreadStart (void)
{
/* 创建线程1，名称是thread1，入口是thread1_entry*/
rt_thread_init (&display_thread, "display_thread",
thread_entry, RT_NULL,
&thread_stack[0],
sizeof (thread_stack),
U4851M_THREAD_PRIORITY, U4851M_THREAD_TIMESLICE);
rt_thread_startup (&display_thread);
return ;
}
Application/os-app.c
+128
View File
@@ -0,0 +1,128 @@
//#include "FreeRTOS.h"
//#include "task.h"
#include "main.h"
#include "os-app.h"
#include <stdio.h>
#include "shell.h"
#include "shellapp.h"
#include <rtthread.h>
#include <easyflash.h>
#include <string.h>
#include <stdlib.h>
#include "mqtt-board.h"
#include "data.h"
uint32_t os_timer_count = 1;
#include <rtthread.h>
rt_event_t gCtrlEvents;
rt_event_t gUartEvents;
//rt_event_t gUIEvents;
rt_event_t gTrigEvents;
//rt_event_t gCommEvents;
rt_mailbox_t gTCommMail;
rt_mailbox_t gSluiceMail;
rt_mailbox_t gCtrlMail;
rt_mailbox_t gViewMail;
ALIGN (RT_ALIGN_SIZE)
static char thread_stack[2048];
static struct rt_thread os_app;
static rt_timer_t locktimer;
static void locktimerouter (void* parameter)
{
// todo 关闭定时器
HAL_GPIO_WritePin (LOCK_GPIO_Port, LOCK_Pin, GPIO_PIN_RESET);
}
static void thread_entry (void *parameter)
{
// 创建控制事件组
gCtrlEvents = rt_event_create ("Ctrl_Events", RT_IPC_FLAG_FIFO) ;
/* 创建串口事件组*/
gUartEvents = rt_event_create ("gUartEvents", RT_IPC_FLAG_FIFO) ;
/* 创建串口事件组*/
//gUIEvents = rt_event_create ("gUIEvents", RT_IPC_FLAG_FIFO) ;
/* 创建串口事件组*/
gTrigEvents = rt_event_create ("gTrigEvents", RT_IPC_FLAG_FIFO) ;
// 创建网络传输邮箱
gTCommMail = rt_mb_create ("gTCommMail", 32, RT_IPC_FLAG_FIFO);
// 创建网络传输邮箱
gSluiceMail = rt_mb_create ("gSluiceMail", 32, RT_IPC_FLAG_FIFO);
// 创建控制传输邮箱
gCtrlMail = rt_mb_create ("gCtrlMail", 32, RT_IPC_FLAG_FIFO);
// 创建控制传输邮箱
gViewMail = rt_mb_create ("gViewMail", 32, RT_IPC_FLAG_FIFO);
//gCommEvents = rt_event_create ("gCommEvents", RT_IPC_FLAG_FIFO) ;
locktimer = rt_timer_create ("locktimer", locktimerouter, RT_NULL, 1000, RT_TIMER_FLAG_ONE_SHOT); // 异常检测定时器
SluiceThreadStart(); // 闸门控制线程
U4851ThreadStart(); // 4851采集线程
U4852ThreadStart(); // 4852采集线程
U4853ThreadStart(); // 4853采集线程
NET_APPThreadStart(); // 网络线程
DisThreadStart(); // UI 线程
PROBUS_APPThreadStart();
uint32_t id1 = HAL_GetUIDw0();
uint32_t id2 = HAL_GetUIDw1();
uint32_t id3 = HAL_GetUIDw2();
rt_kprintf ("ID:%X %X %X\r\n", id1, id2, id3);
rt_kprintf ("Version:%s,%s\r\n",__DATE__,__TIME__);
rt_kprintf ("os-app running !\r\n");
while (1)
{
rt_thread_mdelay (500);
if (RT_EOK == rt_event_recv (gCtrlEvents, EVENT_CTRL_SET_UNLOCK, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 2000, RT_NULL)) // 数据接受失败，上报异常状态
{
// todo: 打开继电器，开启定时器
HAL_GPIO_WritePin (LOCK_GPIO_Port, LOCK_Pin, GPIO_PIN_SET);
rt_timer_start (locktimer);
}
}
}
/* 线程示例 */
int ThreadNewOsApp (void)
{
/* 创建线程1，名称是thread1，入口是thread1_entry*/
rt_thread_init (&os_app, "thread1",
thread_entry, RT_NULL,
&thread_stack[0],
sizeof (thread_stack),
OS_APP_THREAD_PRIORITY, OS_APP_THREAD_TIMESLICE);
rt_thread_startup (&os_app);
return 0;
}
void OsShellTask (void * argument)
{
while (1)
{
myshell_task();
//osDelay(1);
}
}
Application/os-app.h
+165
View File
@@ -0,0 +1,165 @@
#ifndef _OS_APP_H
#define _OS_APP_H
#include "stdint.h"
#include <rtthread.h>
#include <time.h>
// OS-APP 线程
#define OS_APP_THREAD_PRIORITY 25 // 优先级
#define OS_APP_THREAD_TIMESLICE 5
// 阀门控制线程
#define SLUICE_THREAD_PRIORITY 24 // 优先级
#define SLUICE_THREAD_TIMESLICE 5
// 4851 主机线程
#define U4851M_THREAD_PRIORITY 23 // 优先级
#define U4851M_THREAD_TIMESLICE 5
// 4852 主机线程
#define U4852M_THREAD_PRIORITY 22 // 优先级
#define U4852M_THREAD_TIMESLICE 5
// 4853 主机线程
#define U4853M_THREAD_PRIORITY 21 // 优先级
#define U4853M_THREAD_TIMESLICE 5
// 网络线程
#define NET_APP_THREAD_PRIORITY 20 // 优先级
#define NET_APP_THREAD_TIMESLICE 5
// modbus 从机 用于实现modbus 程序
#define PROBUS_APP_THREAD_PRIORITY 19 // 优先级
#define PROBUS_APP_THREAD_TIMESLICE 5
// UI线程
#define DIS_THREAD_PRIORITY 18 // 优先级
#define DIS_THREAD_TIMESLICE 5
// DTU线程
#define DTU_THREAD_PRIORITY 17 // 优先级
#define DTU_THREAD_TIMESLICE 5
// DTU线程
#define DTU2_THREAD_PRIORITY 16 // 优先级
#define DTU2_THREAD_TIMESLICE 5
// MQTT线程
#define MQTT_THREAD_PRIORITY 15 // 优先级
#define MQTT_THREAD_TIMESLICE 5
// CAT1线程
#define CAT1_THREAD_PRIORITY 14 // 优先级
#define CAT1_THREAD_TIMESLICE 5
// CAT1线程
#define ZS001_THREAD_PRIORITY 14 // 优先级
#define ZS001_THREAD_TIMESLICE 5
// CAT1线程
#define MJETH1_THREAD_PRIORITY 14 // 优先级
#define MJETH1_THREAD_TIMESLICE 5
// UI线程
#define CFG_THREAD_PRIORITY 13 // 优先级
#define CFG_THREAD_TIMESLICE 5
// UI线程
#define UPGRADE_THREAD_PRIORITY 12 // 优先级
#define UPGRADE_THREAD_TIMESLICE 5
int ThreadNewOsApp (void);
void SluiceThreadStart (void);
void U4851ThreadStart (void);
void U4852ThreadStart (void);
void U4853ThreadStart (void);
void NET_APPThreadStart (void);
void DisThreadStart (void);
void DTUThreadStart (void);
void PROBUS_APPThreadStart (void);//
void CAT1ThreadStart (void);
void ZS001ThreadStart (void);
void MJEth1ThreadStart (void);
void UpgradeThreadStart (void);
#define EVENT_CTRL_SET_OPT_SLU (1U<< 0) // 发送开度控制到提闸线程
#define EVENT_CTRL_SET_STP_SLU (1U<< 1) // 发送停止控制到提闸线程
#define EVENT_CTRL_SET_SUP_SLU (1U<< 2) // 发送上升控制到提闸线程
#define EVENT_CTRL_SET_SDW_SLU (1U<< 3) // 发送下降控制到提闸线程
#define EVENT_CTRL_SET_OPT_CTT (1U<< 4) // 发送开度控制到控制层
#define EVENT_CTRL_SET_STP_CTT (1U<< 5) // 发送停止控制到控制层
#define EVENT_CTRL_SET_SUP_CTT (1U<< 6) // 发送上升控制到控制层
#define EVENT_CTRL_SET_SDW_CTT (1U<< 7) // 发送下降控制到控制层
#define EVENT_CTRL_SET_UNLOCK (1U<< 8) // 开锁
#define EVENT_UART_4851_RX (1U << 0)
#define EVENT_UART_4852_RX (1U << 1)
#define EVENT_UART_4853_RX (1U << 2)
#define EVENT_UART_VIEW_RX (1U << 3)
#define EVENT_UART_DEBUG_RX (1U << 4)
#define EVENT_UART_GSM_RX (1U << 5)
#define EVENT_UART_ETH1_RX (1U << 6)
#define EVENT_UART_ETH2_RX (1U << 7)
#define EVENT_UART_LORA_RX (1U << 8)
#define EVENT_UART_CONFIG_RX (1U << 9)
#define EVENT_TRIG_NETMODE_TX1 (1U << 0) // 通过网络模块驱动发送数据
#define EVENT_TRIG_NETMODE_RX1 (1U << 1)
#define EVENT_TRIG_NETMODE_RST (1U << 2) // 重启网路模块
#define EVENT_TRIG_MQTT_SUB (1U << 3) // 订阅成功
#define EVENT_TRIG_MQTT_RST (1U << 4) // 重启网路模块
#define EVENT_TRIG_MQTT_TX (1U << 5) // MQTT 发送数据
#define EVENT_TRIG_COMM_RX (1U << 6) // MQTT 接受到数据
#define EVENT_TRIG_COMM_RST (1U << 7) // MQTT 发送数据
#define EVENT_TRIG_UPGRADE_RX (1U << 8) // MQTT 接受到数据
#define MAIL_COMM_HEART 0
#define MAIL_COMM_REGIST 1
#define MAIL_COMM_STAND 2
#define MAIL_COMM_SLUICE 3
#define MAIL_COMM_UPACK 4 // 提闸的ACK
#define MAIL_COMM_SLACK 5 // 其他的ACK
#define MAIL_COMM_READPARA 6 // 读取参数
#define MAIL_SLUICE_OPT 0
#define MAIL_SLUICE_STP 1
#define MAIL_SLUICE_SUP 2
#define MAIL_SLUICE_SDW 3
#define MAIL_CT_OPT 0
#define MAIL_CT_SUP 1
#define MAIL_CT_SDW 2
#define MAIL_CT_STP 3
#define MAIL_VIEW_LOGIN 1 // 登录成功 需要跳转页面
#define MAIL_VIEW_FLUSH 2 // 刷新界面显示
#define MAIL_VIEW_READSL 3 // 读取闸门开度
#define MAIL_VIEW_COD_STE 4 // 更新编码器状态
#define MAIL_VIEW_NET_STE 5 // 更新网络状态
#define MAIL_VIEW_SLU_STE 6 // 更新闸门状态
extern rt_event_t gCtrlEvents;
extern rt_event_t gUartEvents;
extern rt_event_t gUIEvents; // 界面显示事件
extern rt_event_t gTrigEvents; // 界面显示事件
extern rt_event_t gCommEvents;
extern rt_mailbox_t gTCommMail;
extern rt_mailbox_t gCtrlMail;
extern rt_mailbox_t gSluiceMail;
extern rt_mailbox_t gViewMail;
#endif
Application/simuflow.c
+55
View File
@@ -0,0 +1,55 @@
#include "data.h"
#include "math.h"
#include "easyflash.h"
#include "stdlib.h"
// 两点法计算k，b
//uint16_t math_k(uint32_t x0,uint32_t y0,uint32_t x1,uint32_t y1)
//{
// uint16_t k;
// k = (y0-x0)/(y1-x1);
// return k;
//}
//uint16_t math_k(uint32_t x0,uint32_t y0,uint32_t x1,uint32_t y1)
//{
// uint16_t k;
// k = (y0-x0)/(y1-x1);
// return k;
//}
//WaterLeveInfo_t Info = {
// .Y[0] = 2,
//};
// 水位流量关系表
//uint16_t WaterLeveCalc(int leve,int Open)
//{
// for (int i =0;i< 100;i++)
// {
// if (LeveInfo.X[i] > Open)
// {
// for (int j =0;j < 100;i++)
// {
// if (LeveInfo.Key[i].Y[j] >leve)
// {
// return LeveInfo.Key[i].Key[j];
// }
// }
// }
// }
// return 0;
//}
int32_t ParShallCalc(int index,double leve)
{
char * p;
double flow = 0;
flow = ParShallTale[index].c * pow(leve,ParShallTale[index].m);
return (int32_t )(flow *100);
}
Application/simuflow.h
+12
View File
@@ -0,0 +1,12 @@
#ifndef _SIM_FLOW_H
#define _SIM_FLOW_H
int32_t ParShallCalc(int index,double leve);
#endif
Application/upgradethread.c
+163
View File
@@ -0,0 +1,163 @@
#include "main.h"
#include "os-app.h"
#include <stdio.h>
#include <rtthread.h>
#include "usart-board.h"
#include "data.h"
#include "easyflash.h"
#include <string.h>
#include "mqtt-board.h"
#include <stdlib.h>
ALIGN (RT_ALIGN_SIZE)
static char thread_stack[2048];
static struct rt_thread thread;
extern MqttDrv_t gMqttDrv;
static void YmodemC (void)
{
gMqttDrv.txbuff[0] = 0x43;
gMqttDrv.tx_size = 1;
gMqttDrv.tx_index = 0;
MQTT_SendData();
}
static void YmodemAkc (void)
{
gMqttDrv.txbuff[0] = 0x06;
gMqttDrv.tx_size = 1;
gMqttDrv.tx_index = 0;
MQTT_SendData();
}
static void YmodemNak (void)
{
gMqttDrv.txbuff[0] = 0x15;
gMqttDrv.tx_size = 1;
gMqttDrv.tx_index = 0;
MQTT_SendData();
}
static void YmodemFail (void)
{
gMqttDrv.txbuff[0] = 0x19;
gMqttDrv.tx_size = 1;
gMqttDrv.tx_index = 0;
MQTT_SendData();
}
static void YmodemSucc (void)
{
gMqttDrv.txbuff[0] = 0x17;
gMqttDrv.tx_size = 1;
gMqttDrv.tx_index = 0;
MQTT_SendData();
}
static int file_size = 0;
static char file_name[64];
static int cur_size = 0;
static char envbuf[128];
static void thread_entry (void * argument)
{
int tx_size ;
int packet_index = 0;
// 发送文件名给升级服务器
gMqttDrv.tx_size = rt_sprintf (gMqttDrv.txbuff, "N %s,%d", SysData.fileName, 1024);
gMqttDrv.tx_index = 0;
MQTT_SendData();
g_ifupdate = 1;
packet_index = 0;
cur_size = 0;
char * p;
while (g_ifupdate == 1)
{
if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_UPGRADE_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL))
{
switch (gMqttDrv.rx_size)
{
case 0x01:
if (gMqttDrv.rxbuff[0] == 0x06)
{
YmodemC();
}
else if (gMqttDrv.rxbuff[0] == 0x04)
{
YmodemNak();
rt_thread_mdelay (300);
YmodemSucc();
ef_set_env("iap_need_copy_app","1");
rt_sprintf(envbuf,"%d",file_size);
ef_set_env("iap_copy_app_size",envbuf);
ef_set_env("iap_app_filename",file_name);
ef_save_env(); // 存储环境变量
rt_kprintf("update Success\r\n");
rt_thread_mdelay(2000);
NVIC_SystemReset();
g_ifupdate = 0;
}
break;
case 133: // 第一包数据
p = &gMqttDrv.rxbuff[3];
rt_sprintf(file_name,"%s",p);
p = p + strlen(p) +1;
file_size = atoi(p);
// 擦除备份区数据
ef_erase_bak_app(file_size);
YmodemAkc();
rt_thread_mdelay (300);
YmodemC();
break;
case 1029: // 数据包
rt_kprintf ("1029packet,index:%d\r\n", gMqttDrv.rxbuff[1]);
if (packet_index + 1 != gMqttDrv.rxbuff[1]) // 数据丢包，升级失败
{
YmodemFail();
g_ifupdate = 0;
}
else
{
// 写程序到备份区
ef_write_data_to_bak((uint8_t *)&gMqttDrv.rxbuff[3],1024,(size_t *)&cur_size,file_size);
rt_kprintf("cursize:%d\r\n",cur_size) ;
YmodemAkc();
}
packet_index++;
break;
default:
break;
}
}
rt_thread_mdelay (100);
}
rt_kprintf ("upgrade end!\r\n");
}
//char * WriteEasyFlash(char *p)
//{
// if ()
//}
void UpgradeThreadStart (void)
{
/* 创建线程1，名称是thread1，入口是thread1_entry*/
rt_thread_init (&thread, "upgradethread",
thread_entry, RT_NULL,
&thread_stack[0],
sizeof (thread_stack),
UPGRADE_THREAD_PRIORITY, UPGRADE_THREAD_TIMESLICE);
rt_thread_startup (&thread);
return ;
}