From f8591b8b9909d8f51045885c39e0286bac369efd Mon Sep 17 00:00:00 2001 From: "2584532475@qq.com" Date: Thu, 30 Nov 2023 08:10:01 +0800 Subject: [PATCH] =?UTF-8?q?=E5=BC=95=E5=85=A5mqtt=20=E5=BC=95=E5=85=A5cjso?= =?UTF-8?q?n?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Application/cfgthread.c | 123 + Application/disctrlthread.c | 458 +++ Application/disdefine.h | 126 + Application/displaythread.c | 667 ++++ Application/os-app.c | 128 + Application/os-app.h | 165 + Application/simuflow.c | 55 + Application/simuflow.h | 12 + Application/upgradethread.c | 163 + Board/ao-board.c | 22 + Board/ao-board.h | 15 + Board/data.c | 191 + Board/data.h | 213 ++ Board/do-board.c | 9 + Board/do-board.h | 6 + Board/network/cat1drv.c | 307 ++ Board/network/cat1drv.h | 26 + Board/network/dtu-board.c | 123 +- Board/network/dtu-board.h | 12 +- Board/network/dtu2-board.c | 34 +- Board/network/dtu2-board.h | 7 +- Board/network/jsonpacket.c | 237 ++ Board/network/jsonpacket.h | 18 + Board/network/jsonunpack.c | 106 + Board/network/jsonunpack.h | 9 + Board/network/mje1s2fdrv.c | 114 + Board/network/mje1s2fdrv.h | 12 + Board/network/mqtt-board.c | 323 ++ Board/network/mqtt-board.h | 22 + Board/network/netdrv.c | 161 + Board/network/netdrv.h | 41 + Board/network/network.c | 43 + Board/network/network.h | 10 + Board/network/proto.c | 238 ++ Board/network/proto.h | 64 + Board/network/zs001drv.c | 132 + Board/network/zs001drv.h | 16 + Board/usart-board.c | 51 +- Board/usart-board.h | 2 +- Comm/modbusaddr.h | 45 +- Comm/net-app.c | 12 +- Comm/net-app.h | 20 +- Comm/netrecv.c | 6 +- Comm/netsend.c | 34 +- Comm/networkthread.c | 377 +- Comm/package.c | 6 +- Comm/probusthread.c | 179 +- Core/Inc/main.h | 2 + Core/Inc/tim.h | 2 +- Core/Src/adc.c | 248 +- Core/Src/crc.c | 82 +- Core/Src/dma.c | 26 +- Core/Src/gpio.c | 161 +- Core/Src/iwdg.c | 34 +- Core/Src/main.c | 183 +- Core/Src/rtc.c | 106 +- Core/Src/spi.c | 138 +- Core/Src/stm32g0xx_hal_msp.c | 22 +- Core/Src/stm32g0xx_hal_timebase_tim.c | 132 +- Core/Src/stm32g0xx_it.c | 152 +- Core/Src/tim.c | 884 ++--- Core/Src/usart.c | 1234 +++---- Core/Src/wwdg.c | 56 +- GB01VETx.ioc | 48 +- MDK-ARM/.rtt-studio/makefile.targets | 14 + MDK-ARM/GB01VETx.uvguix.Memory | 58 +- MDK-ARM/GB01VETx.uvoptx | 4 +- MDK-ARM/GB01VETx.uvprojx | 1819 +++++++++- MDK-ARM/startup_stm32g0b1xx.s | 4 +- .../bsp/_template/cubemx_config/board.c | 9 +- Project/g0b1vetx-sluice | 1 + RT-Thread/rtconfig.h | 4 +- middleware/Util/util.c | 83 +- middleware/Util/util.h | 16 +- .../cjson/cjson-master/cjson-master/cJSON.c | 3116 +++++++++++++++++ .../cjson/cjson-master/cjson-master/cJSON.h | 294 ++ middleware/easyflash/inc/ef_api.h | 24 + middleware/easyflash/port/ef_api.c | 29 +- middleware/easyflash/port/ef_port.c | 55 +- middleware/easylogger/inc/elog.h | 2 +- middleware/easylogger/port/elog_port.c | 3 +- middleware/modbus/modbus-m.c | 90 + middleware/modbus/modbus-m.h | 9 + middleware/modbus/modbus-s.c | 10 +- middleware/paho.mqtt.embedded-c | 1 + middleware/sfud/inc/sfud_cfg.h | 3 + 86 files changed, 12141 insertions(+), 2157 deletions(-) create mode 100644 Application/cfgthread.c create mode 100644 Application/disctrlthread.c create mode 100644 Application/disdefine.h create mode 100644 Application/displaythread.c create mode 100644 Application/os-app.c create mode 100644 Application/os-app.h create mode 100644 Application/simuflow.c create mode 100644 Application/simuflow.h create mode 100644 Application/upgradethread.c create mode 100644 Board/ao-board.c create mode 100644 Board/ao-board.h create mode 100644 Board/data.c create mode 100644 Board/data.h create mode 100644 Board/do-board.c create mode 100644 Board/do-board.h create mode 100644 Board/network/cat1drv.c create mode 100644 Board/network/cat1drv.h create mode 100644 Board/network/jsonpacket.c create mode 100644 Board/network/jsonpacket.h create mode 100644 Board/network/jsonunpack.c create mode 100644 Board/network/jsonunpack.h create mode 100644 Board/network/mje1s2fdrv.c create mode 100644 Board/network/mje1s2fdrv.h create mode 100644 Board/network/mqtt-board.c create mode 100644 Board/network/mqtt-board.h create mode 100644 Board/network/netdrv.c create mode 100644 Board/network/netdrv.h create mode 100644 Board/network/network.c create mode 100644 Board/network/network.h create mode 100644 Board/network/proto.c create mode 100644 Board/network/proto.h create mode 100644 Board/network/zs001drv.c create mode 100644 Board/network/zs001drv.h create mode 100644 MDK-ARM/.rtt-studio/makefile.targets create mode 160000 Project/g0b1vetx-sluice create mode 100644 middleware/cjson/cjson-master/cjson-master/cJSON.c create mode 100644 middleware/cjson/cjson-master/cjson-master/cJSON.h create mode 100644 middleware/easyflash/inc/ef_api.h create mode 160000 middleware/paho.mqtt.embedded-c diff --git a/Application/cfgthread.c b/Application/cfgthread.c new file mode 100644 index 0000000..67c8ceb --- /dev/null +++ b/Application/cfgthread.c @@ -0,0 +1,123 @@ + +#include "main.h" + +#include "os-app.h" + +#include +#include +#include "usart-board.h" +#include "data.h" +#include "easyflash.h" +#include + + +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 ; +} + + + + diff --git a/Application/disctrlthread.c b/Application/disctrlthread.c new file mode 100644 index 0000000..3488817 --- /dev/null +++ b/Application/disctrlthread.c @@ -0,0 +1,458 @@ + +#include "main.h" + +#include "os-app.h" + +#include +#include +#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 '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 ; +} + + + + + + + + + + diff --git a/Application/disdefine.h b/Application/disdefine.h new file mode 100644 index 0000000..3e8b29d --- /dev/null +++ b/Application/disdefine.h @@ -0,0 +1,126 @@ +#ifndef _DIS_DEFINE_H +#define _DIS_DEFINE_H + +#include + +#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 + + + + + + + diff --git a/Application/displaythread.c b/Application/displaythread.c new file mode 100644 index 0000000..3966aa2 --- /dev/null +++ b/Application/displaythread.c @@ -0,0 +1,667 @@ + +#include "main.h" + +#include "os-app.h" + +#include +#include +#include "usart-board.h" +#include "disdefine.h" +#include "data.h" +#include + + +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) // ÑéÖ¤Éí·Ý£¬²»ÊǹÜÀíÔ±²»ÔÊÐíÐ޸IJÎÊý + { + 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 ; +} + + + + + + + + + + diff --git a/Application/os-app.c b/Application/os-app.c new file mode 100644 index 0000000..2092072 --- /dev/null +++ b/Application/os-app.c @@ -0,0 +1,128 @@ + + +//#include "FreeRTOS.h" +//#include "task.h" +#include "main.h" +#include "os-app.h" +#include +#include "shell.h" +#include "shellapp.h" +#include +#include +#include +#include +#include "mqtt-board.h" +#include "data.h" +uint32_t os_timer_count = 1; + + + +#include +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); + } + +} + + + + diff --git a/Application/os-app.h b/Application/os-app.h new file mode 100644 index 0000000..0880b52 --- /dev/null +++ b/Application/os-app.h @@ -0,0 +1,165 @@ +#ifndef _OS_APP_H +#define _OS_APP_H +#include "stdint.h" +#include +#include + +// 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) // ¶©Ôijɹ¦ +#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 + + diff --git a/Application/simuflow.c b/Application/simuflow.c new file mode 100644 index 0000000..f1594da --- /dev/null +++ b/Application/simuflow.c @@ -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); +} + + diff --git a/Application/simuflow.h b/Application/simuflow.h new file mode 100644 index 0000000..27ac2b0 --- /dev/null +++ b/Application/simuflow.h @@ -0,0 +1,12 @@ +#ifndef _SIM_FLOW_H +#define _SIM_FLOW_H +int32_t ParShallCalc(int index,double leve); + +#endif + + + + + + + diff --git a/Application/upgradethread.c b/Application/upgradethread.c new file mode 100644 index 0000000..c5834d9 --- /dev/null +++ b/Application/upgradethread.c @@ -0,0 +1,163 @@ + +#include "main.h" + +#include "os-app.h" + +#include +#include +#include "usart-board.h" +#include "data.h" +#include "easyflash.h" +#include +#include "mqtt-board.h" +#include + + +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 ; +} + + + + diff --git a/Board/ao-board.c b/Board/ao-board.c new file mode 100644 index 0000000..eeadd08 --- /dev/null +++ b/Board/ao-board.c @@ -0,0 +1,22 @@ +#include "ao-board.h" + + + + + +// //³õʼ»¯ 4-20 ma ͨµÀ +void MX_AOInit (O4_20mA_t o) +{ + +} + + + + + + + + + + + diff --git a/Board/ao-board.h b/Board/ao-board.h new file mode 100644 index 0000000..7e43f68 --- /dev/null +++ b/Board/ao-board.h @@ -0,0 +1,15 @@ +#ifndef _AO_BOARD_H +#define _AO_BOARD_H +#include + + +typedef enum O4_20mA_t +{ + O4_20mA1, + O4_20mA2 +} O4_20mA_t; + + +#endif + + diff --git a/Board/data.c b/Board/data.c new file mode 100644 index 0000000..90de6de --- /dev/null +++ b/Board/data.c @@ -0,0 +1,191 @@ +#include "data.h" +#include + + + +const StrIndex_t cDownDataType[] = +{ + {"run",DownRun} , + {"stop",DownStop} , + {"open",DownOpen} , + {"close",DownClose} , + {"reg_ans",DownRegistAns} , + {"heart_ans",DownHeartAns}, + {"update",DownUpdate}, + {"reboot",DownReboot}, + {"config",DownConfig}, + {"read",DownRead} +}; + + + +const StrIndex_t cSiteType[] = +{ + {"sluice",SiteSluice} , + {"flow",SiteFlow} , + {"press",SiteSee} , + {"auto",SiteColl} , + {"trans",SiteServer} , + {"level",SiteLevel} +}; + + +const StrIndex_t cMotorType[] = +{ + {"mg1000",MT_MG_1000} , + {"qh100",MT_QH_V100} , + {"qh200",MT_QH_V200} , + {"zs100",MT_ZS_V100} , + {"dy100",MT_DY_V100} , + {"kg100",MT_KG_V100} +}; + +const StrIndex_t c4851Type[] = +{ + {"mg1000",ST_MG_1000} , + {"qh100",ST_QH_V100} , + {"qh200",ST_QH_V200} , + {"dy100",ST_DY_V100} , + {"kg100",ST_KG_V100} , +}; + +const StrIndex_t cU485Type[] = +{ + {"modbus",0} +}; + +const StrIndex_t c4852Type[] = +{ + {"rds600",ST_RDS_600} , + {"tds300",ST_TDS_300} , + {"ht100",ST_HT_V100} , + {"zkjszk",ST_ZK_JSZK}, + {"djx100",ST_DJX_100}, + {"rds300",ST_RDS_300} +}; + + +const ParShallInfo_t ParShallTale[] = +{ + {.w = 0,.c = 0,.m = 0}, + {.w = 0.152, .c = 0.381, .m = 1.58 ,.minLeve = 0.03, .maxLeve = 0.45, .minFlow = 1.5/1000, .maxFlow = 100/1000}, + {.w = 0.25, .c = 0.561, .m = 1.513 ,.minLeve = 0.03, .maxLeve = 0.60, .minFlow = 3.0/1000, .maxFlow = 250/1000}, + {.w = 0.30, .c = 0.679, .m = 1.521 ,.minLeve = 0.03, .maxLeve = 0.75, .minFlow = 3.5/1000, .maxFlow = 400/1000}, + {.w = 0.45, .c = 1.038, .m = 1.537 ,.minLeve = 0.03, .maxLeve = 0.75, .minFlow = 4.5/1000, .maxFlow = 630/1000}, + {.w = 0.60, .c = 1.403, .m = 1.548 ,.minLeve = 0.05, .maxLeve = 0.75, .minFlow = 12.5/1000, .maxFlow = 850/1000}, + {.w = 0.75, .c = 1.772, .m = 1.557 ,.minLeve = 0.06, .maxLeve = 0.75, .minFlow = 25.0/1000, .maxFlow = 1100/1000}, + {.w = 0.90, .c = 2.147, .m = 1.565 ,.minLeve = 0.06, .maxLeve = 0.75, .minFlow = 30.0/1000, .maxFlow = 1250/1000}, + {.w = 1.00, .c = 2.397, .m = 1.569 ,.minLeve = 0.06, .maxLeve = 0.80, .minFlow = 30.0/1000, .maxFlow = 1500/1000}, + {.w = 1.20, .c = 2.904, .m = 1.577 ,.minLeve = 0.06, .maxLeve = 0.80, .minFlow = 35.0/1000, .maxFlow = 2000/1000}, + {.w = 1.50, .c = 3.668, .m = 1.586 ,.minLeve = 0.06, .maxLeve = 0.80, .minFlow = 45.0/1000, .maxFlow = 2500/1000}, + {.w = 1.80, .c = 4.440, .m = 1.593 ,.minLeve = 0.08, .maxLeve = 0.80, .minFlow = 80.0/1000, .maxFlow = 3000/1000}, + {.w = 2.10, .c = 5.222, .m = 1.599 ,.minLeve = 0.08, .maxLeve = 0.80, .minFlow = 95.0/1000, .maxFlow = 3600/1000}, + {.w = 2.40, .c = 6.004, .m = 1.605 ,.minLeve = 0.08, .maxLeve = 0.80, .minFlow = 100.0/1000, .maxFlow = 4000/1000}, + + {.w = 3.05, .c = 7.463, .m = 1.6 ,.minLeve = 0.09, .maxLeve = 1.07, .minFlow = 0.16, .maxFlow = 8.28}, + {.w = 3.66, .c = 8.859, .m = 1.6 ,.minLeve = 0.09, .maxLeve = 1.37, .minFlow = 0.19, .maxFlow = 14.68}, + {.w = 4.57, .c = 10.96, .m = 1.6 ,.minLeve = 0.09, .maxLeve = 1.67, .minFlow = 0.23, .maxFlow = 25.04}, + {.w = 6.10, .c = 14.45, .m = 1.6 ,.minLeve = 0.09, .maxLeve = 1.83, .minFlow = 0.31, .maxFlow = 37.97}, + + {.w = 7.62, .c = 17.94, .m = 1.6 ,.minLeve = 0.09, .maxLeve = 1.83, .minFlow = 0.38, .maxFlow = 47.16}, + {.w = 9.14, .c = 21.44, .m = 1.6 ,.minLeve = 0.09, .maxLeve = 1.83, .minFlow = 0.46, .maxFlow = 56.33}, + {.w = 12.19, .c = 28.43, .m = 1.6 ,.minLeve = 0.09, .maxLeve = 1.83, .minFlow = 0.60, .maxFlow = 74.70}, + {.w = 15.24, .c = 35.41, .m = 1.6 ,.minLeve = 0.09, .maxLeve = 1.83, .minFlow = 0.75, .maxFlow = 93.04}, + +} ; + + + +SluiceData_t SluiceData[SLUICE_COUTN]; +WaterData_t WaterData[WATER_COUTN]; +SysData_t SysData; + +uint32_t g_ifconfig = 0; +uint32_t g_ifupdate = 0; + + +int cMotorGetType (char * str) +{ + for (int i =0;i < sizeof(cMotorType)/sizeof(StrIndex_t);i++) + { + if (rt_memcmp(str,cMotorType[i].str,rt_strlen(str)) == 0) + { + return cMotorType[i].index; + } + } + return -1; +} + + +int c4851GetType(char * str) +{ + rt_kprintf("485 option count:%d\r\n",sizeof(c4851Type)/sizeof(StrIndex_t)) ; + for (int i =0;i < sizeof(c4851Type)/sizeof(StrIndex_t);i++) + { + rt_kprintf("%s,%s\r\n",str,c4851Type[i].str) ; + if (rt_memcmp(str,c4851Type[i].str,rt_strlen(str)) == 0) + { + return c4851Type[i].index; + } + } + return -1; +} + +int c4852GetType(char * str) +{ + for (int i =0;i < sizeof(c4852Type)/sizeof(StrIndex_t);i++) + { + if (rt_memcmp(str,c4852Type[i].str,rt_strlen(str)) == 0) + { + return c4852Type[i].index; + } + } + return -1; +} + + +int cU485GetType(char *str) +{ + for (int i =0;i < sizeof(cU485Type)/sizeof(StrIndex_t);i++) + { + if (rt_memcmp(str,cU485Type[i].str,rt_strlen(str)) == 0) + { + return cU485Type[i].index; + } + } + return -1; +} + + +int cDownType2Index(char * str) +{ + for (int i =0;i < sizeof(cDownDataType)/sizeof(StrIndex_t);i++) + { + if (rt_memcmp(str,cDownDataType[i].str,rt_strlen(str)) == 0) + { + return cDownDataType[i].index; + } + } + return -1; +} + + + +int cSiteType2Index(char * str) +{ + for (int i =0;i < sizeof(cSiteType)/sizeof(StrIndex_t);i++) + { + if (rt_memcmp(str,cSiteType[i].str,rt_strlen(str)) == 0) + { + return cSiteType[i].index; + } + } + return -1; +} + + + + + + + diff --git a/Board/data.h b/Board/data.h new file mode 100644 index 0000000..927de34 --- /dev/null +++ b/Board/data.h @@ -0,0 +1,213 @@ +#ifndef _DATA_H +#define _DATA_H +#include + + +#define SLUICE_COUTN 1// µ±Ç°´¦Àí¼¸¿ÚÕ¢ +#define WATER_COUTN 6// µ±Ç°½ÓÈën¸öÁ÷Á¿¼Æ +#define SUBTOPIC_COUNT 1 // ¶©ÔÄtopic ÊýÁ¿ +#define SLUCIE_EXEC_COUNT 20// Õ¢ÃÅÒ쳣ʱ¼ä + + +#define VERSION "V2.0.1" + + + +extern uint32_t g_ifconfig; +extern uint32_t g_ifupdate; + +typedef struct StrIndex_t +{ + char str[10]; + int index; +}StrIndex_t; + + +// °ÍЪ¶û²ÛÁ÷Á¿¼Æ +typedef struct ParShallInfo_t +{ + double w; // ºíµÀ¿í + double c; + double m; + double minLeve; + double maxLeve; + double minFlow; + double maxFlow; +}ParShallInfo_t; + + + +typedef struct LeveInfo_t +{ + uint16_t Y[100]; // ˮλ + uint16_t Key[100]; // Á÷Á¿ +}LeveInfo_t; +// ˮλÁ÷Á¿¹Øϵ±íÊý¾Ý +typedef struct WaterLeveInfo_t +{ + uint16_t X[100]; // µ¥Î» mm + LeveInfo_t Key[100]; +}WaterLeveInfo_t; + + + +// Õ¢ÃÅÐÅÏ¢ +typedef struct SluiceData_t +{ + int32_t gopen; // ¶ÁÈ¡µ½µÄ¿ª¶È µ¥Î» mm / %0.1 + int32_t sopen; // É趨¿ª¶È µ¥Î» mm / %0.1 + int32_t lload; // ×óºÉÖØ µ¥Î» kg + int32_t rload; // ÓÒºÉÖØ µ¥Î» kg + int32_t ecode; // ±àÂëÆ÷ԭʼÊý¾Ý + int32_t currt; // É豸µçÁ÷ +} SluiceData_t; + + +// ϵͳÐÅÏ¢ +typedef struct SysData_t +{ + uint32_t Vbat;// µç³Øµçѹ + char iccid[32] ; + int16_t Csq;// ÐźÅÇ¿¶È + int netState; // ÍøÂç״̬ + int ecdState; // ±àÂëÆ÷״̬ + int flowState;// Á÷Á¿¼Æ״̬ + int ldState; // ºÉÖØ״̬ + int scram; // ¼±Í£±»°´Ï + char fileName[64]; // ÎļþÃû + int fileSize; // Îļþ´óС +} SysData_t; + + + + +// Ë®Á¿²ÎÊý +typedef struct WaterData_t +{ + int64_t ttWater; // ÀÛ¼ÆÁ÷Á¿ µ¥Î» m3 + int32_t thisFlow; // ˲ʱÁ÷Á¿ µ¥Î» m3 + int32_t thisLevel; // ˮλ + int32_t thisSpeed; // Á÷ËÙ + int32_t thisPress; // ѹÁ¦ + int32_t thisTemp; // ÎÂ¶È +} WaterData_t; + + + +typedef enum Ctrl_Mode_t +{ + CTRL_FOPEN = 0, + CTRL_ZOPEN = 1 +}Ctrl_Mode_t; + + +typedef enum MotorType_t +{ + MT_MG_1000, // Ã׸ñ1000 + MT_QH_V100, // Ç¿»ª 1.0 °æ±¾ + MT_QH_V200, // Ç¿»ª 2.0 °æ±¾ + MT_ZS_V100, // ÖÐÊ¢ 4-20 ma + MT_JZ_V200, // ½ðÖ¾ 4-20 ma + MT_DY_V100, // ´óÓí׶ÐÍ·§ + MT_KG_V100, // ¿ª¹ØÁ¿Ä£¿é + MT_KR_V100, // ÐìÖÝÕýÌìբλ¼Æ +} MotorType_t; + +typedef enum S4851Type_t +{ + ST_MG_1000, // Ã׸ñ1000 + ST_QH_V100, // Ç¿»ª 1.0 °æ±¾ + ST_QH_V200, // Ç¿»ª 2.0 °æ±¾ + ST_AT_V100, // °Âͼ±àÂëÆ÷ + ST_DY_V100, // ´óÓí׶Ðη§ + ST_KG_V100, // ¿ª¹ØÁ¿Ä£¿é + ST_KR_V100, // ÐìÖÝÕýÌìբλ¼Æ +} S4851Type_t; + +typedef enum S4852Type_t +{ + ST_RDS_600, // rds600 À×´ïÁ÷ËÙÒ»Ìå»ú + ST_TDS_300, // tds300 ³¬Éù²¨Á÷Á¿¼Æ + ST_HT_V100, // »ªÌìҺλ¼Æ + ST_ZK_JSZK, // ¾«Ë®ÖпƶàÆÕÀÕ + ST_DJX_100, // ¶¡¼ÒÏ¿Õ¢ÃÅ ¶ÁÈ¡¿ª¶È + ST_RDS_300, // À×´ïÁ÷Á¿¼Æ +} S4852Type_t; + + +typedef enum SOFTFLOWType_t +{ + NONE, + WATER, + PARSHALL// +}SOFTFLOWType_t; + + + +typedef enum SiteType_t +{ + SiteSluice, // Õ¢ÃÅÕ¾ + SiteFlow, // Á÷Á¿Õ¾ + SiteSee, // ÉøÁ÷Éøѹվ + SiteColl, // ²É¼¯Õ¾ + SiteServer, // ´®¿Ú·þÎñÆ÷ + SiteLevel // ˮλվ +}SiteType_t; + + +typedef enum DownDataType_t +{ + DownRun = 0, + DownStop = 1, + DownOpen = 2, + DownClose = 3, + DownRegistAns = 4, + DownHeartAns = 5, // ÐÄÌø + DownUpdate = 6, // Éý¼¶ + DownReboot = 7, // ÖØÆô + DownConfig = 8, // Ð޸IJÎÊý + DownRead = 9, // ¶ÁÈ¡²ÎÊý +}DownDataType_t; + + + +extern const StrIndex_t cSiteType[]; + +// ͨ¹ýÓÊÏä´«Êä¸øÇý¶¯²ã +typedef struct TypeIndexMail_t +{ + uint16_t Type; + uint16_t index; +}TypeIndexMail_t; + + + + +extern SluiceData_t SluiceData[SLUICE_COUTN]; +extern WaterData_t WaterData[WATER_COUTN]; +extern SysData_t SysData; +extern const WaterLeveInfo_t LeveInfo; +extern const ParShallInfo_t ParShallTale[]; + + +int cMotorGetType (char * str); + + +int c4851GetType(char * str); + +int c4852GetType(char * str); + +int cU485GetType(char *str); + +// ¶ÁÈ¡¿ØÖÆģʽ +int cCtrlGetType(char * str); + +int cDownType2Index(char * str); + + +int cSiteType2Index(char * str); + + + +#endif + diff --git a/Board/do-board.c b/Board/do-board.c new file mode 100644 index 0000000..ff412f8 --- /dev/null +++ b/Board/do-board.c @@ -0,0 +1,9 @@ +#include "do-board.h" +#include "tim.h" + + + +void MX_Dout_Push(int index,int pwm) +{ + MX_TIM_SetDuty(index,pwm); +} \ No newline at end of file diff --git a/Board/do-board.h b/Board/do-board.h new file mode 100644 index 0000000..a8bbaa8 --- /dev/null +++ b/Board/do-board.h @@ -0,0 +1,6 @@ +#ifndef _DO_BOARD_HH +#define _DO_BOARD_HH + +void MX_Dout_Push(int index, int pwm); + +#endif \ No newline at end of file diff --git a/Board/network/cat1drv.c b/Board/network/cat1drv.c new file mode 100644 index 0000000..db3677a --- /dev/null +++ b/Board/network/cat1drv.c @@ -0,0 +1,307 @@ +#include +#include +#include +#include "main.h" +#include "usart-board.h" +#include +#include +#include +#include "netdrv.h" +#include "data.h" + + + + + +#if !defined(LOG_TAG) +#define LOG_TAG "CAT1" +#endif +#include + + +ALIGN (RT_ALIGN_SIZE) +static char thread_stack[4096]; +static struct rt_thread netapp_thread; +static char tcprxbbuff[1200]; +static char tcptxbbuff[1200]; + + +netDrv_t g_cat1Drv = +{ + 0, // ÐźÅÖµ + "", // iccid + Init, // ״̬ + tcprxbbuff, // ½ÓÊÜ»º´æ + 0, // ½ÓÊÜÊý¾Ý³¤¶È + tcptxbbuff, // ·¢ËÍÊý¾Ý»º´æ + 0, // ·¢ËÍÊý¾Ý³¤¶È + +}; + + + + + +static void ec200_resp_csq_callback (char * data, uint16_t length) +{ + char * p; + p = strstr (data, "+CSQ:"); + p = p + 6; + g_cat1Drv.Csq = atoi (p); + rt_kprintf ("CSQ: <<< <%d>\r\n", g_cat1Drv.Csq); +} + +// У׼ʱ¼ä³ÌÐò +static void ec200_resp_qlts_callback (char * data, uint16_t length) +{ + uint8_t k[6] = {NULL}; + char *p = NULL; + p = strstr (data, "+QLTS:") ; + p = p + 10; + k[0] = atoi (p); // Äê + k[0] = (k[0] + (k[0] / 10) * 6) ; // Ê®½øÖÆתbcdÂë + p = p + 3; + k[1] = atoi (p); // Ô + k[1] = (k[1] + (k[1] / 10) * 6) ; + p = p + 3; + k[2] = atoi (p); // ÈÕ + k[2] = (k[2] + (k[2] / 10) * 6) ; + p = p + 3; // p + k[3] = atoi (p); // ʱ + k[3] = (k[3] + (k[3] / 10) * 6) ; + p = p + 3; // p + k[4] = atoi (p); // ·Ö + k[4] = (k[4] + (k[4] / 10) * 6) ; + p = p + 3; // p + k[5] = atoi (p); // Ãë + k[5] = (k[5] + (k[5] / 10) * 6) ; + rt_kprintf ("20%02x-%02x-%02x %02x:%02x:%02x\r\n", k[0], k[1], k[2], k[3], k[4], k[5]); + +} + + +static void ec200_resp_iccid_callback (char * data, uint16_t length) +{ + char *p; + p = strstr (data, "+QCCID:"); + p = p + 8; + rt_memset (SysData.iccid, 0, 32); + rt_memcpy (SysData.iccid, p, 20); + rt_kprintf ("ICCID: <<< <%d> [%s]\r\n", length, SysData.iccid); +} + +static void ec200_resp_qird_callback (char * data, uint16_t length) +{ + char * p; + p = strstr (data, "+QIRD: "); + p = p + 7; + g_cat1Drv.rx_size = atoi (p); + if (g_cat1Drv.rx_size > 0) // ¶ÁÈ¡µ½Êý¾Ý + { + p = strstr (p, "\r\n"); + p = p + 2; + for (int i = 0; i < g_cat1Drv.rx_size; i++) + { + g_cat1Drv.rxbuff[i] = *p; + p++; + } + rt_event_send (gTrigEvents, EVENT_TRIG_NETMODE_RX1) ; +// rt_kprintf("EVENT_TRIG_NETMODE_RX1\r\n"); +// for(int i =0 ;i < g_cat1Drv.rx_size;i++) +// { +// rt_kprintf("%02X ",g_cat1Drv.rxbuff[i]); +// } + } + +} + +// type 0 ÎÞÐè´ò°ü 1 ÐèÒªÖØдò°ü +const struct +{ + char * cmd; + char * ack; + uint32_t delayms; + uint32_t waitms; + uint32_t retry; + void (*call) (char *, uint16_t); +} cat1list[] = +{ + [ATE] = {"ATE0\r\n", "OK", 10, 2000, 10, NULL}, + [ATI] = {"ATI\r\n", "OK", 10, 2000, 3, NULL}, + [CPIN] = {"AT+CPIN?\r\n", "+CPIN: READY", 10, 2000, 10, NULL}, +// [CREG] = {"AT+CREG?\r\n", "+CREG: 0,1", 10, 2000, 30, NULL}, +// [CGREG] = {"AT+CGREG?\r\n", "+CGREG: 0,1", 10, 2000, 30, NULL}, + [CGATT] = {"AT+CGATT?\r\n", "+CGATT: 1", 10, 2000, 30, NULL}, + [CSQ] = {"AT+CSQ\r\n", "+CSQ:", 10, 2000, 1, ec200_resp_csq_callback}, + [QLTS] = {"AT+QLTS=2\r\n", "+QLTS:", 10, 2000, 1, ec200_resp_qlts_callback}, + [QCCID] = {"AT+QCCID\r\n", "+QCCID:", 10, 2000, 1, ec200_resp_iccid_callback}, +}; + + + +static void cat1_rx_done (void) +{ + rt_event_send (gUartEvents, EVENT_UART_GSM_RX); +// for (int i = 0 ; i < g_GSMDrv.rx_size; i++) +// { +// rt_kprintf ("%c", g_GSMDrv.rx_buffer[i]); +// } + +// MX_UART_Clear (&g_GSMDrv); +} + + +// cat1 ·¢ËÍÊý¾Ý +//0 : ½áÊø£¬ÏÂÒ»¸ö +//1 : ÔËÐÐÖУ¬ÏÂÒ»¸ö +static CommRet_T cat1_sendcmd_and_responce (int time, char * tx, int size, char * ack, void (*call) (char *, uint16_t)) +{ + MX_UART_Clear (&g_GSMDrv); + MX_UART_PutBuffer (&g_GSMDrv, tx, size); + //rt_kprintf ("%.*s", size, tx) ; + //timeout = cat1list[i].waitms; + int timeout = time; + while (timeout--) + { + if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_GSM_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL)) + { + // rt_kprintf ("[%.*s]", g_GSMDrv.rx_size, g_GSMDrv.rx_buffer) ; + if (NULL != rt_strstr ( (char *) g_GSMDrv.rx_buffer, ack)) + { + if (call != NULL) + { + call ( (char *) g_GSMDrv.rx_buffer, g_GSMDrv.rx_size) ; + } + return RetSucc; // ³É¹¦ + } + MX_UART_Clear (&g_GSMDrv); + } + rt_thread_mdelay (1); + } + return RetErr; // ³¬Ê± +} + + + + +static void thread_entry (void * argument) +{ + + char at_cmd[128] = {NULL}; + char ipaddr[32] = {NULL}; + int ipport; + char *p; + int retry = 0; + + p = ef_get_env ("mqtt_addr"); + rt_strncpy (ipaddr, p, rt_strlen (p)); + p = ef_get_env ("mqtt_port"); + ipport = atoi (p); + rt_sprintf (at_cmd, "AT+QIOPEN=1,0,\"TCP\",\"%s\",%d,0,0\r", ipaddr, ipport); + g_GSMDrv.rxdone = cat1_rx_done; + g_GSMDrv.BaudRate = 115200; + // Æô¶¯4G Ä£¿éµçÔ´ + // À­¸ß4G Ä£¿é¸´Î» + while (1) + { +CAT1RST: + // ³õʼ»¯´®¿Ú,´ò¿ªÄ£¿éµçÔ´ + g_cat1Drv.State = Init; + MX_UART_Init (&g_GSMDrv); + HAL_GPIO_WritePin (GSM_PW_GPIO_Port, GSM_PW_Pin, GPIO_PIN_RESET); // ¹Ø±Õ4G Ä£¿éµçÔ´ + rt_thread_mdelay (3000); + HAL_GPIO_WritePin (GSM_PW_GPIO_Port, GSM_PW_Pin, GPIO_PIN_SET); // ¿ªÆô4G + rt_thread_mdelay (100); + // À­¸ßÄ£×鸴λ + HAL_GPIO_WritePin (GSM_RST_GPIO_Port, GSM_RST_Pin, GPIO_PIN_RESET); + rt_thread_mdelay (100); + HAL_GPIO_WritePin (GSM_RST_GPIO_Port, GSM_RST_Pin, GPIO_PIN_SET); + rt_thread_mdelay (8000); + for (int i = 0; i < MAXSETP; i++) + { + retry = cat1list[i].retry; + while (1) + { + if (cat1_sendcmd_and_responce (cat1list[i].waitms, cat1list[i].cmd, strlen (cat1list[i].cmd), cat1list[i].ack, cat1list[i].call) == RetSucc) + { + break; + } + else + { + retry--; + if (retry <= 0) + { + rt_kprintf ("Join Faild%d \r\n", i); + goto CAT1RST; + } + } + } + } + rt_kprintf ("Join Success \r\n"); + rt_sprintf (at_cmd, "AT+QIOPEN=1,0,\"TCP\",\"%s\",%d,0,0\r", ipaddr, ipport); + if (cat1_sendcmd_and_responce (15000, at_cmd, strlen (at_cmd), "+QIOPEN: 0,0", NULL) == RetSucc) + { + g_cat1Drv.State = Conn; + rt_kprintf ("Net is ready \r\n"); + } + else + { + rt_kprintf ("Net is Error \r\n"); + goto CAT1RST; + } + + while (1) + { + // ·¢ËÍÊý¾Ý + if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_TX1, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL)) // ÐèÒª·¢ËÍÊý¾Ý + { + if (g_cat1Drv.txbuff != NULL) + { + rt_sprintf (at_cmd, "AT+QISEND=0,%d\r\n", g_cat1Drv.tx_size); + rt_thread_mdelay (10); + if (cat1_sendcmd_and_responce (1000, at_cmd, strlen (at_cmd), ">", NULL) != RetSucc) + { + rt_kprintf ("NET:+CME:ERROR QISEND\r\n"); + goto CAT1RST; + } + if (cat1_sendcmd_and_responce (3000, g_cat1Drv.txbuff, g_cat1Drv.tx_size, "SEND OK", NULL) != RetSucc) + { + rt_kprintf ("NET:+CME:ERROR QPUSH\r\n"); + goto CAT1RST; + } + } + } + // ¶ÁÈ¡Êý¾Ý + rt_thread_mdelay (300); + if (cat1_sendcmd_and_responce (1000, "AT+QIRD=0,1500\r\n", strlen ("AT+QIRD=0,1500\r\n"), "+QIRD:", ec200_resp_qird_callback) != RetSucc) + { + rt_kprintf ("NET:+CME:ERROR QIRD\r\n"); + goto CAT1RST; + } + } + rt_thread_mdelay (3000); + } + +} + + +void cat1_service_tx (char * buff, int size) +{ + rt_memcpy (g_cat1Drv.txbuff, buff, size); + g_cat1Drv.tx_size = size; + rt_event_send (gTrigEvents, EVENT_TRIG_NETMODE_TX1) ; +} + + +void CAT1ThreadStart (void) +{ + /* ´´½¨Ïß³Ì1£¬Ãû³ÆÊÇthread1£¬Èë¿ÚÊÇthread1_entry */ + rt_thread_init (&netapp_thread, "netapp_thread", + thread_entry, RT_NULL, + &thread_stack[0], + sizeof (thread_stack), + CAT1_THREAD_PRIORITY, CAT1_THREAD_TIMESLICE); + rt_thread_startup (&netapp_thread); + + return ; +} diff --git a/Board/network/cat1drv.h b/Board/network/cat1drv.h new file mode 100644 index 0000000..b0664c5 --- /dev/null +++ b/Board/network/cat1drv.h @@ -0,0 +1,26 @@ +#ifndef _CAT1_DRV_H +#define _CAT1_DRV_H + + +// ¶¨ÒåCAT1 ״̬»úÆ÷ +typedef enum +{ + ATE, + ATI, + CPIN, +// CREG, +// CGREG, + CGATT, + CSQ, + QLTS, + QCCID, + MAXSETP +} EC200_SETUP_T; + + + + +void cat1_service_tx (char * buff, int size); +int cat1_is_connected (void); + +#endif diff --git a/Board/network/dtu-board.c b/Board/network/dtu-board.c index e8a5dc6..82b1387 100644 --- a/Board/network/dtu-board.c +++ b/Board/network/dtu-board.c @@ -7,11 +7,16 @@ #include #include #include "usart-board.h" +#include +#include "transport.h" +#include "netdrv.h" + + #if !defined(LOG_TAG) - #define LOG_TAG "dtu" +#define LOG_TAG "dtu" #endif #include @@ -19,64 +24,101 @@ ALIGN (RT_ALIGN_SIZE) static char thread_stack[2048]; static struct rt_thread dtu_thread; -static struct +static char tx_buffer[512]; +static char rx_buffer[512]; + + + +netDrv_t g_dtuDrv = { - uint32_t isConnected; // Á¬½Ó³É¹¦ - -} g_dtuDrv ; + 0, // ÐźÅÖµ + "", // iccid + Init, // ״̬ + tx_buffer, // ½ÓÊÜ»º´æ + 0, // ½ÓÊÜÊý¾Ý³¤¶È + rx_buffer, // ·¢ËÍÊý¾Ý»º´æ + 0, // ·¢ËÍÊý¾Ý³¤¶È +}; - -static enum +static void net_data_rxdone (void) { - netDrvInit = 0, // ³õʼ»¯ÍøÂçÇý¶¯ - netDrvJoin = 1, // µÈ´ýÍøÂç×¢²á³É¹¦ - netDrvSend = 2, // ·¢ËÍÊý¾Ý - netDrvRecv = 3, // ¶ÁÈ¡Êý¾Ý - netDrvIdle = 4, // ¶ÁÈ¡Êý¾Ý -} eDrvStatus; - - - -static void net_data_rxdone(void) -{ - rt_event_send(gUartEvents,EVENT_UART_ETH1_RX); + rt_event_send (gUartEvents, EVENT_UART_ETH1_RX); //rt_kprintf("net_data_rxdone\r\n"); } static void thread_entry (void * argument) { -// eDrvStatus = netDrvInit; rt_kprintf ("%s was start!\r\n", __FILE__); -// gnetEvents = rt_event_create("gnetEvents", RT_IPC_FLAG_FIFO) ; - - /*Configure GPIO pin Output Level */ - - HAL_GPIO_WritePin(ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET); - HAL_GPIO_WritePin(ETH_PW_GPIO_Port, ETH_PW_Pin, GPIO_PIN_SET); g_ETH1Drv.rxdone = net_data_rxdone; - MX_UART_Init(&g_ETH1Drv); - -// // ×¢²áÍøÂçÇý¶¯ - // ×¢²áÍøÂçÇý¶¯ +// MX_UART_Init(&g_ETH1Drv); while (1) { - //MX_UART_PutBuffer(&g_ETH1Drv,"20140524",8); - if( RT_EOK == rt_event_recv( gUartEvents, EVENT_UART_ETH1_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL )) +MODE_RST: + g_dtuDrv.State = Init; + MX_UART_Init (&g_ETH1Drv); + HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_RESET); + rt_thread_mdelay (1000); + HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET); + rt_thread_mdelay (1000); + HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin, GPIO_PIN_SET); + rt_thread_mdelay (8000); + g_dtuDrv.State = Conn; + while (1) // ÅжÏÊÇ·ñÁ´½Ó³É¹¦ { - rt_kprintf("<<<<<<<<<<<<<<<<<<< @@ -39,9 +39,9 @@ static enum -static void net_data_rxdone(void) +static void net_data_rxdone (void) { - rt_event_send(gUartEvents,EVENT_UART_ETH2_RX); + rt_event_send (gUartEvents, EVENT_UART_ETH2_RX); //rt_kprintf("net_data_rxdone\r\n"); } @@ -51,32 +51,32 @@ static void thread_entry (void * argument) rt_kprintf ("%s was start!\r\n", __FILE__); g_ETH2Drv.rxdone = net_data_rxdone; - MX_UART_Init(&g_ETH2Drv); + MX_UART_Init (&g_ETH2Drv); // // ×¢²áÍøÂçÇý¶¯ // ×¢²áÍøÂçÇý¶¯ while (1) { //MX_UART_PutBuffer(&g_ETH1Drv,"20140524",8); - if( RT_EOK == rt_event_recv( gUartEvents, EVENT_UART_ETH1_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL )) + if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_ETH1_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL)) { - rt_kprintf("<<<<<<<<<<<<<<<<<<< +#include +#include "data.h" +#include +#include + +#define PROTO_VER "FF_V3.0" + +extern char config_list[16][32]; +extern int config_list_size; + + +// 5 ·ÖÖÓÁ÷Á¿Õ¾Êý¾ÝÉϱ¨ +int Json5MinFlowDataPacket (uint8_t * buffer) +{ + char *result, * packMsg = (char *) buffer; + cJSON *root = NULL; + double dbl[6] = {3.14, 3.12, 3.33, 3.20, 3.12, 3.20}; + int length; + char * p; + root = cJSON_CreateObject(); + cJSON_AddItemToObject (root, "func", cJSON_CreateString ("stand")); // ¹¦ÄÜÂë + p = ef_get_env ("site_type"); + cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "pver", cJSON_CreateString (PROTO_VER)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "iccid", cJSON_CreateString (SysData.iccid)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "ver", cJSON_CreateString (VERSION)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "vol", cJSON_CreateNumber (12.3)); // ±íʾµç³Øµçѹ + cJSON_AddItemToObject (root, "temp", cJSON_CreateNumber (32.5)); // ±íʾÁ÷Á¿¼Æ + p = ef_get_env ("net_drv"); + cJSON_AddItemToObject (root, "netdrv", cJSON_CreateString (p)); // ±íʾÁ÷Á¿¼Æ + p = ef_get_env ("iap_app_filename"); + //uint32_t max_open = atoi (p); + cJSON_AddItemToObject (root, "filename", cJSON_CreateString (p)); // ±íʾµç³Øµçѹ + cJSON_AddItemToObject (root, "chancnt", cJSON_CreateNumber (1)); // ±íʾµç³Øµçѹ + //cJSON_AddItemToObject (root, "chancnt", cJSON_CreateNumber (1)); // ±íʾµç³Øµçѹ + // ˲ʱÁ÷ËÙ + for (int i = 0; i < 6; i++) + { + dbl[i] = WaterData[i].thisSpeed; + } + cJSON * ArrNumSpeed = cJSON_CreateDoubleArray (dbl, 6); + cJSON_AddItemToObject (root, "thisspeed", ArrNumSpeed); + + // ˲ʱÁ÷Á¿ + for (int i = 0; i < 6; i++) + { + dbl[i] = WaterData[i].thisFlow; + } + cJSON * ArrNumFlow = cJSON_CreateDoubleArray (dbl, 6); + cJSON_AddItemToObject (root, "thisflow", ArrNumFlow); + + // ÀÛ¼ÆÁ÷Á¿ + for (int i = 0; i < 6; i++) + { + dbl[i] = WaterData[i].ttWater; + } + cJSON * ArrNumTtflow = cJSON_CreateDoubleArray (dbl, 6); + cJSON_AddItemToObject (root, "ttflow", ArrNumTtflow); + + // µ±Ç°Ë®Î» + for (int i = 0; i < 6; i++) + { + dbl[i] = WaterData[i].thisLevel; + } + cJSON * ArrNumLeve = cJSON_CreateDoubleArray (dbl, 6); + cJSON_AddItemToObject (root, "thisLeve", ArrNumLeve); + // µ±Ç°Ñ¹Á¦ + for (int i = 0; i < 6; i++) + { + dbl[i] = WaterData[i].thisPress; + } + cJSON * ArrNumPress = cJSON_CreateDoubleArray (dbl, 6); + cJSON_AddItemToObject (root, "thispress", ArrNumPress); + + // µ±Ç°ÎÂ¶È + for (int i = 0; i < 6; i++) + { + dbl[i] = WaterData[i].ttWater; + } + cJSON * ArrNumTemp = cJSON_CreateDoubleArray (dbl, 6); + cJSON_AddItemToObject (root, "thistemp", ArrNumTemp); + + //---------------------------------------------ÒÔϲ»×¼ÐÞ¸Ä + result = cJSON_PrintUnformatted (root); + strcpy (packMsg, result); + cJSON_free (result); + cJSON_Delete (root); + length = rt_strlen (packMsg); + return length; +} +// 5·ÖÖÓÕ¢ÃÅÕ¾Êý¾ÝÉϱ¨ +int JsonRegistDataPacket (uint8_t * buffer) +{ + char *result, * packMsg = (char *) buffer; + cJSON *root = NULL; + char * p; + int length; + root = cJSON_CreateObject(); + cJSON_AddItemToObject (root, "func", cJSON_CreateString ("regist")); // ¹¦ÄÜÂë + p = ef_get_env ("site_type"); + cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "pver", cJSON_CreateString (PROTO_VER)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "iccid", cJSON_CreateString (SysData.iccid)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "ver", cJSON_CreateString (VERSION)); // ±íʾÁ÷Á¿¼Æ + p = ef_get_env ("net_drv"); + cJSON_AddItemToObject (root, "netdrv", cJSON_CreateString (p)); // ±íʾÁ÷Á¿¼Æ + p = ef_get_env ("iap_app_filename"); + //uint32_t max_open = atoi (p); + cJSON_AddItemToObject (root, "filename", cJSON_CreateString (p)); // ±íʾµç³Øµçѹ + + //---------------------------------------------ÒÔϲ»×¼ÐÞ¸Ä + result = cJSON_PrintUnformatted (root); + strcpy (packMsg, result); + cJSON_free (result); + cJSON_Delete (root); + length = rt_strlen (packMsg); + return length; +} + + +// 5·ÖÖÓÕ¢ÃÅÕ¾Êý¾ÝÉϱ¨ +int Json5MinSluiceDataPacket (uint8_t * buffer) +{ + char *result, * packMsg = (char *) buffer; + cJSON *root = NULL; + char * p; + int length; + root = cJSON_CreateObject(); + cJSON_AddItemToObject (root, "func", cJSON_CreateString ("stand")); // ¹¦ÄÜÂë + p = ef_get_env ("site_type"); + cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "pver", cJSON_CreateString (PROTO_VER)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "iccid", cJSON_CreateString (SysData.iccid)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "ver", cJSON_CreateString (VERSION)); // ±íʾÁ÷Á¿¼Æ + p = ef_get_env ("net_drv"); + cJSON_AddItemToObject (root, "netdrv", cJSON_CreateString (p)); // ±íʾÁ÷Á¿¼Æ + p = ef_get_env ("iap_app_filename"); + //uint32_t max_open = atoi (p); + cJSON_AddItemToObject (root, "filename", cJSON_CreateString (p)); // ±íʾµç³Øµçѹ + + // Ìí¼ÓÕ¢ÃÅÏà¹ØÊý¾Ý + // Õ¢Ãŵ±Ç°¿ª¶È + cJSON_AddItemToObject (root, "thisopen", cJSON_CreateNumber (SluiceData[0].gopen)); // ±íʾµç³Øµçѹ + // Õ¢ÃÅ×î´ó¿ª¶È + p = ef_get_env ("max_open"); + uint32_t max_open = atoi (p); + cJSON_AddItemToObject (root, "maxopen", cJSON_CreateNumber (max_open)); + // Õ¢ÃÅA·ºÉÖØ + cJSON_AddItemToObject (root, "aload", cJSON_CreateNumber (SluiceData[0].lload)); + // Õ¢ÃÅB·ºÉÖØ + cJSON_AddItemToObject (root, "bload", cJSON_CreateNumber (SluiceData[0].rload)); + // բǰˮλ + cJSON_AddItemToObject (root, "thisleve", cJSON_CreateNumber (WaterData[0].thisLevel)); + // Õ¢ÃÅ˲ʱÁ÷ËÙ + cJSON_AddItemToObject (root, "thisspeed", cJSON_CreateNumber (WaterData[0].thisSpeed)); + // Õ¢ÃÅÀÛ¼ÆÁ÷Á¿ + cJSON_AddItemToObject (root, "thisflow", cJSON_CreateNumber (WaterData[0].thisFlow)); + // Õ¢ÃÅ˲ʱÁ÷Á¿ + cJSON_AddItemToObject (root, "ttflow", cJSON_CreateNumber (WaterData[0].ttWater)); + // Õ¢ÃÅÆô¶¯µçÁ÷ + cJSON_AddItemToObject (root, "current", cJSON_CreateNumber (SluiceData[0].currt)); + // Õ¢ÃűàÂëÆ÷×î´óÖµ + p = ef_get_env ("max_ecode"); + uint32_t max_code = atoi (p); + + cJSON_AddItemToObject (root, "maxecode", cJSON_CreateNumber (max_code)); + p = ef_get_env ("min_ecode"); + uint32_t min_code = atoi (p); + // Õ¢ÃűàÂëÆ÷×îСֵ + cJSON_AddItemToObject (root, "minecode", cJSON_CreateNumber (min_code)); + //---------------------------------------------ÒÔϲ»×¼ÐÞ¸Ä + result = cJSON_PrintUnformatted (root); + strcpy (packMsg, result); + cJSON_free (result); + cJSON_Delete (root); + length = rt_strlen (packMsg); + return length; +} + +// ÐÄÌø°ü£¬ÐèÒªÓ¦´ð +int JsonHeartDatapacket (uint8_t * buffer) +{ + char *result, * packMsg = (char *) buffer; + cJSON *root = NULL; + int length; + char *p; + root = cJSON_CreateObject(); + cJSON_AddItemToObject (root, "func", cJSON_CreateString ("heart")); // ¹¦ÄÜÂë + p = ef_get_env ("site_type"); + cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p)); // ±íʾÁ÷Á¿¼Æ + cJSON_AddItemToObject (root, "ecdState", cJSON_CreateNumber (SysData.ecdState)); // ±àÂëÆ÷״̬ + cJSON_AddItemToObject (root, "flowState", cJSON_CreateNumber (SysData.flowState)); // Á÷Á¿¼Æ״̬ + cJSON_AddItemToObject (root, "ldState", cJSON_CreateNumber (SysData.ldState)); // ºÉÖØÒÇ״̬ + cJSON_AddItemToObject (root, "scram", cJSON_CreateNumber (SysData.scram)); // ºÉÖØÒÇ״̬ + //---------------------------------------------ÒÔϲ»×¼ÐÞ¸Ä + result = cJSON_PrintUnformatted (root); + strcpy (packMsg, result); + cJSON_free (result); + cJSON_Delete (root); + length = rt_strlen (packMsg); + return length; +} + + +int JsonConfigReadDataPacket(uint8_t* buffer) +{ + char *result, * packMsg = (char *) buffer; + cJSON *root = NULL; + int length; + char *p; + root = cJSON_CreateObject(); + cJSON_AddItemToObject (root, "func", cJSON_CreateString ("read_config")); // ¹¦ÄÜÂë + p = ef_get_env ("site_type"); + cJSON_AddItemToObject (root, "site_type", cJSON_CreateString (p)); // ±íʾÁ÷Á¿¼Æ + + for (int i =0 ;i < config_list_size;i++) + { + p = ef_get_env (config_list[i]); + cJSON_AddItemToObject (root, config_list[i], cJSON_CreateString (p)); // ±íʾÁ÷Á¿¼Æ + } + //---------------------------------------------ÒÔϲ»×¼ÐÞ¸Ä + result = cJSON_PrintUnformatted (root); + strcpy (packMsg, result); + cJSON_free (result); + cJSON_Delete (root); + length = rt_strlen (packMsg); + return length; +} + +int JsonAckSuccPacket(char * buffer) +{ + rt_sprintf(buffer,"{\"state\":\"ok\"}"); +} + diff --git a/Board/network/jsonpacket.h b/Board/network/jsonpacket.h new file mode 100644 index 0000000..c5dbdcb --- /dev/null +++ b/Board/network/jsonpacket.h @@ -0,0 +1,18 @@ +#ifndef _JSON_PACKET_H +#define _JSON_PACKET_H +#include + + +// 5 ·ÖÖÓÊý¾ÝÉϱ¨ +int Json5MinFlowDataPacket (uint8_t * buffer); + +// ×¢²á°üÊý¾Ý ÐèÒªÓ¦´ð +int JsonRegistDataPacket (uint8_t * buffer); +// ÐÄÌø°ü£¬ÐèÒªÓ¦´ð +int JsonHeartDatapacket (uint8_t * buffer); + +int Json5MinSluiceDataPacket (uint8_t * buffer); + +int JsonConfigReadDataPacket(uint8_t* buffer); +int JsonAckSuccPacket(char * buffer); +#endif diff --git a/Board/network/jsonunpack.c b/Board/network/jsonunpack.c new file mode 100644 index 0000000..6f3d941 --- /dev/null +++ b/Board/network/jsonunpack.c @@ -0,0 +1,106 @@ +#include "jsonunpack.h" +#include "cjson.h" +#include +#include +#include "data.h" +#include +#include +#include "data.h" +#include "os-app.h" + +char config_list[16][32] = {NULL}; +int config_list_size = 0; + + + +void JsonUnPacket (int index, char *buff) +{ + // ¶ÁÈ¡Json Êý¾ÝÀàÐÍ + char * packMsg = (char *) buff; + cJSON *root = NULL, *list = NULL; + root = cJSON_Parse (packMsg); + DownDataType_t type = (DownDataType_t) 0; + char * p, *key, *value; + int list_size; + TypeIndexMail_t mail; + p = cJSON_GetStringValue (cJSON_GetObjectItem (root, "type")); + type = (DownDataType_t) cDownType2Index (p); + rt_kprintf("down :%s<%d>\r\n",p,type); + switch (type) + { + case DownRun : // ¿ª¶ÈÌáÕ¢ + +// rt_kprintf ("open:%u mm/10\r\n", datak); + +// //SluiceData[gMqttDrv.rx_index].opt = 1; // Ö´ÐвÙ×÷Õ¢ÃÅ +// SluiceData[gMqttDrv.rx_index - 1].sopen = datak / 10; +// mail.Type = MAIL_SLUICE_OPT; +// mail.index = gMqttDrv.rx_index - 1; +// rt_mb_send (gSluiceMail, * ( (uint32_t*) &mail)); + +// // »Ø¸´Ó¦´ð +// mail.Type = MAIL_COMM_SLACK; +// mail.index = gMqttDrv.rx_index; +// rt_mb_send (gTCommMail, * ( (uint32_t*) &mail)); + break; + case DownStop : + break; + case DownOpen : + break; + case DownClose : + break; + case DownRegistAns : + break; + case DownHeartAns : + break; + case DownUpdate : + rt_memset (SysData.fileName, 0, 32); + p = cJSON_GetStringValue (cJSON_GetObjectItem (root, "file")); + rt_sprintf (SysData.fileName, "%s", p) ; + // Æô¶¯Éý¼¶Ïß³Ì + // »Ø¸´Ó¦´ð + mail.Type = MAIL_COMM_UPACK; + mail.index = index + 1; // 0ͨµÀÓÃÀ´Éý¼¶µÄͨµÀ + rt_mb_send (gTCommMail, * ( (uint32_t*) &mail)); + rt_thread_mdelay (2000); // µÈ´ý2s ½øÈëÉý¼¶Ïß³Ì + UpgradeThreadStart(); + break; + case DownReboot : + break; + case DownConfig: // ÉèÖòÎÊý + // ¶ÁÈ¡²ÎÊýÁбí + list = cJSON_GetObjectItem (root, "list"); + list_size = cJSON_GetArraySize (list); + for (int i = 0; i < list_size; i++) + { + key = cJSON_GetStringValue (cJSON_GetArrayItem (list, i)); + value = cJSON_GetStringValue (cJSON_GetObjectItem (root, key)); + if ( (ef_get_env (key) != NULL) && (value != NULL)) + { + ef_set_env (key, value); + } + } + break; + case DownRead: // ¶ÁÈ¡²ÎÊý + list = cJSON_GetObjectItem (root, "list"); + config_list_size = cJSON_GetArraySize (list); + for (int i = 0; i < config_list_size; i++) + { + key = cJSON_GetStringValue (cJSON_GetArrayItem (list, i)); + rt_sprintf(config_list[i],"%s",key); + } + mail.Type = MAIL_COMM_READPARA; + mail.index = index + 1; // 0ͨµÀÓÃÀ´Éý¼¶µÄͨµÀ + rt_mb_send (gTCommMail, * ( (uint32_t*) &mail)); + // ¶ÁÈ¡²ÎÊýÁбí + break; + default: + break; + } + cJSON_Delete (root); +} + + + + + diff --git a/Board/network/jsonunpack.h b/Board/network/jsonunpack.h new file mode 100644 index 0000000..9c8547b --- /dev/null +++ b/Board/network/jsonunpack.h @@ -0,0 +1,9 @@ +#ifndef _JSON_UNPACKET_H +#define _JSON_UNPACKET_H +#include + + + + +void JsonUnPacket (int index, char *buff); +#endif diff --git a/Board/network/mje1s2fdrv.c b/Board/network/mje1s2fdrv.c new file mode 100644 index 0000000..82aba7d --- /dev/null +++ b/Board/network/mje1s2fdrv.c @@ -0,0 +1,114 @@ +#include +#include +#include +#include "main.h" +#include "usart-board.h" +#include +#include +#include +#include "netdrv.h" + + + + + + +#if !defined(LOG_TAG) +#define LOG_TAG "MJE1S2" +#endif +#include + + +ALIGN (RT_ALIGN_SIZE) +static char thread_stack[4096]; +static struct rt_thread thread; +static char tcprxbbuff[1200]; +static char tcptxbbuff[1200]; + + + +netDrv_t g_MJEth1Drv = +{ + 0, // ÐźÅÖµ + "", // iccid + Init, // ״̬ + tcprxbbuff, // ½ÓÊÜ»º´æ + 0, // ½ÓÊÜÊý¾Ý³¤¶È + tcptxbbuff, // ·¢ËÍÊý¾Ý»º´æ + 0, // ·¢ËÍÊý¾Ý³¤¶È +}; + + +static void mje1s2f_rx_done (void) +{ + rt_event_send (gUartEvents, EVENT_UART_ETH1_RX); + +} + + + + + +static void thread_entry (void * argument) +{ + + + + uint8_t low_leve = 0; // ¸ßµçƽʱ¼ä + g_ETH1Drv.rxdone = mje1s2f_rx_done; + g_ETH1Drv.BaudRate = 115200; + // Æô¶¯4G Ä£¿éµçÔ´ + // À­¸ß4G Ä£¿é¸´Î» + MX_UART_Init (&g_ETH1Drv); + HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET); + rt_thread_mdelay (1000); + HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin | GSM_PW_Pin, GPIO_PIN_SET); + rt_thread_mdelay (3000); + while (1) + { +MODE_RST: + MX_UART_Init (&g_ETH1Drv); + HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET); + rt_thread_mdelay (1000); + HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin | GSM_PW_Pin, GPIO_PIN_SET); + rt_thread_mdelay (3000); + while (1) // ÅжÏÊÇ·ñÁ´½Ó³É¹¦ + { + + } + +//// rt_kprintf("zs0010+++++++++++++++++++\r\n"); +// MX_UART_PutBuffer(&g_ETH1Drv,(char *)readip,13) ; +// + // ·¢ËÍÊý¾Ý + if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_ETH1_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 2000, RT_NULL)) // ÐèÒª·¢ËÍÊý¾Ý + { + for (int i = 0 ; i < g_ETH1Drv.rx_size; i++) + { + rt_kprintf ("%02X", g_ETH1Drv.rx_buffer[i]); + } + rt_kprintf ("\r\n"); + MX_UART_Clear (&g_ETH1Drv) ; + } + + rt_thread_mdelay (10); + } + +} + + + + + +void MJEth1ThreadStart (void) +{ + /* ´´½¨Ïß³Ì1£¬Ãû³ÆÊÇthread1£¬Èë¿ÚÊÇthread1_entry */ + rt_thread_init (&thread, "mjeth1_thread", + thread_entry, RT_NULL, + &thread_stack[0], + sizeof (thread_stack), + MJETH1_THREAD_PRIORITY, MJETH1_THREAD_TIMESLICE); + rt_thread_startup (&thread); + + return ; +} diff --git a/Board/network/mje1s2fdrv.h b/Board/network/mje1s2fdrv.h new file mode 100644 index 0000000..cd6ea47 --- /dev/null +++ b/Board/network/mje1s2fdrv.h @@ -0,0 +1,12 @@ +#ifndef _MJETH1_DRV_H +#define _MJETH1_DRV_H + + + + + + + + + +#endif diff --git a/Board/network/mqtt-board.c b/Board/network/mqtt-board.c new file mode 100644 index 0000000..88e2b14 --- /dev/null +++ b/Board/network/mqtt-board.c @@ -0,0 +1,323 @@ + +#include "main.h" + +#include "os-app.h" + +#include +#include +#include +#include "usart-board.h" +#include +#include "transport.h" +#include +#include "mqtt-board.h" +#include "netdrv.h" +#include "stdlib.h" +#include "data.h" + + + + +#if !defined(LOG_TAG) +#define LOG_TAG "mqtt" +#endif +#include + +ALIGN (RT_ALIGN_SIZE) +static char thread_stack[2048]; +static struct rt_thread mqtt_thread; + + + + + + +static rt_timer_t timer; + +static char mqtt_tx_buff[500]; +static char mqtt_rx_buff[500]; + + + +static enum {CONN = 1, DISC = 0} State = DISC; +MqttDrv_t gMqttDrv = +{ + .State = DISC, + .txbuff = mqtt_tx_buff, + .tx_size = 0, + .tx_index = 0, + .rxbuff = mqtt_rx_buff, + .rx_size = 0, + .rx_index = 0 +}; + + + +// ¶¨Òåmqtt µÄÊý¾Ý´æ´¢buffer +#define MQTT_BUFF_LENGTH 1500 +static uint8_t mqtt_buffer[MQTT_BUFF_LENGTH]; + +//static uint8_t mqtt_payload[1200]; +//// ¶¨ÒåmqttÏûÏ¢µÄ Êý¾Ý³¤¶È +//static int mqtt_payload_size = 0; +// ¶¨ÒåmqttÏûÏ¢µÄ Êý¾Ý³¤¶È +static int mqtt_buflen = 0; +// ¶¨Òåqos +static int qos[SUBTOPIC_COUNT + 1] = {0}; +// ¶¨Òåmessage id +static int message_id = 0; + +// ¶¨Òåmqtt Á´½Ó²ÎÊý +MQTTPacket_connectData connectData = MQTTPacket_connectData_initializer; +MQTTString subtopic[SUBTOPIC_COUNT + 1] = {MQTTString_initializer}; +MQTTString pubtopic[SUBTOPIC_COUNT + 1] = {MQTTString_initializer}; +char sub_topic_str[SUBTOPIC_COUNT + 1][64] = {NULL}; +char pub_topic_str[SUBTOPIC_COUNT + 1][64] = {NULL}; +char client_id_str[64] = {NULL}; + + +static char device_id[32] = {NULL}; // É豸±àÂë +static char user_topic[32] = {NULL}; // topic + +static void net_data_rxdone (void) +{ + rt_event_send (gUartEvents, EVENT_UART_ETH1_RX); +} + +static int timerout_timer = 0; +static void timerouter (void * parameter) +{ + timerout_timer ++; + if (timerout_timer > 90) // ³¬¹ý90s ûÓÐÊÕµ½Êý¾Ý£¬ÖØÆôÍøÂç + { + rt_event_send (gTrigEvents, EVENT_TRIG_MQTT_RST); + timerout_timer = 0; + } +} + + +static void thread_entry (void * argument) +{ + + int count = 0; + // ³õʼ»¯´®¿ÚÇý¶¯ + rt_kprintf ("%s was start!\r\n", __FILE__); + timer = rt_timer_create ("timer", timerouter, RT_NULL, 1000, RT_TIMER_FLAG_PERIODIC); // Òì³£¼ì²â¶¨Ê±Æ÷ + // ¶ÁÈ¡ÅäÖÃÎļþ + char * p = ef_get_env ("device_id"); + rt_sprintf (device_id, "%s", p); + p = ef_get_env ("mqtt_topic"); + rt_memcpy (user_topic, p, strlen (p)); + + int id = rand() % 1000; + rt_sprintf (client_id_str, "GID_SLUICE_V2_220000%s", device_id) ; + rt_kprintf ("clinet:%s\r\n", client_id_str); + connectData.clientID.cstring = client_id_str; + connectData.keepAliveInterval = 120; + connectData.cleansession = 1; + connectData.username.cstring = "admin"; + connectData.password.cstring = "admin"; + rt_sprintf (sub_topic_str[0], "device/%s/tx/220000%s", "update", device_id); + rt_sprintf (pub_topic_str[0], "device/%s/rx/220000%s", "update", device_id); + // ¶ÁÈ¡É豸±àÂë + rt_sprintf (sub_topic_str[1], "device/%s/tx/220000%s", user_topic, device_id); + rt_sprintf (pub_topic_str[1], "device/%s/rx/220000%s", user_topic, device_id); +#if (SUBTOPIC_COUNT > 1) + rt_sprintf (sub_topic_str[2], "device/%s/tx/2200002308170002", user_topic); + rt_sprintf (pub_topic_str[2], "device/%s/rx/2200002308170002", user_topic); +#endif + + for (int i = 0; i < SUBTOPIC_COUNT + 1; i++) + { + subtopic[i].cstring = sub_topic_str[i]; + pubtopic[i].cstring = pub_topic_str[i]; + } + + rt_timer_start (timer); + while (1) + { +MQTTINIT: + if (g_netDrv->State != Conn) + { + //rt_kprintf ("mqtt tcp-connected fail\r\n"); + rt_thread_delay (1000); // ÑÓ³Ù3s µÈ´ýÄ£¿éÁ¬½ÓTCP ·þÎñ³É¹¦ + goto MQTTINIT; + } + // Á´½ÓMQTT ·þÎñÆ÷ + rt_kprintf ("mqtt connected\r\n"); + mqtt_buflen = MQTTSerialize_connect (mqtt_buffer, MQTT_BUFF_LENGTH, &connectData); + netdrv_service_tx (mqtt_buffer, mqtt_buflen); + if (RT_EOK != rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_RX1, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 10000, RT_NULL)) + { + goto MQTTINIT; + } + rt_thread_mdelay (10); + if (MQTTPacket_read (mqtt_buffer, MQTT_BUFF_LENGTH, netdrv_getdata) == CONNACK) + { + unsigned char sessionPresent, connack_rc; + if (MQTTDeserialize_connack (&sessionPresent, &connack_rc, mqtt_buffer, MQTT_BUFF_LENGTH) != 1 || connack_rc != 0) + { + rt_kprintf ("Unable to connect, return code %d\n", connack_rc); + rt_thread_delay (3000); + netdrv_clear(); + goto MQTTINIT; + } + } + else + { + rt_kprintf ("mqtt error"); + netdrv_clear(); + goto MQTTINIT; + } + netdrv_clear(); + rt_kprintf ("connect to mqtt successful\n"); + // ¶©ÔÄtopic + mqtt_buflen = MQTTSerialize_subscribe (mqtt_buffer, MQTT_BUFF_LENGTH, 0, message_id++, SUBTOPIC_COUNT + 1, subtopic, qos); + netdrv_service_tx (mqtt_buffer, mqtt_buflen); + if (RT_EOK != rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_RX1, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 10000, RT_NULL)) + { + netdrv_clear(); + goto MQTTINIT; + } + if (MQTTPacket_read (mqtt_buffer, MQTT_BUFF_LENGTH, netdrv_getdata) == SUBACK) /* wait for suback */ + { + unsigned short submsgid; + int subcount; + int granted_qos; + MQTTDeserialize_suback (&submsgid, 1, &subcount, &granted_qos, mqtt_buffer, MQTT_BUFF_LENGTH); + if (granted_qos != 0) + { + rt_kprintf ("granted qos != 0, %d\n", granted_qos); + netdrv_clear(); + goto MQTTINIT; + } + } + else + { + rt_kprintf ("sub topic faild\r\n"); + rt_thread_delay (1000); + netdrv_clear(); + goto MQTTINIT; + } + netdrv_clear(); + + rt_kprintf ("subtopic topic %s\r\n", subtopic[0].cstring); + rt_event_send (gTrigEvents, EVENT_TRIG_MQTT_SUB); + netdrv_clear(); + rt_thread_delay (500); + State = CONN; + while (1) + { + // ½ÓÊܵ½Êý¾Ý + if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_NETMODE_RX1, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL)) + { + if (MQTTPacket_read (mqtt_buffer, MQTT_BUFF_LENGTH, netdrv_getdata) == PUBLISH) + { + + unsigned char dup; + int qos; + unsigned char retained; + unsigned short msgid; + int payloadlen_in; + unsigned char* payload_in; + int rc; + MQTTString receivedTopic; + rc = MQTTDeserialize_publish (&dup, &qos, &retained, &msgid, &receivedTopic, + &payload_in, &payloadlen_in, mqtt_buffer, MQTT_BUFF_LENGTH); + rt_memcpy (gMqttDrv.rxbuff, payload_in, payloadlen_in) ; + gMqttDrv.rx_size = payloadlen_in; + //rt_memcpy(gMqttDrv.topic,receivedTopic.lenstring.data,receivedTopic.lenstring.len); + + + for (int var = 0; var < SUBTOPIC_COUNT + 1; ++var) + { + if (rt_memcmp (subtopic[var].cstring, receivedTopic.lenstring.data, receivedTopic.lenstring.len) == 0) + { + gMqttDrv.rx_index = var; + rt_kprintf ("recv from :%d,%*.s\r\n", gMqttDrv.rx_index, receivedTopic.lenstring.len, receivedTopic.lenstring.data); + break; + } + } + if (gMqttDrv.rx_index == 0) // 0 ͨµÀΪÉý¼¶Í¨µÀ + { + rt_event_send (gTrigEvents, EVENT_TRIG_UPGRADE_RX); + } + else + { + rt_event_send (gTrigEvents, EVENT_TRIG_COMM_RX); + } + timerout_timer = 0; + } + netdrv_clear(); + } + // ·¢ËÍÊý¾Ý + if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_MQTT_TX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL)) + { + mqtt_buflen = MQTTSerialize_publish (mqtt_buffer, MQTT_BUFF_LENGTH, 0, 0, 0, 0, pubtopic[gMqttDrv.tx_index], (uint8_t *) gMqttDrv.txbuff, gMqttDrv.tx_size); + netdrv_service_tx (mqtt_buffer, mqtt_buflen); + } + if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_MQTT_RST, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 0, RT_NULL)) + { + rt_kprintf ("mqtt conn lost\r\n"); + netdrv_reset(); + State = DISC; + rt_event_send (gTrigEvents, EVENT_TRIG_COMM_RST); + goto MQTTINIT; + } + // ÍøÂçÁ´½Ó¶ªÊ§ + if (g_netDrv->State != Conn) + { + rt_kprintf ("mqtt conn lost\r\n"); + netdrv_reset(); + State = DISC; + rt_event_send (gTrigEvents, EVENT_TRIG_COMM_RST); + goto MQTTINIT; + } + rt_thread_delay (100); + } + } + +} + + + +void MQTT_SendData (void) +{ + +// topic_index = index; +//// rt_memcpy(mqtt_payload,data,size); +//// mqtt_payload_size = size ; + rt_event_send (gTrigEvents, EVENT_TRIG_MQTT_TX); +} +int MQTT_Subscribed (void) +{ + return State; +} + + +void MQTTThreadStart (void) +{ + /* ´´½¨Ïß³Ì1£¬Ãû³ÆÊÇthread1£¬Èë¿ÚÊÇthread1_entry*/ + rt_thread_init (&mqtt_thread, "mqtt_thread", + thread_entry, RT_NULL, + &thread_stack[0], + sizeof (thread_stack), + MQTT_THREAD_PRIORITY, MQTT_THREAD_TIMESLICE); + rt_thread_startup (&mqtt_thread); + + return ; +} + + + + +void shell_mqtt_time (void) +{ + rt_kprintf ("lost_timer:%u\r\n", timerout_timer) ; +} + + + + + + diff --git a/Board/network/mqtt-board.h b/Board/network/mqtt-board.h new file mode 100644 index 0000000..2445f0f --- /dev/null +++ b/Board/network/mqtt-board.h @@ -0,0 +1,22 @@ +#ifndef _MQTT__BOARD_H +#define _MQTT__BOARD_H + + + +void MQTTThreadStart (void); +void MQTT_SendData (void); +int MQTT_Subscribed (void); + + +typedef struct MqttDrv_t +{ + int State; // ¶©Ôijɹ¦ + char * txbuff; + int tx_size; + uint8_t tx_index; + char * rxbuff; + int rx_size; + uint8_t rx_index;// ½ÓÊÜÊý¾ÝµÄ¶©ÔÄ +} MqttDrv_t; + +#endif diff --git a/Board/network/netdrv.c b/Board/network/netdrv.c new file mode 100644 index 0000000..bb00857 --- /dev/null +++ b/Board/network/netdrv.c @@ -0,0 +1,161 @@ +#include +#include +#include +#include "main.h" +#include "usart-board.h" +#include +#include +#include +#include "netdrv.h" +#include "dtu-board.h" + +extern netDrv_t g_cat1Drv; +extern netDrv_t g_MJEth1Drv; +extern netDrv_t g_dtuDrv; + + +netDrv_t * g_netDrv; + + +static int mysock = 0; +static int offset = 0; + + + +void netdrv_init (void) +{ + char * drv = ef_get_env ("net_drv"); // ¶ÁÈ¡ÍøÂçÀàÐÍ + if (rt_memcmp ("dtu", drv, 3) == 0) // Çý¶¯³ÌÐòλDTUģʽ£¬¾ÍÊDz»Í¨¹ý±¾µØÅäÖã¬Ö±½Ó͸´« + { + g_netDrv = &g_dtuDrv; + DTUThreadStart(); + } + else if (rt_memcmp ("ec200", drv, 4) == 0) + { + g_netDrv = &g_cat1Drv; + + CAT1ThreadStart(); + } +// else if (rt_memcmp ("eth", drv, 3) == 0) +// { +// g_netDrv = &g_MJEth1Drv; +// MJEth1ThreadStart(); +// } + else + { + + } +} + + +void netdrv_service_tx (uint8_t * data, int length) +{ + char * drv = ef_get_env ("net_drv"); // ¶ÁÈ¡ÍøÂçÀàÐÍ + if (rt_memcmp ("dtu", drv, 3) == 0) // Çý¶¯³ÌÐòλDTUģʽ£¬¾ÍÊDz»Í¨¹ý±¾µØÅäÖã¬Ö±½Ó͸´« + { + dtu_service_tx ( (char *) data, length); + } + else if (rt_memcmp ("ec200", drv, 4) == 0) + { + cat1_service_tx ( (char *) data, length); + } + else if (rt_memcmp ("eth", drv, 3) == 0) + { + + } + else + { + + } +} + +void netdrv_reset (void) +{ + char * drv = ef_get_env ("net_drv"); // ¶ÁÈ¡ÍøÂçÀàÐÍ + if (rt_memcmp ("dtu", drv, 3) == 0) // Çý¶¯³ÌÐòλDTUģʽ£¬¾ÍÊDz»Í¨¹ý±¾µØÅäÖã¬Ö±½Ó͸´« + { + dtu_netreset(); + } + else if (rt_memcmp ("ec200", drv, 4) == 0) + { + //cat1_service_tx ( (char *) data, length); + } + else if (rt_memcmp ("eth", drv, 3) == 0) + { + + } + else + { + + } +} + + +int netdrv_getdata (unsigned char* buf, int count) +{ + int tsize = 0; + char * drv = ef_get_env ("net_drv"); // ¶ÁÈ¡ÍøÂçÀàÐÍ + if (rt_memcmp ("dtu", drv, 3) == 0) // Çý¶¯³ÌÐòλDTUģʽ£¬¾ÍÊDz»Í¨¹ý±¾µØÅäÖã¬Ö±½Ó͸´« + { + if (offset + count > g_netDrv->rx_size) + { + tsize = g_netDrv->rx_size - offset; + rt_memcpy (buf, &g_netDrv->rxbuff[offset], tsize); + } + else + { + tsize = count; + rt_memcpy (buf, &g_netDrv->rxbuff[offset], tsize); + } + + } + else if (rt_memcmp ("ec200", drv, 4) == 0) + { + if (offset + count > g_netDrv->rx_size) + { + tsize = g_netDrv->rx_size - offset; + rt_memcpy (buf, &g_netDrv->rxbuff[offset], tsize); + } + else + { + tsize = count; + rt_memcpy (buf, &g_netDrv->rxbuff[offset], tsize); + } + } + else if (rt_memcmp ("eth", drv, 3) == 0) + { + + } + else + { + + } + offset += count; + return tsize; +} + + +int netdrv_clear (void) +{ + + char * drv = ef_get_env ("net_drv"); // ¶ÁÈ¡ÍøÂçÀàÐÍ + if (rt_memcmp ("dtu", drv, 3) == 0) // Çý¶¯³ÌÐòλDTUģʽ£¬¾ÍÊDz»Í¨¹ý±¾µØÅäÖã¬Ö±½Ó͸´« + { + MX_UART_Clear (&g_ETH1Drv); + + } + else if (rt_memcmp ("ec200", drv, 4) == 0) + { + //rt_memcpy(buf, &g_cat1Drv.rxbuff[offset], count); + } + else if (rt_memcmp ("eth", drv, 3) == 0) + { + + } + else + { + + } + offset = 0; + return 0; +} diff --git a/Board/network/netdrv.h b/Board/network/netdrv.h new file mode 100644 index 0000000..9458e46 --- /dev/null +++ b/Board/network/netdrv.h @@ -0,0 +1,41 @@ +#ifndef _NET_DRV_H +#define _NET_DRV_H + + +typedef enum netDrvState_t +{ + Init, // ³õʼ»¯×´Ì¬ + Join, // ÈëÍø + Conn, // ÈëÍø³É¹¦ + Idle // ¿ÕÏÐ +} netDrvState_t; + +typedef struct netDrv_t +{ + int Csq; + char Iccid[20]; + netDrvState_t State; + char * rxbuff; + int rx_size; // ½ÓÊܵ½µÄtcp Êý¾Ý»º´æ + char * txbuff; // ·¢Ë͵ÄTCP Êý¾Ý»º´æ + int tx_size; +} netDrv_t; + + +typedef enum CommRet_T +{ + RetSucc, + RetErr +} CommRet_T; + +extern netDrv_t * g_netDrv;; + + +void netdrv_service_tx (uint8_t * data, int length); +int netdrv_getdata (uint8_t* buf, int count); +int netdrv_clear (void); +void netdrv_init (void); +void netdrv_reset (void); // ÍøÂçÁ´½Óʧ°Ü£¬Í¨ÖªÇý¶¯ÖØÐÂÆô¶¯ÍøÂçÄ£¿é + + +#endif diff --git a/Board/network/network.c b/Board/network/network.c new file mode 100644 index 0000000..354e435 --- /dev/null +++ b/Board/network/network.c @@ -0,0 +1,43 @@ + +#include "main.h" + +#include "os-app.h" + +#include +#include +#include +#include "usart-board.h" + + +void networkInit (void) +{ + +} + + +// ÍøÂçÏß³Ì mqtt Ïß³ÌºÍ Çý¶¯¶¼´ÓÕâÀï×ß +void networkthread_entry (void * argument) +{ + while (1) + { + + } +} + + + + + + + +#if !defined(LOG_TAG) +#define LOG_TAG "network" +#endif +#include + + + + + + + diff --git a/Board/network/network.h b/Board/network/network.h new file mode 100644 index 0000000..76d054d --- /dev/null +++ b/Board/network/network.h @@ -0,0 +1,10 @@ +#ifndef _NET_WORK_H +#define _NET_WORK_H + + + +#endif + + + + diff --git a/Board/network/proto.c b/Board/network/proto.c new file mode 100644 index 0000000..dea9e6f --- /dev/null +++ b/Board/network/proto.c @@ -0,0 +1,238 @@ +#include "proto.h" +#include "util.h" +#include "main.h" +#include "data.h" +#include "crc.h" +#include +#include +#include "data.h" + + + + +static int g_syn_number = 0; + + +// ´ò°üÊý¾ÝÖ¡ +int PacketHeader (uint8_t func, char * data, int length, char * txbuff) +{ + char * p; + char id [5]; + p = ef_get_env ("device_id"); + hexstr_to_hexbyte (p, id, 10); + int tx_size = 0; + uint16_t crc = 0; + txbuff[tx_size++] = 0x7E; + txbuff[tx_size++] = 0x7E; + txbuff[tx_size++] = 0x01; + txbuff[tx_size++] = 0xFF; + txbuff[tx_size++] = 0xFF; + for (int i = 0; i < 5; i++) + { + txbuff[tx_size++] = id[i]; + } + txbuff[tx_size++] = func; + txbuff[tx_size++] = 0x00; + txbuff[tx_size++] = length;// ³¤¶È + txbuff[tx_size++] = _651_STX; + //dbg_printf ("sizeof (_651_U_Header_t):%d\r\n", tx_size); + + for (int i = 0; i < length; i++) + { + txbuff[tx_size++] = data[i]; + } + txbuff[tx_size++] = 0x03; + + crc = MX_CRC_CALC ( (uint8_t *) txbuff, tx_size); //MX_; + + txbuff[tx_size++] = (crc >> 8) & 0x00FF; + txbuff[tx_size++] = crc & 0x00FF; + return tx_size; + // + // ¼ÆËãУÑé +} + +// ¾ùÔÈʱ¶Î±¨ +int PakcetTimerUp (int k, char * tx_data) +{ + + char * p; + char id [5]; + p = ef_get_env ("device_id"); + hexstr_to_hexbyte (p, id, 10); + int tx_size = 0; + g_syn_number ++; + Int intk; + tx_data[tx_size++] = (g_syn_number >> 8) & 0x00FF; + tx_data[tx_size++] = g_syn_number & 0xFF; + for (int i = 0; i < 6; i++) + { + tx_data[tx_size++] = 0; + } + for (int i = 0; i < 5; i++) + { + tx_data[tx_size++] = id[i]; + } + tx_data[tx_size++] = 0x5A; //Õ¢°Ó + for (int i = 0; i < 6; i++) + { + tx_data[tx_size++] = 0; + } + tx_data[tx_size++] = 0x30; // ±àÂëÒªËØ + tx_data[tx_size++] = 0xFF; // ÒªËØ1 ˲ʱÁ÷ËÙ + tx_data[tx_size++] = 0x31; // ÒªËØ1 ˲ʱÁ÷ËÙ + tx_data[tx_size++] = 0xFF; // ÒªËØ1 ˲ʱÁ÷Á¿ + tx_data[tx_size++] = 0x32; // ÒªËØ1 ˲ʱÁ÷Á¿ + tx_data[tx_size++] = 0xFF; // ÒªËØ1 ÀÛ¼ÆÁ÷Á¿ + tx_data[tx_size++] = 0x33; // ÒªËØ1 ÀÛ¼ÆÁ÷Á¿ + tx_data[tx_size++] = 0xFF; // ÒªËØ1 Õ¢ÃÅ¿ª¶È + tx_data[tx_size++] = 0x34; // ÒªËØ1 Õ¢ÃÅ¿ª¶È + tx_data[tx_size++] = 0xFF; // ÒªËØ1 Õ¢ÃźÉÖØ + tx_data[tx_size++] = 0x35; // ÒªËØ1 Õ¢ÃźÉÖØ + + tx_data[tx_size++] = 0xFF; // ÒªËØ1 ÀÛ¼ÆÁ÷Á¿ + tx_data[tx_size++] = 0x36; // ÒªËØ1 ÀÛ¼ÆÁ÷Á¿ + tx_data[tx_size++] = 0xFF; // ÒªËØ1 Õ¢ÃÅ¿ª¶È + tx_data[tx_size++] = 0x37; // ÒªËØ1 Õ¢ÃÅ¿ª¶È + tx_data[tx_size++] = 0xFF; // ÒªËØ1 Õ¢ÃźÉÖØ + tx_data[tx_size++] = 0x38; // ÒªËØ1 Õ¢ÃźÉÖØ + + tx_data[tx_size++] = 0xFF; // ÒªËØ1 բǰˮλ + tx_data[tx_size++] = 0x39; // ÒªËØ1 բǰˮλ + + intk.data = WaterData[0].thisSpeed * 100; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + + intk.data = WaterData[0].thisFlow * 100; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + + intk.data = WaterData[0].ttWater * 100; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + intk.data = SluiceData[k].gopen * 10; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + + intk.data = (SluiceData[k].lload + SluiceData[k].rload) * 10; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + + // ÒªËØ6 ×î´ó¿ª¶È + intk.data = ef_get_integer ("max_open") * 10; // µ¥Î»mm *10 + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + + // ÒªËØ7 µç³Øµçѹ + intk.data = 0 * 100; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + + // ÒªËØ8 »úÏäÎÂ¶È + intk.data = 0 * 100; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + + // ÒªËØ9 բǰˮλ + intk.data = WaterData[0].thisLevel; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + return tx_size; + +} + +// Õ¢ÃÅ״̬×Ô±¨ Õ¢ÃÅ¿ª¶È·¢Éú±ä»¯Ê±Éϱ¨ +int PacketSluiceUp (int k, char * tx_data) +{ + int tx_size = 0; + g_syn_number ++; + Int intk; + tx_data[tx_size++] = (g_syn_number >> 8) & 0x00FF; + tx_data[tx_size++] = g_syn_number & 0xFF; + tx_data[tx_size++] = 0x01; + tx_data[tx_size++] = 0x01; +// // Õ¢ÃÅ¿ª¶È + intk.data = SluiceData[k].gopen * 10; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + + intk.data = (SluiceData[k].lload + SluiceData[k].rload) * 10; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + // բǰˮλ + intk.data = WaterData[0].thisLevel; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + // ˲ʱÁ÷Á¿ + intk.data = 0 * 100; + tx_data[tx_size++] = intk.byte[3]; + tx_data[tx_size++] = intk.byte[2]; + tx_data[tx_size++] = intk.byte[1]; + tx_data[tx_size++] = intk.byte[0]; + return tx_size; + +} + +// ½ÓÊܵ½ÌáÕ¢Êý¾Ýʱ£¬Ó¦´ðµÄACK +int PacketSluiceAck (char* tx_data) +{ + int tx_size = 0; + g_syn_number ++; + tx_data[tx_size++] = (g_syn_number >> 8) & 0x00FF; + tx_data[tx_size++] = g_syn_number & 0xFF; + for (int i = 0; i < 6; i++) + { + tx_data[tx_size++] = 0; + } + + for (int i = 0; i < 5; i++) + { + tx_data[tx_size++] = 0xEE; + } + return tx_size; +} + + +int PacketAnsAck (char * tx_data) +{ + int size = 0; + size = rt_sprintf (tx_data, "{\"result\":\"ok\"}"); + return size; +} + + +int PacketUpRegist (char * tx_data) +{ + + int tx_size = rt_sprintf (tx_data, "{\"iccid\":\"%s\",\"version\":\"%s\"}", SysData.iccid, VERSION); + return tx_size ; +} + + + + diff --git a/Board/network/proto.h b/Board/network/proto.h new file mode 100644 index 0000000..3a53684 --- /dev/null +++ b/Board/network/proto.h @@ -0,0 +1,64 @@ +#ifndef _PROTO_H +#define _PROTO_H +#include + + +// ÉÏÐÐͳһʹÓÃM1ģʽ£¬ÎÞÈ·ÈÏ +// ÏÂÐÐͳһʹÓÃM2ģʽһ´ÎÈ·ÈÏ + +#define _651_STX 2 +#define _651_ETX 3 +#define _651_ETB 23 + + + +#pragma pack (1) +typedef struct _651_U_Header_t +{ + uint16_t Head; + uint8_t CentAddr; + uint8_t DeviAddr[5]; + uint16_t Pass; + uint8_t FuncCode; + uint16_t TypeLength; + uint8_t Stx; +} _651_U_Header_t; + +typedef struct _651_D_Header_t +{ + uint16_t Head; + uint8_t DeviAddr[5]; + uint8_t CentAddr; + uint16_t Pass; + uint8_t FuncCode; + uint16_t Type: 4; + uint16_t Length: 12; + uint8_t Stx; +} _651_D_Header_t; +#pragma pack () + + + + +// ´ò°üÊý¾ÝÖ¡ +int PacketHeader (uint8_t func, char * data, int length, char * txbuff); + +// ¾ùÔÈʱ¶Î±¨ +int PakcetTimerUp (int k, char * tx_data); + +// Õ¢ÃÅ״̬×Ô±¨ Õ¢ÃÅ¿ª¶È·¢Éú±ä»¯Ê±Éϱ¨ +int PacketSluiceUp (int k, char * tx_data); + +// ½ÓÊܵ½ÌáÕ¢Êý¾Ýʱ£¬Ó¦´ðµÄACK +int PacketSluiceAck (char* tx_data); + + +int PacketAnsAck (char * tx_data); +int PacketUpRegist (char * tx_data); + + + + + + +#endif diff --git a/Board/network/zs001drv.c b/Board/network/zs001drv.c new file mode 100644 index 0000000..bfbd533 --- /dev/null +++ b/Board/network/zs001drv.c @@ -0,0 +1,132 @@ +#include +#include +#include +#include "main.h" +#include "usart-board.h" +#include +#include +#include +#include "netdrv.h" + + + + + + +#if !defined(LOG_TAG) +#define LOG_TAG "CAT1" +#endif +#include + + +ALIGN (RT_ALIGN_SIZE) +static char thread_stack[4096]; +static struct rt_thread thread; +static char tcprxbbuff[1200]; +static char tcptxbbuff[1200]; + + +static const uint8_t header[] = {0xed, 0xf2, 0xa3, 0x56, 0xca, 0xdb, 0x91, 0x84, 0xb0, 0xd7}; +static const uint8_t readip[] = {0xed, 0xf2, 0xa3, 0x56, 0xca, 0xdb, 0x91, 0x84, 0xb0, 0xd7, 0x00, 0x00, 0x04}; + + +netDrv_t g_ZS001Drv = +{ + 0, // ÐźÅÖµ + "", // iccid + Init, // ״̬ + tcprxbbuff, // ½ÓÊÜ»º´æ + 0, // ½ÓÊÜÊý¾Ý³¤¶È + tcptxbbuff, // ·¢ËÍÊý¾Ý»º´æ + 0, // ·¢ËÍÊý¾Ý³¤¶È +}; + + +static void zs001_rx_done (void) +{ + rt_event_send (gUartEvents, EVENT_UART_ETH1_RX); + +} + + + +static int zs001_packet_commad (int type, int loc, int size, char * data) +{ + int index = 0; + for (int i = 0; i < 10; i++) + { + data[index++] = header[i]; + } + data[index++] = type; + data[index++] = loc; + data[index++] = size; + return index; +} + + +static void thread_entry (void * argument) +{ + +// char at_cmd[128] = {NULL}; +// char ipaddr[32] = {NULL}; +// int ipport; +// char *p; +// int retry = 0; + + + +// char send_data[32]; +// int size = 0; +// size = zs001_packet_commad(0,) +// p = ef_get_env ("mqtt_addr"); +// rt_strncpy (ipaddr, p, rt_strlen (p)); +// p = ef_get_env ("mqtt_port"); +// ipport = atoi (p); + //rt_sprintf (at_cmd, "AT+QIOPEN=1,0,\"TCP\",\"%s\",%d,0,0\r", ipaddr, ipport); + g_ETH1Drv.rxdone = zs001_rx_done; + g_ETH1Drv.BaudRate = 115200; + // Æô¶¯4G Ä£¿éµçÔ´ + // À­¸ß4G Ä£¿é¸´Î» + MX_UART_Init (&g_ETH1Drv); + HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET); + rt_thread_mdelay (1000); + HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin | GSM_PW_Pin, GPIO_PIN_SET); + rt_thread_mdelay (3000); + while (1) + { + +// rt_kprintf("zs0010+++++++++++++++++++\r\n"); + MX_UART_PutBuffer (&g_ETH1Drv, (char *) readip, 13) ; + + // ·¢ËÍÊý¾Ý + if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_ETH1_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 2000, RT_NULL)) // ÐèÒª·¢ËÍÊý¾Ý + { + for (int i = 0 ; i < g_ETH1Drv.rx_size; i++) + { + rt_kprintf ("%02X", g_ETH1Drv.rx_buffer[i]); + } + rt_kprintf ("\r\n"); + MX_UART_Clear (&g_ETH1Drv) ; + } + + rt_thread_mdelay (3000); + } + +} + + + + + +void ZS001ThreadStart (void) +{ + /* ´´½¨Ïß³Ì1£¬Ãû³ÆÊÇthread1£¬Èë¿ÚÊÇthread1_entry */ + rt_thread_init (&thread, "zs001_thread", + thread_entry, RT_NULL, + &thread_stack[0], + sizeof (thread_stack), + ZS001_THREAD_PRIORITY, ZS001_THREAD_TIMESLICE); + rt_thread_startup (&thread); + + return ; +} diff --git a/Board/network/zs001drv.h b/Board/network/zs001drv.h new file mode 100644 index 0000000..89c79bb --- /dev/null +++ b/Board/network/zs001drv.h @@ -0,0 +1,16 @@ +#ifndef _ZS001_DRV_H +#define _ZS001_DRV_H + + + +#define ZS001_READ_CMD 0x00 +#define ZS001_WRITE_CMD 0x01 + +//#define ZS001_CMD_READSTATE + + + + + + +#endif diff --git a/Board/usart-board.c b/Board/usart-board.c index 8afb6d0..fdeb129 100644 --- a/Board/usart-board.c +++ b/Board/usart-board.c @@ -57,8 +57,8 @@ void MX_UART_TickHandle (void) g_DebugDrv.rx_timer--; // 4851 - - + + if (g_U4851Drv.rx_timer == 2) // ͨ¹ýʼþ֪ͨµ½ÒµÎñapp { if (g_U4851Drv.rxdone != NULL) @@ -238,6 +238,7 @@ void MX_UART_Init (UartDrv_t *drv) { Error_Handler(); } + __HAL_UART_ENABLE_IT (&hlpuart2, UART_IT_RXNE); break; case G0_UART1 : // 4853 huart1.Instance = USART1; @@ -328,6 +329,7 @@ void MX_UART_Init (UartDrv_t *drv) { Error_Handler(); } + __HAL_UART_ENABLE_IT (&huart3, UART_IT_RXNE); break; case G0_UART4: // ETH1 huart4.Instance = USART4; @@ -383,6 +385,7 @@ void MX_UART_Init (UartDrv_t *drv) { Error_Handler(); } + __HAL_UART_ENABLE_IT (&huart6, UART_IT_RXNE); break; default: break; @@ -394,10 +397,21 @@ void MX_UART_Init (UartDrv_t *drv) void MX_UART_IRQHandle (void) { uint8_t ret; + if (USART3->ISR & (1 << 5)) // ´®¿Ú2 + { + ret = USART3->RDR; + if (g_U4852Drv.rx_buffer != NULL) + { + g_U4852Drv.rx_buffer[g_U4852Drv.rx_size++] = ret; + g_U4852Drv.rx_timer = 30; // 30ms + if (g_U4852Drv.rx_size > UART_UART3_BUFF_SIZE) + g_U4852Drv.rx_size = 0; + } + } if (USART2->ISR & (1 << 5)) // ´®¿Ú2 { ret = USART2->RDR; - if( g_DebugDrv.rx_buffer != NULL) + if (g_DebugDrv.rx_buffer != NULL) { g_DebugDrv.rx_buffer[g_DebugDrv.rx_size++] = ret; g_DebugDrv.rx_timer = 30; // 30ms @@ -408,7 +422,7 @@ void MX_UART_IRQHandle (void) if (USART4->ISR & (1 << 5)) { ret = USART4->RDR; - if( g_ETH1Drv.rx_buffer != NULL) + if (g_ETH1Drv.rx_buffer != NULL) { g_ETH1Drv.rx_buffer[g_ETH1Drv.rx_size++] = ret; g_ETH1Drv.rx_timer = 30; // 30ms @@ -419,7 +433,7 @@ void MX_UART_IRQHandle (void) if (USART5->ISR & (1 << 5)) { ret = USART5->RDR; - if( g_U4851Drv.rx_buffer != NULL) + if (g_U4851Drv.rx_buffer != NULL) { g_U4851Drv.rx_buffer[g_U4851Drv.rx_size++] = ret; g_U4851Drv.rx_timer = 30; // 30ms @@ -427,11 +441,22 @@ void MX_UART_IRQHandle (void) g_U4851Drv.rx_size = 0; } } - + if (USART6->ISR & (1 << 5)) + { + ret = USART6->RDR; + if (g_ViewDrv.rx_buffer != NULL) + { + g_ViewDrv.rx_buffer[g_ViewDrv.rx_size++] = ret; + g_ViewDrv.rx_timer = 30; // 30ms + if (g_ViewDrv.rx_size > UART_UART6_BUFF_SIZE) + g_ViewDrv.rx_size = 0; + } + } + if (LPUART1->ISR & (1 << 5)) { ret = LPUART1->RDR; - if( g_ETH2Drv.rx_buffer != NULL) + if (g_ETH2Drv.rx_buffer != NULL) { g_ETH2Drv.rx_buffer[g_ETH2Drv.rx_size++] = ret; g_ETH2Drv.rx_timer = 30; // 30ms @@ -439,6 +464,18 @@ void MX_UART_IRQHandle (void) g_ETH2Drv.rx_size = 0; } } + + if (LPUART2->ISR & (1 << 5)) + { + ret = LPUART2->RDR; + if (g_GSMDrv.rx_buffer != NULL) + { + g_GSMDrv.rx_buffer[g_GSMDrv.rx_size++] = ret; + g_GSMDrv.rx_timer = 30; // 30ms + if (g_GSMDrv.rx_size > UART_LPUART2_BUFF_SIZE) + g_GSMDrv.rx_size = 0; + } + } } diff --git a/Board/usart-board.h b/Board/usart-board.h index 40e33e8..a9a19e0 100644 --- a/Board/usart-board.h +++ b/Board/usart-board.h @@ -56,7 +56,7 @@ extern UartDrv_t g_LoRaDrv ; -// function +// function extern void MX_UART_TickHandle (void); diff --git a/Comm/modbusaddr.h b/Comm/modbusaddr.h index ea7d551..f95bad9 100644 --- a/Comm/modbusaddr.h +++ b/Comm/modbusaddr.h @@ -1,31 +1,42 @@ -#ifndef MODBUS_ADDR_H +#ifndef MODBUS_ADDR_H #define MODBUS_ADDR_H #include - -#define REG_GOPENH 0X0000 -#define REG_GOPENL 0X0001 - -#define REG_ALOADH 0X0002 -#define REG_ALOADL 0X0003 - -#define REG_BLOADH 0X0004 -#define REG_BLOADL 0X0005 - -#define REG_SOPEN 0X0007 -#define REG_SLOPT 0X0008 // Ö´ÐÐÕ¢ÃŶ¯×÷ +typedef struct reg_data_t +{ + uint16_t gopen; + uint16_t aload; + uint16_t bload; + uint16_t bl1; + uint16_t bl2; + uint16_t bl3; + uint16_t bl4; + uint16_t sopen; + uint16_t slopt; +} reg_data_t; +typedef enum reg_addr_t +{ + reg_gopen = 0X0000, // 2¸ö×Ö + reg_aload = 0X0001, + reg_bload = 0X0002, + reg_bl1 = 0X0003, + reg_bl2 = 0X0004, + reg_bl3 = 0X0005, + reg_bl4 = 0X0006, + reg_sopen = 0X0007, + reg_slopt = 0X0008, +} reg_addr_t; -#define REG_MAX 0X0009 + +extern reg_data_t reg_data; - - -#endif +#endif diff --git a/Comm/net-app.c b/Comm/net-app.c index b13f0c6..addeadd 100644 --- a/Comm/net-app.c +++ b/Comm/net-app.c @@ -278,11 +278,11 @@ void NetTask (void) log_d ("<<<<<<<<<<< #include "usart-board.h" +#include "mqtt-board.h" +#include "network.h" +#include "netdrv.h" +#include "proto.h" +#include "util.h" +#include "data.h" +#include "disdefine.h" +#include "jsonpacket.h" +#include "jsonunpack.h" +#include -ALIGN(RT_ALIGN_SIZE) + +ALIGN (RT_ALIGN_SIZE) static char thread_stack[4096]; static struct rt_thread netapp_thread; -static rt_event_t gnetEvents; -#define EVENT_COMM_TX (1U << 0) -#define EVENT_COMM_RX (1U << 1) // + +extern MqttDrv_t gMqttDrv; -// case ssKHYSet: -// { -// vv = value*10; -// dbg_printf ("MbusSetValue vv:%d\r\n",vv); -// sendcmd[type][4] = ((vv >> 8) & 0xff); -// sendcmd[type][5] = (vv & 0xff); -// vv = bsp_crc_calc16((uint8_t *)sendcmd[type],6); -// sendcmd[type][7] = ((vv >> 8) & 0xff); -// sendcmd[type][6] = (vv & 0xff); -// for(int i = 0;i < 8;i++) -// { -// dbg_printf("%02X ",sendcmd[type][i]); -// } -// dbg_printf("\r\n"); -// } +static rt_timer_t timer; -// {0x01, 0x03, 0x00, 0x00, 0x00, 0x06, 0xC5, 0xC8}, // բλ¼Æ¶ÁÈ¡¿ª¶È -// {0x01, 0x06, 0x00, 0x07, 0x00, 0x02, 0xE6, 0x69}, // բλ¼ÆÉèÖÿª¶È -// {0x01, 0x06, 0x00, 0x04, 0x01, 0x00, 0xC9, 0x9B}, // Æô¶¯Õ¢Î»¼Æ -// {0x01, 0x06, 0x00, 0x04, 0x00, 0x00, 0xC8, 0x0B}, // ֹͣբλ¼Æ -static enum { - netDrvInit = 0, // ³õʼ»¯ÍøÂçÇý¶¯ - netDrvJoin = 1, // µÈ´ýÍøÂç×¢²á³É¹¦ - netDrvSend = 2, // ·¢ËÍÊý¾Ý - netDrvRecv = 3, // ¶ÁÈ¡Êý¾Ý - netDrvIdle = 4, // ¶ÁÈ¡Êý¾Ý -}eDrvStatus; -static netWorkInterface_t interface; +static uint32_t g_net_5min_timer[SLUICE_COUTN] = {0}; +static uint32_t g_net_1min_timer[SLUICE_COUTN] = {0}; -static void net_send_frame(void) + +static void timerouter (void * parameter) { - rt_event_send(gnetEvents,EVENT_COMM_TX) ; -} -// ÍøÂçÁ´½Ó³É¹¦ -static void net_connected(void) -{ - -} - -static void thread_entry(void * argument) -{ - eDrvStatus = netDrvInit; - rt_kprintf("%s was start!\r\n",__FILE__); - gnetEvents = rt_event_create("gnetEvents", RT_IPC_FLAG_FIFO) ; - // ¶ÁÈ¡ÍøÂçÇý¶¯ÀàÐÍ - char * drv = ef_get_env ("net_drv"); // ¶ÁÈ¡ÍøÂçÀàÐÍ - if(strcmp("dtu",drv) == 0) // Çý¶¯³ÌÐòλDTUģʽ£¬¾ÍÊDz»Í¨¹ý±¾µØÅäÖã¬Ö±½Ó͸´« + TypeIndexMail_t mail; + for (int i = 0; i < SLUICE_COUTN; i++) { - DTUThreadStart(); - // ³õʼ»¯´®¿ÚÇý¶¯ -// interface.Init = NULL; -// interface.IsConnected = NULL; -// interface.IsIdle = NULL; -// interface.IsReady = NULL; -// interface.ReadData = NULL; -// interface.ReSubTopic = NULL; -// interface.WriteData = NULL; - + if (g_net_1min_timer[i] == 1) + { + g_net_1min_timer[i] = 60; + mail.Type = MAIL_COMM_HEART; + mail.index = i + 1; + rt_mb_send (gTCommMail, * ( (uint32_t *) &mail)); + } + if (g_net_5min_timer[i] == 1) + { + g_net_5min_timer[i] = 60 * 5; + mail.Type = MAIL_COMM_STAND; + mail.index = i + 1; + rt_mb_send (gTCommMail, * ( (uint32_t *) &mail)); + } + if (g_net_1min_timer[i] > 1) + g_net_1min_timer[i]--; + if (g_net_5min_timer[i] > 1) + g_net_5min_timer[i]--; } - // ×¢²áÍøÂçÇý¶¯ - // ×¢²áÍøÂçÇý¶¯ - while (1) - { - // ·¢ËÍÊý¾Ý - if( RT_EOK == rt_event_recv( gnetEvents, EVENT_COMM_TX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL )) - { - - } - if ( RT_EOK == rt_event_recv( gnetEvents, EVENT_COMM_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL )) - { - - } - rt_thread_delay(10); - } } -void NET_APPThreadStart(void ) + +const static char upinfo[][10] = {"heart", "regist", "stand", "sluice", "upack", "slack","readcfg"} ; + +static void thread_entry (void * argument) +{ + rt_kprintf ("%s was start!\r\n", __FILE__); + TypeIndexMail_t mail; + timer = rt_timer_create ("timer", timerouter, RT_NULL, 1000, RT_TIMER_FLAG_PERIODIC); + // ¶ÁÈ¡ÍøÂçÇý¶¯ÀàÐÍ + netdrv_init(); + MQTTThreadStart(); + char data[100] = {0}; + int tx_size = 0; +#ifndef USER_JSON_PACKET + char rxdata_decode[256]; + int rxdata_decode_size = 0; + uint32_t datak; +#endif + + // ÅжÏÕ¾µãÀàÐÍ + //site_type + char * p = ef_get_env ("site_type") ; + int site_type = cSiteType2Index(p); + rt_kprintf ("site_type:%d\r\n", site_type); + + //CommTMail_t mail; + // ×¢²áÍøÂçÇý¶¯ + // ×¢²áÍøÂçÇý¶¯ + while (1) + { + +INIT: + if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_COMM_RST, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL)) + { + rt_kprintf ("net work lost\r\n"); + mail.Type = MAIL_VIEW_NET_STE; + mail.index = DIS_STE_ERROR; + rt_mb_send (gViewMail, * ( (uint32_t*) &mail)); + rt_timer_stop (timer); + // ·¢ËÍÏûÏ¢¸ø + } + if (MQTT_Subscribed() != 1) // ÍøÂçÁ´½Ó²»³É¹¦ + { + rt_thread_mdelay (1000); + goto INIT; + } + // ¶©Ôijɹ¦ + if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_MQTT_SUB, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL)) + { + rt_kprintf ("netWork Sub Success\r\n"); + // ·¢ËÍ×¢²á±¨ + mail.Type = MAIL_COMM_REGIST; + mail.index = 1; + rt_mb_send (gTCommMail, * ( (uint32_t *) &mail)); + for (int i = 0; i < SLUICE_COUTN; i++) + { + rt_timer_start (timer); + g_net_1min_timer[i] = i * 10 + 5; + g_net_5min_timer[i] = i * 10 + 10; + mail.Type = MAIL_VIEW_NET_STE; + mail.index = DIS_STE_SUCCSEE; + rt_mb_send (gViewMail, * ( (uint32_t*) &mail)); + } + } + if (rt_mb_recv (gTCommMail, (rt_ubase_t *) &mail, RT_WAITING_NO) == RT_EOK) + { + rt_kprintf ("recv send mail: type:%s,index:%d\n", upinfo[mail.Type], mail.index); + if (g_ifupdate != 1) + { + switch (mail.Type) + { + case MAIL_COMM_HEART: +#ifdef USER_JSON_PACKET + gMqttDrv.tx_size = JsonHeartDatapacket ( (uint8_t *) gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; +#else + // ÐÄÌøÊý¾Ý + gMqttDrv.tx_size = PacketHeader (0x2F, data, 4, gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; + +#endif + MQTT_SendData () ; + break; + case MAIL_COMM_REGIST: // ×¢²á±¨ + +#ifdef USER_JSON_PACKET // ʹÓÃJson¸ñʽÊý¾Ý°ü + gMqttDrv.tx_size = JsonRegistDataPacket ((uint8_t *) gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; +#else + // ÐÄÌøÊý¾Ý + tx_size = PacketUpRegist (data); + gMqttDrv.tx_size = PacketHeader (0xE4, data, tx_size, gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; +#endif + MQTT_SendData () ; + break; + case MAIL_COMM_SLUICE: // Õ¢ÃÅ״̬×Ô±¨ + tx_size = PacketSluiceUp (mail.index - 1, data); + gMqttDrv.tx_size = PacketHeader (0x4E, data, tx_size, gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; + MQTT_SendData () ; + break; + case MAIL_COMM_STAND: // 5·ÖÖÓ±ê×¼°üÉϱ¨ + +#ifdef USER_JSON_PACKET // ʹÓÃJson¸ñʽÊý¾Ý°ü + // ÅжÏÕ¾µãÀàÐÍ + switch (site_type) + { + case SiteSluice: // Õ¢ÃÅÕ¾ + gMqttDrv.tx_size = Json5MinSluiceDataPacket ( (uint8_t *) gMqttDrv.txbuff); + break; + case SiteFlow: + case SiteSee: + gMqttDrv.tx_size = Json5MinFlowDataPacket ( (uint8_t *) gMqttDrv.txbuff); + break; + case SiteColl: + case SiteServer: + break; + } + + gMqttDrv.tx_index = mail.index; +#else + // ÐÄÌøÊý¾Ý + tx_size = PakcetTimerUp (mail.index - 1, data); + gMqttDrv.tx_size = PacketHeader (0x31, data, tx_size, gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; +#endif + + MQTT_SendData () ; + break; + case MAIL_COMM_SLACK: // ÌáÕ¢µÄÓ¦´ð + tx_size = PacketSluiceAck (data); + gMqttDrv.tx_size = PacketHeader (0x4E, data, tx_size, gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; + MQTT_SendData(); + break; + case MAIL_COMM_UPACK: // Éý¼¶µÄÓ¦´ð + +#ifdef USER_JSON_PACKET // ʹÓÃJson¸ñʽÊý¾Ý°ü + gMqttDrv.tx_size = JsonAckSuccPacket ((uint8_t *) gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; +#else + // ÐÄÌøÊý¾Ý + tx_size = PacketAnsAck (data); + gMqttDrv.tx_size = PacketHeader (0xE0, data, tx_size, gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; +#endif + + + MQTT_SendData(); + break; + case MAIL_COMM_READPARA: +#ifdef USER_JSON_PACKET // ʹÓÃJson¸ñʽÊý¾Ý°ü + gMqttDrv.tx_size = JsonConfigReadDataPacket ((uint8_t *) gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; +#else + // ÐÄÌøÊý¾Ý + tx_size = PacketUpRegist (data); + gMqttDrv.tx_size = PacketHeader (0xE4, data, tx_size, gMqttDrv.txbuff); + gMqttDrv.tx_index = mail.index; +#endif + MQTT_SendData(); + break; + default: + break; + } + } + + } + // ½ÓÊÜÊý¾Ý + if (RT_EOK == rt_event_recv (gTrigEvents, EVENT_TRIG_COMM_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL)) + { + +#ifdef USER_JSON_PACKET // ʹÓÃJson¸ñʽÊý¾Ý°ü + JsonUnPacket(gMqttDrv.rx_index - 1,gMqttDrv.rxbuff); // µÚn¸öͨµÀ¹ýÀ´µÄÊý¾Ý + // ½âÎöÊý¾Ý +#else + + rxdata_decode_size = hexstr_to_hexbyte (gMqttDrv.rxbuff, rxdata_decode, gMqttDrv.rx_size); + rt_kprintf ("<<<<<<<<<<<> 16) & 0x000000FF); tx_data[tx_size++] = 0;//SysInfo.baseAddr[3]; //(uint8_t) ( (SysInfo.Addr >> 8) & 0x000000FF); tx_data[tx_size++] = 0;//SysInfo.baseAddr[4]; //(uint8_t) (SysInfo.Addr & 0x000000FF); - return tx_size; + return tx_size; } // ´ò°ü »ù´¡²ÎÊý @@ -211,7 +211,7 @@ int Json651PacketBaseInfo (char *outBuffer, int length) // "NetDev", SysInfo.baseNetDev, // "StandTime", SysInfo.baseStandbyTime); // return k; -return 0; + return 0; } // ½Ó¿Ú²ÎÊýÉèÖà int Json651PacketInterfaceInfo (char *outBuffer, int length) @@ -251,7 +251,7 @@ int Json651PacketInterfaceInfo (char *outBuffer, int length) // "pwm3", SysInfo.PWMFunc[2], // "pwm4", SysInfo.PWMFunc[3]); // return k; -return 0; + return 0; } int Json651PacketSluiceInfo (char *outBuffer, int length) diff --git a/Comm/probusthread.c b/Comm/probusthread.c index a4112ff..6b093c8 100644 --- a/Comm/probusthread.c +++ b/Comm/probusthread.c @@ -11,152 +11,155 @@ #include "usart-board.h" #include "modbus-s.h" #include "modbusaddr.h" +#include "data.h" -ALIGN(RT_ALIGN_SIZE) +ALIGN (RT_ALIGN_SIZE) static char thread_stack[4096]; static struct rt_thread probus_thread; -uint16_t REG_DATA[REG_MAX] = {0x00}; + + +//uint16_t REG_DATA[REG_MAX] = {0x00}; -// ¼Ä´æÆ÷¶ÔÓ¦µÄÊý¾Ý +reg_data_t reg_data = +{ + .gopen = 56, + .aload = 0, +}; - -// case ssKHYSet: -// { -// vv = value*10; -// dbg_printf ("MbusSetValue vv:%d\r\n",vv); -// sendcmd[type][4] = ((vv >> 8) & 0xff); -// sendcmd[type][5] = (vv & 0xff); -// vv = bsp_crc_calc16((uint8_t *)sendcmd[type],6); -// sendcmd[type][7] = ((vv >> 8) & 0xff); -// sendcmd[type][6] = (vv & 0xff); -// for(int i = 0;i < 8;i++) -// { -// dbg_printf("%02X ",sendcmd[type][i]); -// } -// dbg_printf("\r\n"); -// } - -// {0x01, 0x03, 0x00, 0x00, 0x00, 0x06, 0xC5, 0xC8}, // բλ¼Æ¶ÁÈ¡¿ª¶È -// {0x01, 0x06, 0x00, 0x07, 0x00, 0x02, 0xE6, 0x69}, // բλ¼ÆÉèÖÿª¶È -// {0x01, 0x06, 0x00, 0x04, 0x01, 0x00, 0xC9, 0x9B}, // Æô¶¯Õ¢Î»¼Æ -// {0x01, 0x06, 0x00, 0x04, 0x00, 0x00, 0xC8, 0x0B}, // ֹͣբλ¼Æ - - static ModBusSlave_t modbus_slave; -static uint8_t modbus_rx_data[32]; +static uint8_t modbus_rx_data[256]; -static void eth2_data_rxdone(void) +static void eth2_data_rxdone (void) { - rt_event_send(gUartEvents,EVENT_UART_ETH2_RX); - //rt_kprintf("net_data_rxdone\r\n"); + rt_event_send (gUartEvents, EVENT_UART_ETH2_RX); + } -static void probus_handle(uint16_t addr,uint8_t * data) +static void probus_handle (reg_addr_t addr, uint8_t * data) { + uint32_t data32; + TypeIndexMail_t mail; switch (addr) { - case REG_SOPEN: // É趨բÃÅ¿ª¶È - break; - case REG_SLOPT: // Ö´ÐÐÕ¢ÃŶ¯×÷ - if (data[0] == 0x01) // Ö´ÐÐ - { - rt_event_send(gCtrlEvents,EVENT_CTRL_SET_OPEN); - rt_kprintf("probus_handle set open\r\n"); - } - else - { - - } - - break; - default: - break; + case reg_sopen: // É趨բÃÅ¿ª¶È + data32 = data[0]; + data32 = (data32 << 8) + data[1]; + SluiceData[0].sopen = data32 * 10; + break; + case reg_slopt: // Ö´ÐÐÕ¢ÃŶ¯×÷ + rt_kprintf ("reg_slopt\r\n"); + if (data[0] == 0x01) // Ö´ÐÐ + { + rt_kprintf ("reg_slopt\r\n"); + mail.Type = MAIL_SLUICE_OPT; + mail.index = 0; + rt_mb_send (gSluiceMail, * ( (uint32_t*) &mail)); + } + else + { + mail.Type = MAIL_SLUICE_STP; + mail.index = 0; + rt_mb_send (gSluiceMail, * ( (uint32_t*) &mail)); + rt_kprintf ("reg_stp\r\n"); + } + + break; + default: + break; } } -static void thread_entry(void * argument) +static void thread_entry (void * argument) { int k = 0; uint8_t txbuff[128] = {0}; int tx_size = 0; - rt_kprintf("%s was start!\r\n",__FILE__); + rt_kprintf ("%s was start!\r\n", __FILE__); g_ETH2Drv.rxdone = eth2_data_rxdone; g_ETH2Drv.BaudRate = 115200; - MX_UART_Init(&g_ETH2Drv); - - ModbusSlaveInit(&modbus_slave,0x01,modbus_rx_data,REG_DATA,REG_MAX); + MX_UART_Init (&g_ETH2Drv); + + ModbusSlaveInit (&modbus_slave, 0x01, modbus_rx_data, (uint16_t *) ®_data, sizeof (reg_data_t) / 2); + MX_UART_Clear (&g_ETH2Drv); // ×¢²áÍøÂçÇý¶¯ // ×¢²áÍøÂçÇý¶¯ - while (1) - { - if( RT_EOK == rt_event_recv( gUartEvents, EVENT_UART_ETH2_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL )) + while (1) + { + // ´ÓÆäËûÊý¾ÝÇøÓò¸üе½¼Ä´æÆ÷ + reg_data.gopen = SluiceData[0].gopen * 10; + //reg_data.aload = SluiceData[0].lload; + //reg_data.bload = SluiceData[0].rload; + if (RT_EOK == rt_event_recv (gUartEvents, EVENT_UART_ETH2_RX, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL)) { -// rt_kprintf("<<<<<<<<<<<<<<<<<<< 4) + { + k = ModbusSlaveHandle (&modbus_slave, (uint8_t *) g_ETH2Drv.rx_buffer, g_ETH2Drv.rx_size); + //k = 2; + rt_kprintf ("k:%d\r\n", k); + if (k == 0) { + switch (modbus_slave.func) + { case 0x03: - tx_size = ModbusSlavePacket(&modbus_slave,txbuff); + tx_size = ModbusSlavePacket (&modbus_slave, txbuff); // Ö±½Ó·µ»Øµ±Ç°¼Ä´æÆ÷ÖеÄÊý¾Ý break; case 0x06: //´¦Àí¶ÔÓ¦µÄʼþ - probus_handle(modbus_slave.Addr,modbus_slave.data); + probus_handle (modbus_slave.Addr, modbus_slave.data); // Êý¾Ý´ò°ü»Ø¸´ - tx_size = ModbusSlavePacket(&modbus_slave,txbuff); + tx_size = ModbusSlavePacket (&modbus_slave, txbuff); break; default: tx_size = 0; break; + } + } + else + { + tx_size = 0; + } + if (tx_size > 0) + { + //rt_kprintf("tx_size :%d\r\n",tx_size); + MX_UART_PutBuffer (&g_ETH2Drv, (char *) txbuff, tx_size); } } - else - { - tx_size = 0; - } - if (tx_size > 0) - { - MX_UART_PutBuffer(&g_ETH2Drv,(char *)txbuff,tx_size); - } - - MX_UART_Clear(&g_ETH2Drv); + + MX_UART_Clear (&g_ETH2Drv); } - rt_thread_delay(10); - } + rt_thread_mdelay (100); + } } -void PROBUS_APPThreadStart(void ) +void PROBUS_APPThreadStart (void) { /* ´´½¨Ïß³Ì1£¬Ãû³ÆÊÇthread1£¬Èë¿ÚÊÇthread1_entry*/ - rt_thread_init(&probus_thread, "probus_thread", - thread_entry, RT_NULL, - &thread_stack[0], - sizeof(thread_stack), - PROBUS_APP_THREAD_PRIORITY, PROBUS_APP_THREAD_TIMESLICE); - rt_thread_startup(&probus_thread); + rt_thread_init (&probus_thread, "probus_thread", + thread_entry, RT_NULL, + &thread_stack[0], + sizeof (thread_stack), + PROBUS_APP_THREAD_PRIORITY, PROBUS_APP_THREAD_TIMESLICE); + rt_thread_startup (&probus_thread); - return ; + return ; } diff --git a/Core/Inc/main.h b/Core/Inc/main.h index 89fed4f..13acbd2 100644 --- a/Core/Inc/main.h +++ b/Core/Inc/main.h @@ -133,6 +133,8 @@ void Error_Handler(void); #define DI6_GPIO_Port GPIOD #define PWM_CH1_Pin GPIO_PIN_4 #define PWM_CH1_GPIO_Port GPIOB +#define LOCK_Pin GPIO_PIN_5 +#define LOCK_GPIO_Port GPIOB #define RELAY1_Pin GPIO_PIN_0 #define RELAY1_GPIO_Port GPIOE #define RELAY2_Pin GPIO_PIN_1 diff --git a/Core/Inc/tim.h b/Core/Inc/tim.h index a6d04e5..2fbfbbb 100644 --- a/Core/Inc/tim.h +++ b/Core/Inc/tim.h @@ -58,7 +58,7 @@ void MX_TIM15_Init(void); void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim); /* USER CODE BEGIN Prototypes */ - +void MX_TIM_SetDuty (int index, uint32_t duty); /* USER CODE END Prototypes */ #ifdef __cplusplus diff --git a/Core/Src/adc.c b/Core/Src/adc.c index 1cfec41..323ec1f 100644 --- a/Core/Src/adc.c +++ b/Core/Src/adc.c @@ -31,81 +31,81 @@ ADC_HandleTypeDef hadc1; DMA_HandleTypeDef hdma_adc1; /* ADC1 init function */ -void MX_ADC1_Init(void) +void MX_ADC1_Init (void) { - /* USER CODE BEGIN ADC1_Init 0 */ + /* USER CODE BEGIN ADC1_Init 0 */ - /* USER CODE END ADC1_Init 0 */ + /* USER CODE END ADC1_Init 0 */ - ADC_ChannelConfTypeDef sConfig = {0}; + ADC_ChannelConfTypeDef sConfig = {0}; - /* USER CODE BEGIN ADC1_Init 1 */ + /* USER CODE BEGIN ADC1_Init 1 */ - /* USER CODE END ADC1_Init 1 */ + /* USER CODE END ADC1_Init 1 */ - /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion) - */ - hadc1.Instance = ADC1; - hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2; - hadc1.Init.Resolution = ADC_RESOLUTION_12B; - hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT; - hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE; - hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV; - hadc1.Init.LowPowerAutoWait = DISABLE; - hadc1.Init.LowPowerAutoPowerOff = DISABLE; - hadc1.Init.ContinuousConvMode = ENABLE; - hadc1.Init.NbrOfConversion = 4; - hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START; - hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; - hadc1.Init.DMAContinuousRequests = ENABLE; - hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED; - hadc1.Init.SamplingTimeCommon1 = ADC_SAMPLETIME_160CYCLES_5; - hadc1.Init.SamplingTimeCommon2 = ADC_SAMPLETIME_160CYCLES_5; - hadc1.Init.OversamplingMode = DISABLE; - hadc1.Init.TriggerFrequencyMode = ADC_TRIGGER_FREQ_HIGH; - if (HAL_ADC_Init(&hadc1) != HAL_OK) - { - Error_Handler(); - } + /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion) + */ + hadc1.Instance = ADC1; + hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2; + hadc1.Init.Resolution = ADC_RESOLUTION_12B; + hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT; + hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE; + hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV; + hadc1.Init.LowPowerAutoWait = DISABLE; + hadc1.Init.LowPowerAutoPowerOff = DISABLE; + hadc1.Init.ContinuousConvMode = ENABLE; + hadc1.Init.NbrOfConversion = 4; + hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START; + hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; + hadc1.Init.DMAContinuousRequests = ENABLE; + hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED; + hadc1.Init.SamplingTimeCommon1 = ADC_SAMPLETIME_160CYCLES_5; + hadc1.Init.SamplingTimeCommon2 = ADC_SAMPLETIME_160CYCLES_5; + hadc1.Init.OversamplingMode = DISABLE; + hadc1.Init.TriggerFrequencyMode = ADC_TRIGGER_FREQ_HIGH; + if (HAL_ADC_Init (&hadc1) != HAL_OK) + { + Error_Handler(); + } - /** Configure Regular Channel - */ - sConfig.Channel = ADC_CHANNEL_0; - sConfig.Rank = ADC_REGULAR_RANK_1; - sConfig.SamplingTime = ADC_SAMPLINGTIME_COMMON_1; - if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) - { - Error_Handler(); - } + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_0; + sConfig.Rank = ADC_REGULAR_RANK_1; + sConfig.SamplingTime = ADC_SAMPLINGTIME_COMMON_1; + if (HAL_ADC_ConfigChannel (&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } - /** Configure Regular Channel - */ - sConfig.Channel = ADC_CHANNEL_1; - sConfig.Rank = ADC_REGULAR_RANK_2; - if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) - { - Error_Handler(); - } + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_1; + sConfig.Rank = ADC_REGULAR_RANK_2; + if (HAL_ADC_ConfigChannel (&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } - /** Configure Regular Channel - */ - sConfig.Channel = ADC_CHANNEL_7; - sConfig.Rank = ADC_REGULAR_RANK_3; - if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) - { - Error_Handler(); - } + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_7; + sConfig.Rank = ADC_REGULAR_RANK_3; + if (HAL_ADC_ConfigChannel (&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } - /** Configure Regular Channel - */ - sConfig.Channel = ADC_CHANNEL_TEMPSENSOR; - sConfig.Rank = ADC_REGULAR_RANK_4; - if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN ADC1_Init 2 */ + /** Configure Regular Channel + */ + sConfig.Channel = ADC_CHANNEL_TEMPSENSOR; + sConfig.Rank = ADC_REGULAR_RANK_4; + if (HAL_ADC_ConfigChannel (&hadc1, &sConfig) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN ADC1_Init 2 */ //HAL_ADCEx_Calibration_Start if (HAL_ADCEx_Calibration_Start (&hadc1) != HAL_OK) @@ -123,88 +123,94 @@ void MX_ADC1_Init(void) } - /* USER CODE END ADC1_Init 2 */ + /* USER CODE END ADC1_Init 2 */ } -void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle) +void HAL_ADC_MspInit (ADC_HandleTypeDef* adcHandle) { - GPIO_InitTypeDef GPIO_InitStruct = {0}; - if(adcHandle->Instance==ADC1) - { - /* USER CODE BEGIN ADC1_MspInit 0 */ + GPIO_InitTypeDef GPIO_InitStruct = {0}; + if (adcHandle->Instance == ADC1) + { + /* USER CODE BEGIN ADC1_MspInit 0 */ - /* USER CODE END ADC1_MspInit 0 */ - /* ADC1 clock enable */ - __HAL_RCC_ADC_CLK_ENABLE(); + /* USER CODE END ADC1_MspInit 0 */ + /* ADC1 clock enable */ + __HAL_RCC_ADC_CLK_ENABLE(); - __HAL_RCC_GPIOA_CLK_ENABLE(); - /**ADC1 GPIO Configuration - PA0 ------> ADC1_IN0 - PA1 ------> ADC1_IN1 - PA7 ------> ADC1_IN7 - */ - GPIO_InitStruct.Pin = ADC1_Pin|ADC2_Pin|ADCPW_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = GPIO_NOPULL; - HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + __HAL_RCC_GPIOA_CLK_ENABLE(); + /**ADC1 GPIO Configuration + PA0 ------> ADC1_IN0 + PA1 ------> ADC1_IN1 + PA7 ------> ADC1_IN7 + */ + GPIO_InitStruct.Pin = ADC1_Pin | ADC2_Pin | ADCPW_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init (GPIOA, &GPIO_InitStruct); - /* ADC1 DMA Init */ - /* ADC1 Init */ - hdma_adc1.Instance = DMA1_Channel1; - hdma_adc1.Init.Request = DMA_REQUEST_ADC1; - hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY; - hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE; - hdma_adc1.Init.MemInc = DMA_MINC_ENABLE; - hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; - hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; - hdma_adc1.Init.Mode = DMA_CIRCULAR; - hdma_adc1.Init.Priority = DMA_PRIORITY_LOW; - if (HAL_DMA_Init(&hdma_adc1) != HAL_OK) - { - Error_Handler(); - } + /* ADC1 DMA Init */ + /* ADC1 Init */ + hdma_adc1.Instance = DMA1_Channel1; + hdma_adc1.Init.Request = DMA_REQUEST_ADC1; + hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY; + hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE; + hdma_adc1.Init.MemInc = DMA_MINC_ENABLE; + hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; + hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; + hdma_adc1.Init.Mode = DMA_CIRCULAR; + hdma_adc1.Init.Priority = DMA_PRIORITY_LOW; + if (HAL_DMA_Init (&hdma_adc1) != HAL_OK) + { + Error_Handler(); + } - __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1); + __HAL_LINKDMA (adcHandle, DMA_Handle, hdma_adc1); - /* USER CODE BEGIN ADC1_MspInit 1 */ + /* USER CODE BEGIN ADC1_MspInit 1 */ - /* USER CODE END ADC1_MspInit 1 */ - } + /* USER CODE END ADC1_MspInit 1 */ + } } -void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle) +void HAL_ADC_MspDeInit (ADC_HandleTypeDef* adcHandle) { - if(adcHandle->Instance==ADC1) - { - /* USER CODE BEGIN ADC1_MspDeInit 0 */ + if (adcHandle->Instance == ADC1) + { + /* USER CODE BEGIN ADC1_MspDeInit 0 */ - /* USER CODE END ADC1_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_ADC_CLK_DISABLE(); + /* USER CODE END ADC1_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_ADC_CLK_DISABLE(); - /**ADC1 GPIO Configuration - PA0 ------> ADC1_IN0 - PA1 ------> ADC1_IN1 - PA7 ------> ADC1_IN7 - */ - HAL_GPIO_DeInit(GPIOA, ADC1_Pin|ADC2_Pin|ADCPW_Pin); + /**ADC1 GPIO Configuration + PA0 ------> ADC1_IN0 + PA1 ------> ADC1_IN1 + PA7 ------> ADC1_IN7 + */ + HAL_GPIO_DeInit (GPIOA, ADC1_Pin | ADC2_Pin | ADCPW_Pin); - /* ADC1 DMA DeInit */ - HAL_DMA_DeInit(adcHandle->DMA_Handle); - /* USER CODE BEGIN ADC1_MspDeInit 1 */ + /* ADC1 DMA DeInit */ + HAL_DMA_DeInit (adcHandle->DMA_Handle); + /* USER CODE BEGIN ADC1_MspDeInit 1 */ - /* USER CODE END ADC1_MspDeInit 1 */ - } + /* USER CODE END ADC1_MspDeInit 1 */ + } } /* USER CODE BEGIN 1 */ uint32_t MX_READ_ADC_VALUE (int channel) { - return aADCxConvertedData[channel]; + uint32_t p = 0; + for (int i = 0; i < 100; i++) + { + p = p + aADCxConvertedData[channel]; + } + p = p / 100; + return p;//aADCxConvertedData[channel]; } diff --git a/Core/Src/crc.c b/Core/Src/crc.c index 838107e..9c14f04 100644 --- a/Core/Src/crc.c +++ b/Core/Src/crc.c @@ -27,68 +27,68 @@ CRC_HandleTypeDef hcrc; /* CRC init function */ -void MX_CRC_Init(void) +void MX_CRC_Init (void) { - /* USER CODE BEGIN CRC_Init 0 */ + /* USER CODE BEGIN CRC_Init 0 */ - /* USER CODE END CRC_Init 0 */ + /* USER CODE END CRC_Init 0 */ - /* USER CODE BEGIN CRC_Init 1 */ - /* USER CODE END CRC_Init 1 */ - hcrc.Instance = CRC; - hcrc.Init.DefaultPolynomialUse = DEFAULT_POLYNOMIAL_DISABLE; - hcrc.Init.DefaultInitValueUse = DEFAULT_INIT_VALUE_DISABLE; - hcrc.Init.GeneratingPolynomial = 0x8005; - hcrc.Init.CRCLength = CRC_POLYLENGTH_16B; - hcrc.Init.InitValue = 0xFFFF; - hcrc.Init.InputDataInversionMode = CRC_INPUTDATA_INVERSION_BYTE; - hcrc.Init.OutputDataInversionMode = CRC_OUTPUTDATA_INVERSION_ENABLE; - hcrc.InputDataFormat = CRC_INPUTDATA_FORMAT_BYTES; - if (HAL_CRC_Init(&hcrc) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN CRC_Init 2 */ + /* USER CODE BEGIN CRC_Init 1 */ + /* USER CODE END CRC_Init 1 */ + hcrc.Instance = CRC; + hcrc.Init.DefaultPolynomialUse = DEFAULT_POLYNOMIAL_DISABLE; + hcrc.Init.DefaultInitValueUse = DEFAULT_INIT_VALUE_DISABLE; + hcrc.Init.GeneratingPolynomial = 0x8005; + hcrc.Init.CRCLength = CRC_POLYLENGTH_16B; + hcrc.Init.InitValue = 0xFFFF; + hcrc.Init.InputDataInversionMode = CRC_INPUTDATA_INVERSION_BYTE; + hcrc.Init.OutputDataInversionMode = CRC_OUTPUTDATA_INVERSION_ENABLE; + hcrc.InputDataFormat = CRC_INPUTDATA_FORMAT_BYTES; + if (HAL_CRC_Init (&hcrc) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN CRC_Init 2 */ - /* USER CODE END CRC_Init 2 */ + /* USER CODE END CRC_Init 2 */ } -void HAL_CRC_MspInit(CRC_HandleTypeDef* crcHandle) +void HAL_CRC_MspInit (CRC_HandleTypeDef* crcHandle) { - if(crcHandle->Instance==CRC) - { - /* USER CODE BEGIN CRC_MspInit 0 */ + if (crcHandle->Instance == CRC) + { + /* USER CODE BEGIN CRC_MspInit 0 */ - /* USER CODE END CRC_MspInit 0 */ - /* CRC clock enable */ - __HAL_RCC_CRC_CLK_ENABLE(); - /* USER CODE BEGIN CRC_MspInit 1 */ + /* USER CODE END CRC_MspInit 0 */ + /* CRC clock enable */ + __HAL_RCC_CRC_CLK_ENABLE(); + /* USER CODE BEGIN CRC_MspInit 1 */ - /* USER CODE END CRC_MspInit 1 */ - } + /* USER CODE END CRC_MspInit 1 */ + } } -void HAL_CRC_MspDeInit(CRC_HandleTypeDef* crcHandle) +void HAL_CRC_MspDeInit (CRC_HandleTypeDef* crcHandle) { - if(crcHandle->Instance==CRC) - { - /* USER CODE BEGIN CRC_MspDeInit 0 */ + if (crcHandle->Instance == CRC) + { + /* USER CODE BEGIN CRC_MspDeInit 0 */ - /* USER CODE END CRC_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_CRC_CLK_DISABLE(); - /* USER CODE BEGIN CRC_MspDeInit 1 */ + /* USER CODE END CRC_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_CRC_CLK_DISABLE(); + /* USER CODE BEGIN CRC_MspDeInit 1 */ - /* USER CODE END CRC_MspDeInit 1 */ - } + /* USER CODE END CRC_MspDeInit 1 */ + } } /* USER CODE BEGIN 1 */ -uint16_t MX_CRC_CALC(uint8_t * data,int length) +uint16_t MX_CRC_CALC (uint8_t * data, int length) { uint16_t ret; ret = (uint16_t) HAL_CRC_Calculate (&hcrc, (uint32_t *) data, length); diff --git a/Core/Src/dma.c b/Core/Src/dma.c index 468cfac..34f4794 100644 --- a/Core/Src/dma.c +++ b/Core/Src/dma.c @@ -36,22 +36,22 @@ /** * Enable DMA controller clock */ -void MX_DMA_Init(void) +void MX_DMA_Init (void) { - /* DMA controller clock enable */ - __HAL_RCC_DMA1_CLK_ENABLE(); + /* DMA controller clock enable */ + __HAL_RCC_DMA1_CLK_ENABLE(); - /* DMA interrupt init */ - /* DMA1_Channel1_IRQn interrupt configuration */ - HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn); - /* DMA1_Channel2_3_IRQn interrupt configuration */ - HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn); - /* DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn interrupt configuration */ - HAL_NVIC_SetPriority(DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn); + /* DMA interrupt init */ + /* DMA1_Channel1_IRQn interrupt configuration */ + HAL_NVIC_SetPriority (DMA1_Channel1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (DMA1_Channel1_IRQn); + /* DMA1_Channel2_3_IRQn interrupt configuration */ + HAL_NVIC_SetPriority (DMA1_Channel2_3_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (DMA1_Channel2_3_IRQn); + /* DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn interrupt configuration */ + HAL_NVIC_SetPriority (DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn); } diff --git a/Core/Src/gpio.c b/Core/Src/gpio.c index 3c0b82e..80c8510 100644 --- a/Core/Src/gpio.c +++ b/Core/Src/gpio.c @@ -20,6 +20,7 @@ /* Includes ------------------------------------------------------------------*/ #include "gpio.h" +#include /* USER CODE BEGIN 0 */ @@ -40,95 +41,111 @@ * EXTI PA5 ------> COMP_DAC12_group */ -void MX_GPIO_Init(void) +void MX_GPIO_Init (void) { - GPIO_InitTypeDef GPIO_InitStruct = {0}; + GPIO_InitTypeDef GPIO_InitStruct = {0}; - /* GPIO Ports Clock Enable */ - __HAL_RCC_GPIOB_CLK_ENABLE(); - __HAL_RCC_GPIOC_CLK_ENABLE(); - __HAL_RCC_GPIOE_CLK_ENABLE(); - __HAL_RCC_GPIOF_CLK_ENABLE(); - __HAL_RCC_GPIOA_CLK_ENABLE(); - __HAL_RCC_GPIOD_CLK_ENABLE(); + /* GPIO Ports Clock Enable */ + __HAL_RCC_GPIOB_CLK_ENABLE(); + __HAL_RCC_GPIOC_CLK_ENABLE(); + __HAL_RCC_GPIOE_CLK_ENABLE(); + __HAL_RCC_GPIOF_CLK_ENABLE(); + __HAL_RCC_GPIOA_CLK_ENABLE(); + __HAL_RCC_GPIOD_CLK_ENABLE(); - /*Configure GPIO pin Output Level */ - HAL_GPIO_WritePin(ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_RESET); + /*Configure GPIO pin Output Level */ + HAL_GPIO_WritePin (ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_RESET); - /*Configure GPIO pin Output Level */ - HAL_GPIO_WritePin(GPIOA, ETH_PW_Pin|GSM_PW_Pin, GPIO_PIN_RESET); + /*Configure GPIO pin Output Level */ + HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin | GSM_PW_Pin, GPIO_PIN_RESET); - /*Configure GPIO pin Output Level */ - HAL_GPIO_WritePin(GPIOB, U485_RT_Pin|LORA_TX_Pin|LORA_RX_Pin|SPI2_NSS_Pin, GPIO_PIN_RESET); + /*Configure GPIO pin Output Level */ + HAL_GPIO_WritePin (GPIOB, U485_RT_Pin | LORA_TX_Pin | LORA_RX_Pin | SPI2_NSS_Pin + | LOCK_Pin, GPIO_PIN_RESET); - /*Configure GPIO pin Output Level */ - HAL_GPIO_WritePin(GPIOE, LORA_M1_Pin|RELAY1_Pin|RELAY2_Pin|S4851_RT_Pin - |S4852_RT_Pin, GPIO_PIN_RESET); + /*Configure GPIO pin Output Level */ + HAL_GPIO_WritePin (GPIOE, LORA_M1_Pin | RELAY1_Pin | RELAY2_Pin | S4851_RT_Pin + | S4852_RT_Pin, GPIO_PIN_RESET); - /*Configure GPIO pin Output Level */ - HAL_GPIO_WritePin(GSM_RST_GPIO_Port, GSM_RST_Pin, GPIO_PIN_RESET); + /*Configure GPIO pin Output Level */ + HAL_GPIO_WritePin (GSM_RST_GPIO_Port, GSM_RST_Pin, GPIO_PIN_RESET); - /*Configure GPIO pin : PtPin */ - GPIO_InitStruct.Pin = ETH_RST_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - HAL_GPIO_Init(ETH_RST_GPIO_Port, &GPIO_InitStruct); + /*Configure GPIO pin : PtPin */ + GPIO_InitStruct.Pin = ETH_RST_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init (ETH_RST_GPIO_Port, &GPIO_InitStruct); - /*Configure GPIO pin : PtPin */ - GPIO_InitStruct.Pin = ETH_STA_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_INPUT; - GPIO_InitStruct.Pull = GPIO_NOPULL; - HAL_GPIO_Init(ETH_STA_GPIO_Port, &GPIO_InitStruct); + /*Configure GPIO pin : PtPin */ + GPIO_InitStruct.Pin = ETH_STA_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_INPUT; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init (ETH_STA_GPIO_Port, &GPIO_InitStruct); - /*Configure GPIO pins : PAPin PAPin */ - GPIO_InitStruct.Pin = ETH_PW_Pin|GSM_PW_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + /*Configure GPIO pins : PAPin PAPin */ + GPIO_InitStruct.Pin = ETH_PW_Pin | GSM_PW_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init (GPIOA, &GPIO_InitStruct); - /*Configure GPIO pin : PtPin */ - GPIO_InitStruct.Pin = DAC2_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; - GPIO_InitStruct.Pull = GPIO_NOPULL; - HAL_GPIO_Init(DAC2_GPIO_Port, &GPIO_InitStruct); + /*Configure GPIO pin : PtPin */ + GPIO_InitStruct.Pin = DAC2_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init (DAC2_GPIO_Port, &GPIO_InitStruct); - /*Configure GPIO pins : PBPin PBPin PBPin PBPin */ - GPIO_InitStruct.Pin = U485_RT_Pin|LORA_TX_Pin|LORA_RX_Pin|SPI2_NSS_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + /*Configure GPIO pins : PBPin PBPin PBPin PBPin + PBPin */ + GPIO_InitStruct.Pin = U485_RT_Pin | LORA_TX_Pin | LORA_RX_Pin | SPI2_NSS_Pin + | LOCK_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init (GPIOB, &GPIO_InitStruct); - /*Configure GPIO pins : PEPin PEPin PEPin PEPin - PEPin */ - GPIO_InitStruct.Pin = LORA_M1_Pin|RELAY1_Pin|RELAY2_Pin|S4851_RT_Pin - |S4852_RT_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - HAL_GPIO_Init(GPIOE, &GPIO_InitStruct); + /*Configure GPIO pins : PEPin PEPin PEPin PEPin + PEPin */ + GPIO_InitStruct.Pin = LORA_M1_Pin | RELAY1_Pin | RELAY2_Pin | S4851_RT_Pin + | S4852_RT_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init (GPIOE, &GPIO_InitStruct); - /*Configure GPIO pin : PtPin */ - GPIO_InitStruct.Pin = LORA_DI0_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_INPUT; - GPIO_InitStruct.Pull = GPIO_NOPULL; - HAL_GPIO_Init(LORA_DI0_GPIO_Port, &GPIO_InitStruct); + /*Configure GPIO pin : PtPin */ + GPIO_InitStruct.Pin = LORA_DI0_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_INPUT; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init (LORA_DI0_GPIO_Port, &GPIO_InitStruct); - /*Configure GPIO pin : PtPin */ - GPIO_InitStruct.Pin = GSM_RST_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - HAL_GPIO_Init(GSM_RST_GPIO_Port, &GPIO_InitStruct); + /*Configure GPIO pin : PtPin */ + GPIO_InitStruct.Pin = GSM_RST_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init (GSM_RST_GPIO_Port, &GPIO_InitStruct); - /*Configure GPIO pins : PDPin PDPin PDPin PDPin */ - GPIO_InitStruct.Pin = DI3_Pin|DI4_Pin|DI5_Pin|DI6_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_INPUT; - GPIO_InitStruct.Pull = GPIO_NOPULL; - HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); + /*Configure GPIO pins : PDPin PDPin PDPin PDPin */ + GPIO_InitStruct.Pin = DI3_Pin | DI4_Pin | DI5_Pin | DI6_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_INPUT; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init (GPIOD, &GPIO_InitStruct); + +// HAL_GPIO_WritePin (S4851_RT_GPIO_Port, S4851_RT_Pin, GPIO_PIN_SET); + + //HAL_GPIO_WritePin(GPIOB, LOCK_Pin, GPIO_PIN_SET); + +// HAL_GPIO_WritePin(ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET); +// rt_kprintf("+++++++++++++++++++++\r\n"); +//// /*Configure GPIO pin Output Level */ +//HAL_GPIO_WritePin(GPIOA, ETH_PW_Pin|GSM_PW_Pin, GPIO_PIN_SET); +HAL_GPIO_WritePin (GPIOA, ETH_PW_Pin | GSM_PW_Pin, GPIO_PIN_RESET); + +// + /*Configure GPIO pin Output Level */ } diff --git a/Core/Src/iwdg.c b/Core/Src/iwdg.c index 53a1d1d..30375d2 100644 --- a/Core/Src/iwdg.c +++ b/Core/Src/iwdg.c @@ -27,35 +27,35 @@ IWDG_HandleTypeDef hiwdg; /* IWDG init function */ -void MX_IWDG_Init(void) +void MX_IWDG_Init (void) { - /* USER CODE BEGIN IWDG_Init 0 */ + /* USER CODE BEGIN IWDG_Init 0 */ - /* USER CODE END IWDG_Init 0 */ + /* USER CODE END IWDG_Init 0 */ - /* USER CODE BEGIN IWDG_Init 1 */ + /* USER CODE BEGIN IWDG_Init 1 */ - /* USER CODE END IWDG_Init 1 */ - hiwdg.Instance = IWDG; - hiwdg.Init.Prescaler = IWDG_PRESCALER_4; - hiwdg.Init.Window = 4095; - hiwdg.Init.Reload = 4095; - if (HAL_IWDG_Init(&hiwdg) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN IWDG_Init 2 */ + /* USER CODE END IWDG_Init 1 */ + hiwdg.Instance = IWDG; + hiwdg.Init.Prescaler = IWDG_PRESCALER_4; + hiwdg.Init.Window = 4095; + hiwdg.Init.Reload = 4095; + if (HAL_IWDG_Init (&hiwdg) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN IWDG_Init 2 */ - /* USER CODE END IWDG_Init 2 */ + /* USER CODE END IWDG_Init 2 */ } /* USER CODE BEGIN 1 */ -void MX_IWDG_Reload(void) +void MX_IWDG_Reload (void) { - HAL_IWDG_Refresh(&hiwdg); + HAL_IWDG_Refresh (&hiwdg); } /* USER CODE END 1 */ diff --git a/Core/Src/main.c b/Core/Src/main.c index d2f5ec9..681c346 100644 --- a/Core/Src/main.c +++ b/Core/Src/main.c @@ -55,7 +55,7 @@ /* USER CODE END PV */ /* Private function prototypes -----------------------------------------------*/ -void SystemClock_Config(void); +void SystemClock_Config (void); /* USER CODE BEGIN PFP */ /* USER CODE END PFP */ @@ -69,109 +69,109 @@ void SystemClock_Config(void); * @brief The application entry point. * @retval int */ -int main(void) +int main (void) { - /* USER CODE BEGIN 1 */ + /* USER CODE BEGIN 1 */ - /* USER CODE END 1 */ + /* USER CODE END 1 */ - /* MCU Configuration--------------------------------------------------------*/ + /* MCU Configuration--------------------------------------------------------*/ - /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ - HAL_Init(); + /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ + HAL_Init(); - /* USER CODE BEGIN Init */ + /* USER CODE BEGIN Init */ - /* USER CODE END Init */ + /* USER CODE END Init */ - /* Configure the system clock */ - SystemClock_Config(); + /* Configure the system clock */ + SystemClock_Config(); - /* USER CODE BEGIN SysInit */ + /* USER CODE BEGIN SysInit */ - /* USER CODE END SysInit */ + /* USER CODE END SysInit */ - /* Initialize all configured peripherals */ - MX_GPIO_Init(); - MX_DMA_Init(); - MX_ADC1_Init(); - MX_CRC_Init(); - MX_IWDG_Init(); - MX_LPUART1_UART_Init(); - MX_LPUART2_UART_Init(); - MX_USART1_UART_Init(); - MX_USART2_UART_Init(); - MX_USART3_UART_Init(); - MX_USART4_UART_Init(); - MX_USART5_UART_Init(); - MX_USART6_UART_Init(); - MX_RTC_Init(); - MX_TIM1_Init(); - MX_TIM3_Init(); - MX_WWDG_Init(); - MX_TIM6_Init(); - MX_TIM7_Init(); - MX_TIM14_Init(); - MX_SPI2_Init(); - MX_TIM15_Init(); - /* USER CODE BEGIN 2 */ + /* Initialize all configured peripherals */ + MX_GPIO_Init(); + MX_DMA_Init(); + MX_ADC1_Init(); + MX_CRC_Init(); + MX_IWDG_Init(); + MX_LPUART1_UART_Init(); + MX_LPUART2_UART_Init(); + MX_USART1_UART_Init(); + MX_USART2_UART_Init(); + MX_USART3_UART_Init(); + MX_USART4_UART_Init(); + MX_USART5_UART_Init(); + MX_USART6_UART_Init(); + MX_RTC_Init(); + MX_TIM1_Init(); + MX_TIM3_Init(); + MX_WWDG_Init(); + MX_TIM6_Init(); + MX_TIM7_Init(); + MX_TIM14_Init(); + MX_SPI2_Init(); + MX_TIM15_Init(); + /* USER CODE BEGIN 2 */ // ³õʼÍê³É ͨ¹ýÏÖ³É - /* USER CODE END 2 */ + /* USER CODE END 2 */ - /* Infinite loop */ - /* USER CODE BEGIN WHILE */ + /* Infinite loop */ + /* USER CODE BEGIN WHILE */ while (1) { - /* USER CODE END WHILE */ + /* USER CODE END WHILE */ - /* USER CODE BEGIN 3 */ + /* USER CODE BEGIN 3 */ } - /* USER CODE END 3 */ + /* USER CODE END 3 */ } /** * @brief System Clock Configuration * @retval None */ -void SystemClock_Config(void) +void SystemClock_Config (void) { - RCC_OscInitTypeDef RCC_OscInitStruct = {0}; - RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; + RCC_OscInitTypeDef RCC_OscInitStruct = {0}; + RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; - /** Configure the main internal regulator output voltage - */ - HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1); + /** Configure the main internal regulator output voltage + */ + HAL_PWREx_ControlVoltageScaling (PWR_REGULATOR_VOLTAGE_SCALE1); - /** Initializes the RCC Oscillators according to the specified parameters - * in the RCC_OscInitTypeDef structure. - */ - RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI|RCC_OSCILLATORTYPE_HSE; - RCC_OscInitStruct.HSEState = RCC_HSE_ON; - RCC_OscInitStruct.LSIState = RCC_LSI_ON; - RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; - RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE; - RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV1; - RCC_OscInitStruct.PLL.PLLN = 16; - RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2; - RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2; - RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2; - if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) - { - Error_Handler(); - } + /** Initializes the RCC Oscillators according to the specified parameters + * in the RCC_OscInitTypeDef structure. + */ + RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_HSE; + RCC_OscInitStruct.HSEState = RCC_HSE_ON; + RCC_OscInitStruct.LSIState = RCC_LSI_ON; + RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; + RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE; + RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV1; + RCC_OscInitStruct.PLL.PLLN = 16; + RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2; + RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2; + RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2; + if (HAL_RCC_OscConfig (&RCC_OscInitStruct) != HAL_OK) + { + Error_Handler(); + } - /** Initializes the CPU, AHB and APB buses clocks - */ - RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK - |RCC_CLOCKTYPE_PCLK1; - RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; - RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; - RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; + /** Initializes the CPU, AHB and APB buses clocks + */ + RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK + | RCC_CLOCKTYPE_PCLK1; + RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; + RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; + RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; - if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK) - { - Error_Handler(); - } + if (HAL_RCC_ClockConfig (&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK) + { + Error_Handler(); + } } /* USER CODE BEGIN 4 */ @@ -186,32 +186,33 @@ void SystemClock_Config(void) * @param htim : TIM handle * @retval None */ -void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) +void HAL_TIM_PeriodElapsedCallback (TIM_HandleTypeDef *htim) { - /* USER CODE BEGIN Callback 0 */ + /* USER CODE BEGIN Callback 0 */ - /* USER CODE END Callback 0 */ - if (htim->Instance == TIM2) { - HAL_IncTick(); - } - /* USER CODE BEGIN Callback 1 */ + /* USER CODE END Callback 0 */ + if (htim->Instance == TIM2) + { + HAL_IncTick(); + } + /* USER CODE BEGIN Callback 1 */ - /* USER CODE END Callback 1 */ + /* USER CODE END Callback 1 */ } /** * @brief This function is executed in case of error occurrence. * @retval None */ -void Error_Handler(void) +void Error_Handler (void) { - /* USER CODE BEGIN Error_Handler_Debug */ + /* USER CODE BEGIN Error_Handler_Debug */ /* User can add his own implementation to report the HAL error return state */ __disable_irq(); while (1) { } - /* USER CODE END Error_Handler_Debug */ + /* USER CODE END Error_Handler_Debug */ } #ifdef USE_FULL_ASSERT @@ -222,11 +223,11 @@ void Error_Handler(void) * @param line: assert_param error line source number * @retval None */ -void assert_failed(uint8_t *file, uint32_t line) +void assert_failed (uint8_t *file, uint32_t line) { - /* USER CODE BEGIN 6 */ + /* USER CODE BEGIN 6 */ /* User can add his own implementation to report the file name and line number, ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */ - /* USER CODE END 6 */ + /* USER CODE END 6 */ } #endif /* USE_FULL_ASSERT */ diff --git a/Core/Src/rtc.c b/Core/Src/rtc.c index 1aa8859..bc5aeb8 100644 --- a/Core/Src/rtc.c +++ b/Core/Src/rtc.c @@ -27,81 +27,81 @@ RTC_HandleTypeDef hrtc; /* RTC init function */ -void MX_RTC_Init(void) +void MX_RTC_Init (void) { - /* USER CODE BEGIN RTC_Init 0 */ + /* USER CODE BEGIN RTC_Init 0 */ - /* USER CODE END RTC_Init 0 */ + /* USER CODE END RTC_Init 0 */ - /* USER CODE BEGIN RTC_Init 1 */ + /* USER CODE BEGIN RTC_Init 1 */ - /* USER CODE END RTC_Init 1 */ + /* USER CODE END RTC_Init 1 */ - /** Initialize RTC Only - */ - hrtc.Instance = RTC; - hrtc.Init.HourFormat = RTC_HOURFORMAT_24; - hrtc.Init.AsynchPrediv = 127; - hrtc.Init.SynchPrediv = 255; - hrtc.Init.OutPut = RTC_OUTPUT_DISABLE; - hrtc.Init.OutPutRemap = RTC_OUTPUT_REMAP_NONE; - hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH; - hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN; - hrtc.Init.OutPutPullUp = RTC_OUTPUT_PULLUP_NONE; - if (HAL_RTC_Init(&hrtc) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN RTC_Init 2 */ + /** Initialize RTC Only + */ + hrtc.Instance = RTC; + hrtc.Init.HourFormat = RTC_HOURFORMAT_24; + hrtc.Init.AsynchPrediv = 127; + hrtc.Init.SynchPrediv = 255; + hrtc.Init.OutPut = RTC_OUTPUT_DISABLE; + hrtc.Init.OutPutRemap = RTC_OUTPUT_REMAP_NONE; + hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH; + hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN; + hrtc.Init.OutPutPullUp = RTC_OUTPUT_PULLUP_NONE; + if (HAL_RTC_Init (&hrtc) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN RTC_Init 2 */ - /* USER CODE END RTC_Init 2 */ + /* USER CODE END RTC_Init 2 */ } -void HAL_RTC_MspInit(RTC_HandleTypeDef* rtcHandle) +void HAL_RTC_MspInit (RTC_HandleTypeDef* rtcHandle) { - RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; - if(rtcHandle->Instance==RTC) - { - /* USER CODE BEGIN RTC_MspInit 0 */ + RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; + if (rtcHandle->Instance == RTC) + { + /* USER CODE BEGIN RTC_MspInit 0 */ - /* USER CODE END RTC_MspInit 0 */ + /* USER CODE END RTC_MspInit 0 */ - /** Initializes the peripherals clocks - */ - PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC; - PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSI; - if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) - { - Error_Handler(); - } + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC; + PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSI; + if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } - /* RTC clock enable */ - __HAL_RCC_RTC_ENABLE(); - __HAL_RCC_RTCAPB_CLK_ENABLE(); - /* USER CODE BEGIN RTC_MspInit 1 */ + /* RTC clock enable */ + __HAL_RCC_RTC_ENABLE(); + __HAL_RCC_RTCAPB_CLK_ENABLE(); + /* USER CODE BEGIN RTC_MspInit 1 */ - /* USER CODE END RTC_MspInit 1 */ - } + /* USER CODE END RTC_MspInit 1 */ + } } -void HAL_RTC_MspDeInit(RTC_HandleTypeDef* rtcHandle) +void HAL_RTC_MspDeInit (RTC_HandleTypeDef* rtcHandle) { - if(rtcHandle->Instance==RTC) - { - /* USER CODE BEGIN RTC_MspDeInit 0 */ + if (rtcHandle->Instance == RTC) + { + /* USER CODE BEGIN RTC_MspDeInit 0 */ - /* USER CODE END RTC_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_RTC_DISABLE(); - __HAL_RCC_RTCAPB_CLK_DISABLE(); - /* USER CODE BEGIN RTC_MspDeInit 1 */ + /* USER CODE END RTC_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_RTC_DISABLE(); + __HAL_RCC_RTCAPB_CLK_DISABLE(); + /* USER CODE BEGIN RTC_MspDeInit 1 */ - /* USER CODE END RTC_MspDeInit 1 */ - } + /* USER CODE END RTC_MspDeInit 1 */ + } } /* USER CODE BEGIN 1 */ diff --git a/Core/Src/spi.c b/Core/Src/spi.c index bae75dc..8710b40 100644 --- a/Core/Src/spi.c +++ b/Core/Src/spi.c @@ -27,48 +27,48 @@ SPI_HandleTypeDef hspi2; /* SPI2 init function */ -void MX_SPI2_Init(void) +void MX_SPI2_Init (void) { - /* USER CODE BEGIN SPI2_Init 0 */ + /* USER CODE BEGIN SPI2_Init 0 */ - /* USER CODE END SPI2_Init 0 */ + /* USER CODE END SPI2_Init 0 */ - /* USER CODE BEGIN SPI2_Init 1 */ + /* USER CODE BEGIN SPI2_Init 1 */ - /* USER CODE END SPI2_Init 1 */ - hspi2.Instance = SPI2; - hspi2.Init.Mode = SPI_MODE_MASTER; - hspi2.Init.Direction = SPI_DIRECTION_2LINES; - hspi2.Init.DataSize = SPI_DATASIZE_8BIT; - hspi2.Init.CLKPolarity = SPI_POLARITY_LOW; - hspi2.Init.CLKPhase = SPI_PHASE_1EDGE; - hspi2.Init.NSS = SPI_NSS_SOFT; - hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; - hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB; - hspi2.Init.TIMode = SPI_TIMODE_DISABLE; - hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; - hspi2.Init.CRCPolynomial = 7; - hspi2.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE; - hspi2.Init.NSSPMode = SPI_NSS_PULSE_ENABLE; - if (HAL_SPI_Init(&hspi2) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN SPI2_Init 2 */ + /* USER CODE END SPI2_Init 1 */ + hspi2.Instance = SPI2; + hspi2.Init.Mode = SPI_MODE_MASTER; + hspi2.Init.Direction = SPI_DIRECTION_2LINES; + hspi2.Init.DataSize = SPI_DATASIZE_8BIT; + hspi2.Init.CLKPolarity = SPI_POLARITY_LOW; + hspi2.Init.CLKPhase = SPI_PHASE_1EDGE; + hspi2.Init.NSS = SPI_NSS_SOFT; + hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; + hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB; + hspi2.Init.TIMode = SPI_TIMODE_DISABLE; + hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; + hspi2.Init.CRCPolynomial = 7; + hspi2.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE; + hspi2.Init.NSSPMode = SPI_NSS_PULSE_ENABLE; + if (HAL_SPI_Init (&hspi2) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN SPI2_Init 2 */ __HAL_SPI_ENABLE (&hspi2); - /* USER CODE END SPI2_Init 2 */ + /* USER CODE END SPI2_Init 2 */ } -void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle) +void HAL_SPI_MspInit (SPI_HandleTypeDef* spiHandle) { - GPIO_InitTypeDef GPIO_InitStruct = {0}; - if(spiHandle->Instance==SPI2) - { - /* USER CODE BEGIN SPI2_MspInit 0 */ + GPIO_InitTypeDef GPIO_InitStruct = {0}; + if (spiHandle->Instance == SPI2) + { + /* USER CODE BEGIN SPI2_MspInit 0 */ //#define SPI2_NSS_Pin GPIO_PIN_12 //#define SPI2_NSS_GPIO_Port GPIOB @@ -78,57 +78,57 @@ void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle) GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; //GPIO_InitStruct.Alternate = GPIO_AF0_SPI2; HAL_GPIO_Init (SPI2_NSS_GPIO_Port, &GPIO_InitStruct); - /* USER CODE END SPI2_MspInit 0 */ - /* SPI2 clock enable */ - __HAL_RCC_SPI2_CLK_ENABLE(); + /* USER CODE END SPI2_MspInit 0 */ + /* SPI2 clock enable */ + __HAL_RCC_SPI2_CLK_ENABLE(); - __HAL_RCC_GPIOB_CLK_ENABLE(); - /**SPI2 GPIO Configuration - PB13 ------> SPI2_SCK - PB14 ------> SPI2_MISO - PB15 ------> SPI2_MOSI - */ - GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF0_SPI2; - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + __HAL_RCC_GPIOB_CLK_ENABLE(); + /**SPI2 GPIO Configuration + PB13 ------> SPI2_SCK + PB14 ------> SPI2_MISO + PB15 ------> SPI2_MOSI + */ + GPIO_InitStruct.Pin = GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF0_SPI2; + HAL_GPIO_Init (GPIOB, &GPIO_InitStruct); - /* SPI2 interrupt Init */ - HAL_NVIC_SetPriority(SPI2_3_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(SPI2_3_IRQn); - /* USER CODE BEGIN SPI2_MspInit 1 */ + /* SPI2 interrupt Init */ + HAL_NVIC_SetPriority (SPI2_3_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (SPI2_3_IRQn); + /* USER CODE BEGIN SPI2_MspInit 1 */ - /* USER CODE END SPI2_MspInit 1 */ - } + /* USER CODE END SPI2_MspInit 1 */ + } } -void HAL_SPI_MspDeInit(SPI_HandleTypeDef* spiHandle) +void HAL_SPI_MspDeInit (SPI_HandleTypeDef* spiHandle) { - if(spiHandle->Instance==SPI2) - { - /* USER CODE BEGIN SPI2_MspDeInit 0 */ + if (spiHandle->Instance == SPI2) + { + /* USER CODE BEGIN SPI2_MspDeInit 0 */ - /* USER CODE END SPI2_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_SPI2_CLK_DISABLE(); + /* USER CODE END SPI2_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_SPI2_CLK_DISABLE(); - /**SPI2 GPIO Configuration - PB13 ------> SPI2_SCK - PB14 ------> SPI2_MISO - PB15 ------> SPI2_MOSI - */ - HAL_GPIO_DeInit(GPIOB, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15); + /**SPI2 GPIO Configuration + PB13 ------> SPI2_SCK + PB14 ------> SPI2_MISO + PB15 ------> SPI2_MOSI + */ + HAL_GPIO_DeInit (GPIOB, GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15); - /* SPI2 interrupt Deinit */ - HAL_NVIC_DisableIRQ(SPI2_3_IRQn); - /* USER CODE BEGIN SPI2_MspDeInit 1 */ + /* SPI2 interrupt Deinit */ + HAL_NVIC_DisableIRQ (SPI2_3_IRQn); + /* USER CODE BEGIN SPI2_MspDeInit 1 */ - /* USER CODE END SPI2_MspDeInit 1 */ - } + /* USER CODE END SPI2_MspDeInit 1 */ + } } /* USER CODE BEGIN 1 */ diff --git a/Core/Src/stm32g0xx_hal_msp.c b/Core/Src/stm32g0xx_hal_msp.c index a6b375a..268d7b2 100644 --- a/Core/Src/stm32g0xx_hal_msp.c +++ b/Core/Src/stm32g0xx_hal_msp.c @@ -60,24 +60,24 @@ /** * Initializes the Global MSP. */ -void HAL_MspInit(void) +void HAL_MspInit (void) { - /* USER CODE BEGIN MspInit 0 */ + /* USER CODE BEGIN MspInit 0 */ - /* USER CODE END MspInit 0 */ + /* USER CODE END MspInit 0 */ - __HAL_RCC_SYSCFG_CLK_ENABLE(); - __HAL_RCC_PWR_CLK_ENABLE(); + __HAL_RCC_SYSCFG_CLK_ENABLE(); + __HAL_RCC_PWR_CLK_ENABLE(); - /* System interrupt init*/ + /* System interrupt init*/ - /** Disable the internal Pull-Up in Dead Battery pins of UCPD peripheral - */ - HAL_SYSCFG_StrobeDBattpinsConfig(SYSCFG_CFGR1_UCPD1_STROBE | SYSCFG_CFGR1_UCPD2_STROBE); + /** Disable the internal Pull-Up in Dead Battery pins of UCPD peripheral + */ + HAL_SYSCFG_StrobeDBattpinsConfig (SYSCFG_CFGR1_UCPD1_STROBE | SYSCFG_CFGR1_UCPD2_STROBE); - /* USER CODE BEGIN MspInit 1 */ + /* USER CODE BEGIN MspInit 1 */ - /* USER CODE END MspInit 1 */ + /* USER CODE END MspInit 1 */ } /* USER CODE BEGIN 1 */ diff --git a/Core/Src/stm32g0xx_hal_timebase_tim.c b/Core/Src/stm32g0xx_hal_timebase_tim.c index 8ace86c..0fde8b2 100644 --- a/Core/Src/stm32g0xx_hal_timebase_tim.c +++ b/Core/Src/stm32g0xx_hal_timebase_tim.c @@ -38,76 +38,76 @@ TIM_HandleTypeDef htim2; * @param TickPriority: Tick interrupt priority. * @retval HAL status */ -HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority) +HAL_StatusTypeDef HAL_InitTick (uint32_t TickPriority) { - RCC_ClkInitTypeDef clkconfig; - uint32_t uwTimclock, uwAPB1Prescaler; + RCC_ClkInitTypeDef clkconfig; + uint32_t uwTimclock, uwAPB1Prescaler; - uint32_t uwPrescalerValue; - uint32_t pFLatency; - HAL_StatusTypeDef status = HAL_OK; + uint32_t uwPrescalerValue; + uint32_t pFLatency; + HAL_StatusTypeDef status = HAL_OK; - /* Enable TIM2 clock */ - __HAL_RCC_TIM2_CLK_ENABLE(); + /* Enable TIM2 clock */ + __HAL_RCC_TIM2_CLK_ENABLE(); - /* Get clock configuration */ - HAL_RCC_GetClockConfig(&clkconfig, &pFLatency); + /* Get clock configuration */ + HAL_RCC_GetClockConfig (&clkconfig, &pFLatency); - /* Get APB1 prescaler */ - uwAPB1Prescaler = clkconfig.APB1CLKDivider; - /* Compute TIM2 clock */ - if (uwAPB1Prescaler == RCC_HCLK_DIV1) - { - uwTimclock = HAL_RCC_GetPCLK1Freq(); - } - else - { - uwTimclock = 2UL * HAL_RCC_GetPCLK1Freq(); - } + /* Get APB1 prescaler */ + uwAPB1Prescaler = clkconfig.APB1CLKDivider; + /* Compute TIM2 clock */ + if (uwAPB1Prescaler == RCC_HCLK_DIV1) + { + uwTimclock = HAL_RCC_GetPCLK1Freq(); + } + else + { + uwTimclock = 2UL * HAL_RCC_GetPCLK1Freq(); + } - /* Compute the prescaler value to have TIM2 counter clock equal to 1MHz */ - uwPrescalerValue = (uint32_t) ((uwTimclock / 1000000U) - 1U); + /* Compute the prescaler value to have TIM2 counter clock equal to 1MHz */ + uwPrescalerValue = (uint32_t) ( (uwTimclock / 1000000U) - 1U); - /* Initialize TIM2 */ - htim2.Instance = TIM2; + /* Initialize TIM2 */ + htim2.Instance = TIM2; - /* Initialize TIMx peripheral as follow: - + Period = [(TIM2CLK/1000) - 1]. to have a (1/1000) s time base. - + Prescaler = (uwTimclock/1000000 - 1) to have a 1MHz counter clock. - + ClockDivision = 0 - + Counter direction = Up - */ - htim2.Init.Period = (1000000U / 1000U) - 1U; - htim2.Init.Prescaler = uwPrescalerValue; - htim2.Init.ClockDivision = 0; - htim2.Init.CounterMode = TIM_COUNTERMODE_UP; - htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; + /* Initialize TIMx peripheral as follow: + + Period = [(TIM2CLK/1000) - 1]. to have a (1/1000) s time base. + + Prescaler = (uwTimclock/1000000 - 1) to have a 1MHz counter clock. + + ClockDivision = 0 + + Counter direction = Up + */ + htim2.Init.Period = (1000000U / 1000U) - 1U; + htim2.Init.Prescaler = uwPrescalerValue; + htim2.Init.ClockDivision = 0; + htim2.Init.CounterMode = TIM_COUNTERMODE_UP; + htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; - status = HAL_TIM_Base_Init(&htim2); - if (status == HAL_OK) - { - /* Start the TIM time Base generation in interrupt mode */ - status = HAL_TIM_Base_Start_IT(&htim2); - if (status == HAL_OK) - { - /* Enable the TIM2 global Interrupt */ - HAL_NVIC_EnableIRQ(TIM2_IRQn); - /* Configure the SysTick IRQ priority */ - if (TickPriority < (1UL << __NVIC_PRIO_BITS)) - { - /* Configure the TIM IRQ priority */ - HAL_NVIC_SetPriority(TIM2_IRQn, TickPriority, 0U); - uwTickPrio = TickPriority; - } - else - { - status = HAL_ERROR; - } - } - } + status = HAL_TIM_Base_Init (&htim2); + if (status == HAL_OK) + { + /* Start the TIM time Base generation in interrupt mode */ + status = HAL_TIM_Base_Start_IT (&htim2); + if (status == HAL_OK) + { + /* Enable the TIM2 global Interrupt */ + HAL_NVIC_EnableIRQ (TIM2_IRQn); + /* Configure the SysTick IRQ priority */ + if (TickPriority < (1UL << __NVIC_PRIO_BITS)) + { + /* Configure the TIM IRQ priority */ + HAL_NVIC_SetPriority (TIM2_IRQn, TickPriority, 0U); + uwTickPrio = TickPriority; + } + else + { + status = HAL_ERROR; + } + } + } - /* Return function status */ - return status; + /* Return function status */ + return status; } /** @@ -116,10 +116,10 @@ HAL_StatusTypeDef HAL_InitTick(uint32_t TickPriority) * @param None * @retval None */ -void HAL_SuspendTick(void) +void HAL_SuspendTick (void) { - /* Disable TIM2 update Interrupt */ - __HAL_TIM_DISABLE_IT(&htim2, TIM_IT_UPDATE); + /* Disable TIM2 update Interrupt */ + __HAL_TIM_DISABLE_IT (&htim2, TIM_IT_UPDATE); } /** @@ -128,9 +128,9 @@ void HAL_SuspendTick(void) * @param None * @retval None */ -void HAL_ResumeTick(void) +void HAL_ResumeTick (void) { - /* Enable TIM2 Update interrupt */ - __HAL_TIM_ENABLE_IT(&htim2, TIM_IT_UPDATE); + /* Enable TIM2 Update interrupt */ + __HAL_TIM_ENABLE_IT (&htim2, TIM_IT_UPDATE); } diff --git a/Core/Src/stm32g0xx_it.c b/Core/Src/stm32g0xx_it.c index ac1de06..33793d1 100644 --- a/Core/Src/stm32g0xx_it.c +++ b/Core/Src/stm32g0xx_it.c @@ -75,7 +75,7 @@ extern TIM_HandleTypeDef htim2; /* USER CODE BEGIN EV */ extern void MX_UART_IRQHandle (void); extern void MX_UART_TickHandle (void); -//extern void main_Systick (void); +extern void main_Systick (void); /* USER CODE END EV */ /******************************************************************************/ @@ -84,16 +84,16 @@ extern void MX_UART_TickHandle (void); /** * @brief This function handles Non maskable interrupt. */ -void NMI_Handler(void) +void NMI_Handler (void) { - /* USER CODE BEGIN NonMaskableInt_IRQn 0 */ + /* USER CODE BEGIN NonMaskableInt_IRQn 0 */ - /* USER CODE END NonMaskableInt_IRQn 0 */ - /* USER CODE BEGIN NonMaskableInt_IRQn 1 */ + /* USER CODE END NonMaskableInt_IRQn 0 */ + /* USER CODE BEGIN NonMaskableInt_IRQn 1 */ while (1) { } - /* USER CODE END NonMaskableInt_IRQn 1 */ + /* USER CODE END NonMaskableInt_IRQn 1 */ } /******************************************************************************/ @@ -106,153 +106,155 @@ void NMI_Handler(void) /** * @brief This function handles DMA1 channel 1 interrupt. */ -void DMA1_Channel1_IRQHandler(void) +void DMA1_Channel1_IRQHandler (void) { - /* USER CODE BEGIN DMA1_Channel1_IRQn 0 */ + /* USER CODE BEGIN DMA1_Channel1_IRQn 0 */ - /* USER CODE END DMA1_Channel1_IRQn 0 */ - HAL_DMA_IRQHandler(&hdma_adc1); - /* USER CODE BEGIN DMA1_Channel1_IRQn 1 */ + /* USER CODE END DMA1_Channel1_IRQn 0 */ + HAL_DMA_IRQHandler (&hdma_adc1); + /* USER CODE BEGIN DMA1_Channel1_IRQn 1 */ - /* USER CODE END DMA1_Channel1_IRQn 1 */ + /* USER CODE END DMA1_Channel1_IRQn 1 */ } /** * @brief This function handles DMA1 channel 2 and channel 3 interrupts. */ -void DMA1_Channel2_3_IRQHandler(void) +void DMA1_Channel2_3_IRQHandler (void) { - /* USER CODE BEGIN DMA1_Channel2_3_IRQn 0 */ + /* USER CODE BEGIN DMA1_Channel2_3_IRQn 0 */ - /* USER CODE END DMA1_Channel2_3_IRQn 0 */ - HAL_DMA_IRQHandler(&hdma_lpuart1_rx); - /* USER CODE BEGIN DMA1_Channel2_3_IRQn 1 */ + /* USER CODE END DMA1_Channel2_3_IRQn 0 */ + HAL_DMA_IRQHandler (&hdma_lpuart1_rx); + /* USER CODE BEGIN DMA1_Channel2_3_IRQn 1 */ - /* USER CODE END DMA1_Channel2_3_IRQn 1 */ + /* USER CODE END DMA1_Channel2_3_IRQn 1 */ } /** * @brief This function handles DMA1 Ch4 to Ch7, DMA2 Ch1 to Ch5 and DMAMUX1 Overrun Interrupts. */ -void DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQHandler(void) +void DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQHandler (void) { - /* USER CODE BEGIN DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn 0 */ + /* USER CODE BEGIN DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn 0 */ - /* USER CODE END DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn 0 */ - // Handle DMAMUX - // Handle DMA1_Channel1 - HAL_DMAEx_MUX_IRQHandler(&hdma_adc1); - /* USER CODE BEGIN DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn 1 */ + /* USER CODE END DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn 0 */ + // Handle DMAMUX + // Handle DMA1_Channel1 + HAL_DMAEx_MUX_IRQHandler (&hdma_adc1); + /* USER CODE BEGIN DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn 1 */ - /* USER CODE END DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn 1 */ + /* USER CODE END DMA1_Ch4_7_DMA2_Ch1_5_DMAMUX1_OVR_IRQn 1 */ } /** * @brief This function handles TIM2 global interrupt. */ -void TIM2_IRQHandler(void) +void TIM2_IRQHandler (void) { - /* USER CODE BEGIN TIM2_IRQn 0 */ + /* USER CODE BEGIN TIM2_IRQn 0 */ MX_UART_TickHandle(); - //main_Systick(); + main_Systick(); + #ifdef USE_APP_SLUICE MX_IWDG_Reload(); - MX_WWDG_Relad(); - /* USER CODE END TIM2_IRQn 0 */ - HAL_TIM_IRQHandler(&htim2); - /* USER CODE BEGIN TIM2_IRQn 1 */ + //MX_WWDG_Relad(); + #endif + /* USER CODE END TIM2_IRQn 0 */ + HAL_TIM_IRQHandler (&htim2); + /* USER CODE BEGIN TIM2_IRQn 1 */ - /* USER CODE END TIM2_IRQn 1 */ + /* USER CODE END TIM2_IRQn 1 */ } /** * @brief This function handles TIM7 and LPTIM2 global Interrupt. */ -void TIM7_LPTIM2_IRQHandler(void) +void TIM7_LPTIM2_IRQHandler (void) { - /* USER CODE BEGIN TIM7_LPTIM2_IRQn 0 */ + /* USER CODE BEGIN TIM7_LPTIM2_IRQn 0 */ - /* USER CODE END TIM7_LPTIM2_IRQn 0 */ - HAL_TIM_IRQHandler(&htim7); - /* USER CODE BEGIN TIM7_LPTIM2_IRQn 1 */ + /* USER CODE END TIM7_LPTIM2_IRQn 0 */ + HAL_TIM_IRQHandler (&htim7); + /* USER CODE BEGIN TIM7_LPTIM2_IRQn 1 */ - /* USER CODE END TIM7_LPTIM2_IRQn 1 */ + /* USER CODE END TIM7_LPTIM2_IRQn 1 */ } /** * @brief This function handles TIM14 global interrupt. */ -void TIM14_IRQHandler(void) +void TIM14_IRQHandler (void) { - /* USER CODE BEGIN TIM14_IRQn 0 */ + /* USER CODE BEGIN TIM14_IRQn 0 */ - /* USER CODE END TIM14_IRQn 0 */ - HAL_TIM_IRQHandler(&htim14); - /* USER CODE BEGIN TIM14_IRQn 1 */ + /* USER CODE END TIM14_IRQn 0 */ + HAL_TIM_IRQHandler (&htim14); + /* USER CODE BEGIN TIM14_IRQn 1 */ - /* USER CODE END TIM14_IRQn 1 */ + /* USER CODE END TIM14_IRQn 1 */ } /** * @brief This function handles SPI2/I2S2, SPI3/I2S3 Interrupt. */ -void SPI2_3_IRQHandler(void) +void SPI2_3_IRQHandler (void) { - /* USER CODE BEGIN SPI2_3_IRQn 0 */ + /* USER CODE BEGIN SPI2_3_IRQn 0 */ - /* USER CODE END SPI2_3_IRQn 0 */ - HAL_SPI_IRQHandler(&hspi2); - /* USER CODE BEGIN SPI2_3_IRQn 1 */ + /* USER CODE END SPI2_3_IRQn 0 */ + HAL_SPI_IRQHandler (&hspi2); + /* USER CODE BEGIN SPI2_3_IRQn 1 */ - /* USER CODE END SPI2_3_IRQn 1 */ + /* USER CODE END SPI2_3_IRQn 1 */ } /** * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25. */ -void USART1_IRQHandler(void) +void USART1_IRQHandler (void) { - /* USER CODE BEGIN USART1_IRQn 0 */ + /* USER CODE BEGIN USART1_IRQn 0 */ - /* USER CODE END USART1_IRQn 0 */ - HAL_UART_IRQHandler(&huart1); - /* USER CODE BEGIN USART1_IRQn 1 */ + /* USER CODE END USART1_IRQn 0 */ + HAL_UART_IRQHandler (&huart1); + /* USER CODE BEGIN USART1_IRQn 1 */ - /* USER CODE END USART1_IRQn 1 */ + /* USER CODE END USART1_IRQn 1 */ } /** * @brief This function handles USART2 + LPUART2 Interrupt. */ -void USART2_LPUART2_IRQHandler(void) +void USART2_LPUART2_IRQHandler (void) { - /* USER CODE BEGIN USART2_LPUART2_IRQn 0 */ + /* USER CODE BEGIN USART2_LPUART2_IRQn 0 */ MX_UART_IRQHandle(); - /* USER CODE END USART2_LPUART2_IRQn 0 */ - HAL_UART_IRQHandler(&huart2); - HAL_UART_IRQHandler(&hlpuart2); - /* USER CODE BEGIN USART2_LPUART2_IRQn 1 */ + /* USER CODE END USART2_LPUART2_IRQn 0 */ + HAL_UART_IRQHandler (&huart2); + HAL_UART_IRQHandler (&hlpuart2); + /* USER CODE BEGIN USART2_LPUART2_IRQn 1 */ - /* USER CODE END USART2_LPUART2_IRQn 1 */ + /* USER CODE END USART2_LPUART2_IRQn 1 */ } /** * @brief This function handles USART3, USART4, USART5, USART6, LPUART1 globlal Interrupts (combined with EXTI 28). */ -void USART3_4_5_6_LPUART1_IRQHandler(void) +void USART3_4_5_6_LPUART1_IRQHandler (void) { - /* USER CODE BEGIN USART3_4_5_6_LPUART1_IRQn 0 */ + /* USER CODE BEGIN USART3_4_5_6_LPUART1_IRQn 0 */ MX_UART_IRQHandle(); - /* USER CODE END USART3_4_5_6_LPUART1_IRQn 0 */ - HAL_UART_IRQHandler(&huart3); - HAL_UART_IRQHandler(&huart4); - HAL_UART_IRQHandler(&huart5); - HAL_UART_IRQHandler(&huart6); - HAL_UART_IRQHandler(&hlpuart1); - /* USER CODE BEGIN USART3_4_5_6_LPUART1_IRQn 1 */ + /* USER CODE END USART3_4_5_6_LPUART1_IRQn 0 */ + HAL_UART_IRQHandler (&huart3); + HAL_UART_IRQHandler (&huart4); + HAL_UART_IRQHandler (&huart5); + HAL_UART_IRQHandler (&huart6); + HAL_UART_IRQHandler (&hlpuart1); + /* USER CODE BEGIN USART3_4_5_6_LPUART1_IRQn 1 */ - /* USER CODE END USART3_4_5_6_LPUART1_IRQn 1 */ + /* USER CODE END USART3_4_5_6_LPUART1_IRQn 1 */ } /* USER CODE BEGIN 1 */ diff --git a/Core/Src/tim.c b/Core/Src/tim.c index 2d6e927..0491848 100644 --- a/Core/Src/tim.c +++ b/Core/Src/tim.c @@ -32,550 +32,616 @@ TIM_HandleTypeDef htim14; TIM_HandleTypeDef htim15; /* TIM1 init function */ -void MX_TIM1_Init(void) +void MX_TIM1_Init (void) { - /* USER CODE BEGIN TIM1_Init 0 */ + /* USER CODE BEGIN TIM1_Init 0 */ - /* USER CODE END TIM1_Init 0 */ + /* USER CODE END TIM1_Init 0 */ - TIM_MasterConfigTypeDef sMasterConfig = {0}; - TIM_IC_InitTypeDef sConfigIC = {0}; + TIM_MasterConfigTypeDef sMasterConfig = {0}; + TIM_IC_InitTypeDef sConfigIC = {0}; - /* USER CODE BEGIN TIM1_Init 1 */ + /* USER CODE BEGIN TIM1_Init 1 */ - /* USER CODE END TIM1_Init 1 */ - htim1.Instance = TIM1; - htim1.Init.Prescaler = 0; - htim1.Init.CounterMode = TIM_COUNTERMODE_UP; - htim1.Init.Period = 65535; - htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; - htim1.Init.RepetitionCounter = 0; - htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; - if (HAL_TIM_IC_Init(&htim1) != HAL_OK) - { - Error_Handler(); - } - sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; - sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET; - sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; - if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK) - { - Error_Handler(); - } - sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING; - sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI; - sConfigIC.ICPrescaler = TIM_ICPSC_DIV1; - sConfigIC.ICFilter = 0; - if (HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_1) != HAL_OK) - { - Error_Handler(); - } - if (HAL_TIM_IC_ConfigChannel(&htim1, &sConfigIC, TIM_CHANNEL_2) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN TIM1_Init 2 */ + /* USER CODE END TIM1_Init 1 */ + htim1.Instance = TIM1; + htim1.Init.Prescaler = 0; + htim1.Init.CounterMode = TIM_COUNTERMODE_UP; + htim1.Init.Period = 65535; + htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; + htim1.Init.RepetitionCounter = 0; + htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; + if (HAL_TIM_IC_Init (&htim1) != HAL_OK) + { + Error_Handler(); + } + sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; + sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET; + sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; + if (HAL_TIMEx_MasterConfigSynchronization (&htim1, &sMasterConfig) != HAL_OK) + { + Error_Handler(); + } + sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING; + sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI; + sConfigIC.ICPrescaler = TIM_ICPSC_DIV1; + sConfigIC.ICFilter = 0; + if (HAL_TIM_IC_ConfigChannel (&htim1, &sConfigIC, TIM_CHANNEL_1) != HAL_OK) + { + Error_Handler(); + } + if (HAL_TIM_IC_ConfigChannel (&htim1, &sConfigIC, TIM_CHANNEL_2) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN TIM1_Init 2 */ - /* USER CODE END TIM1_Init 2 */ + /* USER CODE END TIM1_Init 2 */ } /* TIM3 init function */ -void MX_TIM3_Init(void) +void MX_TIM3_Init (void) { - /* USER CODE BEGIN TIM3_Init 0 */ + /* USER CODE BEGIN TIM3_Init 0 */ - /* USER CODE END TIM3_Init 0 */ + /* USER CODE END TIM3_Init 0 */ - TIM_MasterConfigTypeDef sMasterConfig = {0}; - TIM_OC_InitTypeDef sConfigOC = {0}; + TIM_MasterConfigTypeDef sMasterConfig = {0}; + TIM_OC_InitTypeDef sConfigOC = {0}; - /* USER CODE BEGIN TIM3_Init 1 */ + /* USER CODE BEGIN TIM3_Init 1 */ - /* USER CODE END TIM3_Init 1 */ - htim3.Instance = TIM3; - htim3.Init.Prescaler = 0; - htim3.Init.CounterMode = TIM_COUNTERMODE_UP; - htim3.Init.Period = 65535; - htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; - htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; - if (HAL_TIM_PWM_Init(&htim3) != HAL_OK) - { - Error_Handler(); - } - sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; - sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; - if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK) - { - Error_Handler(); - } - sConfigOC.OCMode = TIM_OCMODE_PWM1; - sConfigOC.Pulse = 0; - sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; - sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; - if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK) - { - Error_Handler(); - } - if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK) - { - Error_Handler(); - } - if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_3) != HAL_OK) - { - Error_Handler(); - } - if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_4) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN TIM3_Init 2 */ + /* USER CODE END TIM3_Init 1 */ + htim3.Instance = TIM3; + htim3.Init.Prescaler = 0; + htim3.Init.CounterMode = TIM_COUNTERMODE_UP; + htim3.Init.Period = 640; + htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; + htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; + if (HAL_TIM_PWM_Init (&htim3) != HAL_OK) + { + Error_Handler(); + } + sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; + sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; + if (HAL_TIMEx_MasterConfigSynchronization (&htim3, &sMasterConfig) != HAL_OK) + { + Error_Handler(); + } + sConfigOC.OCMode = TIM_OCMODE_PWM1; + sConfigOC.Pulse = 0; + sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; + sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; + if (HAL_TIM_PWM_ConfigChannel (&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK) + { + Error_Handler(); + } + if (HAL_TIM_PWM_ConfigChannel (&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK) + { + Error_Handler(); + } + if (HAL_TIM_PWM_ConfigChannel (&htim3, &sConfigOC, TIM_CHANNEL_3) != HAL_OK) + { + Error_Handler(); + } + if (HAL_TIM_PWM_ConfigChannel (&htim3, &sConfigOC, TIM_CHANNEL_4) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN TIM3_Init 2 */ - /* USER CODE END TIM3_Init 2 */ - HAL_TIM_MspPostInit(&htim3); + /* USER CODE END TIM3_Init 2 */ + HAL_TIM_MspPostInit (&htim3); + HAL_TIM_PWM_Start (&htim3, TIM_CHANNEL_1); + HAL_TIM_PWM_Start (&htim3, TIM_CHANNEL_2); + HAL_TIM_PWM_Start (&htim3, TIM_CHANNEL_3); + HAL_TIM_PWM_Start (&htim3, TIM_CHANNEL_4); } /* TIM6 init function */ -void MX_TIM6_Init(void) +void MX_TIM6_Init (void) { - /* USER CODE BEGIN TIM6_Init 0 */ + /* USER CODE BEGIN TIM6_Init 0 */ - /* USER CODE END TIM6_Init 0 */ + /* USER CODE END TIM6_Init 0 */ - TIM_MasterConfigTypeDef sMasterConfig = {0}; + TIM_MasterConfigTypeDef sMasterConfig = {0}; - /* USER CODE BEGIN TIM6_Init 1 */ + /* USER CODE BEGIN TIM6_Init 1 */ - /* USER CODE END TIM6_Init 1 */ - htim6.Instance = TIM6; - htim6.Init.Prescaler = 64; - htim6.Init.CounterMode = TIM_COUNTERMODE_UP; - htim6.Init.Period = 10000; - htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; - if (HAL_TIM_Base_Init(&htim6) != HAL_OK) - { - Error_Handler(); - } - sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; - sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; - if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN TIM6_Init 2 */ + /* USER CODE END TIM6_Init 1 */ + htim6.Instance = TIM6; + htim6.Init.Prescaler = 64; + htim6.Init.CounterMode = TIM_COUNTERMODE_UP; + htim6.Init.Period = 10000; + htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; + if (HAL_TIM_Base_Init (&htim6) != HAL_OK) + { + Error_Handler(); + } + sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; + sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; + if (HAL_TIMEx_MasterConfigSynchronization (&htim6, &sMasterConfig) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN TIM6_Init 2 */ HAL_TIM_Base_Start_IT (&htim6); - /* USER CODE END TIM6_Init 2 */ + /* USER CODE END TIM6_Init 2 */ } /* TIM7 init function */ -void MX_TIM7_Init(void) +void MX_TIM7_Init (void) { - /* USER CODE BEGIN TIM7_Init 0 */ + /* USER CODE BEGIN TIM7_Init 0 */ - /* USER CODE END TIM7_Init 0 */ + /* USER CODE END TIM7_Init 0 */ - TIM_MasterConfigTypeDef sMasterConfig = {0}; + TIM_MasterConfigTypeDef sMasterConfig = {0}; - /* USER CODE BEGIN TIM7_Init 1 */ + /* USER CODE BEGIN TIM7_Init 1 */ - /* USER CODE END TIM7_Init 1 */ - htim7.Instance = TIM7; - htim7.Init.Prescaler = 640; - htim7.Init.CounterMode = TIM_COUNTERMODE_UP; - htim7.Init.Period = 10000; - htim7.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; - if (HAL_TIM_Base_Init(&htim7) != HAL_OK) - { - Error_Handler(); - } - sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; - sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; - if (HAL_TIMEx_MasterConfigSynchronization(&htim7, &sMasterConfig) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN TIM7_Init 2 */ + /* USER CODE END TIM7_Init 1 */ + htim7.Instance = TIM7; + htim7.Init.Prescaler = 640; + htim7.Init.CounterMode = TIM_COUNTERMODE_UP; + htim7.Init.Period = 10000; + htim7.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; + if (HAL_TIM_Base_Init (&htim7) != HAL_OK) + { + Error_Handler(); + } + sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; + sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; + if (HAL_TIMEx_MasterConfigSynchronization (&htim7, &sMasterConfig) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN TIM7_Init 2 */ HAL_TIM_Base_Start_IT (&htim7); - /* USER CODE END TIM7_Init 2 */ + /* USER CODE END TIM7_Init 2 */ } /* TIM14 init function */ -void MX_TIM14_Init(void) +void MX_TIM14_Init (void) { - /* USER CODE BEGIN TIM14_Init 0 */ + /* USER CODE BEGIN TIM14_Init 0 */ - /* USER CODE END TIM14_Init 0 */ + /* USER CODE END TIM14_Init 0 */ - /* USER CODE BEGIN TIM14_Init 1 */ + /* USER CODE BEGIN TIM14_Init 1 */ - /* USER CODE END TIM14_Init 1 */ - htim14.Instance = TIM14; - htim14.Init.Prescaler = 6400; - htim14.Init.CounterMode = TIM_COUNTERMODE_UP; - htim14.Init.Period = 10000; - htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; - htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; - if (HAL_TIM_Base_Init(&htim14) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN TIM14_Init 2 */ + /* USER CODE END TIM14_Init 1 */ + htim14.Instance = TIM14; + htim14.Init.Prescaler = 6400; + htim14.Init.CounterMode = TIM_COUNTERMODE_UP; + htim14.Init.Period = 10000; + htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; + htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; + if (HAL_TIM_Base_Init (&htim14) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN TIM14_Init 2 */ - /* USER CODE END TIM14_Init 2 */ + /* USER CODE END TIM14_Init 2 */ } /* TIM15 init function */ -void MX_TIM15_Init(void) +void MX_TIM15_Init (void) { - /* USER CODE BEGIN TIM15_Init 0 */ + /* USER CODE BEGIN TIM15_Init 0 */ - /* USER CODE END TIM15_Init 0 */ + /* USER CODE END TIM15_Init 0 */ - TIM_MasterConfigTypeDef sMasterConfig = {0}; - TIM_OC_InitTypeDef sConfigOC = {0}; - TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0}; + TIM_MasterConfigTypeDef sMasterConfig = {0}; + TIM_OC_InitTypeDef sConfigOC = {0}; + TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0}; - /* USER CODE BEGIN TIM15_Init 1 */ + /* USER CODE BEGIN TIM15_Init 1 */ - /* USER CODE END TIM15_Init 1 */ - htim15.Instance = TIM15; - htim15.Init.Prescaler = 0; - htim15.Init.CounterMode = TIM_COUNTERMODE_UP; - htim15.Init.Period = 65535; - htim15.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; - htim15.Init.RepetitionCounter = 0; - htim15.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; - if (HAL_TIM_PWM_Init(&htim15) != HAL_OK) - { - Error_Handler(); - } - sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; - sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; - if (HAL_TIMEx_MasterConfigSynchronization(&htim15, &sMasterConfig) != HAL_OK) - { - Error_Handler(); - } - sConfigOC.OCMode = TIM_OCMODE_PWM1; - sConfigOC.Pulse = 0; - sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; - sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH; - sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; - sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET; - sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET; - if (HAL_TIM_PWM_ConfigChannel(&htim15, &sConfigOC, TIM_CHANNEL_1) != HAL_OK) - { - Error_Handler(); - } - if (HAL_TIM_PWM_ConfigChannel(&htim15, &sConfigOC, TIM_CHANNEL_2) != HAL_OK) - { - Error_Handler(); - } - sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE; - sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE; - sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF; - sBreakDeadTimeConfig.DeadTime = 0; - sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE; - sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH; - sBreakDeadTimeConfig.BreakFilter = 0; - sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE; - if (HAL_TIMEx_ConfigBreakDeadTime(&htim15, &sBreakDeadTimeConfig) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN TIM15_Init 2 */ + /* USER CODE END TIM15_Init 1 */ + htim15.Instance = TIM15; + htim15.Init.Prescaler = 0; + htim15.Init.CounterMode = TIM_COUNTERMODE_UP; + htim15.Init.Period = 65535; + htim15.Init.ClockDivision = TIM_CLOCKDIVISION_DIV4 ; + htim15.Init.RepetitionCounter = 0; + htim15.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; + if (HAL_TIM_PWM_Init (&htim15) != HAL_OK) + { + Error_Handler(); + } + sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; + sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; + if (HAL_TIMEx_MasterConfigSynchronization (&htim15, &sMasterConfig) != HAL_OK) + { + Error_Handler(); + } + sConfigOC.OCMode = TIM_OCMODE_PWM1; + sConfigOC.Pulse = 3000; + sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; + sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH; + sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; + sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET; + sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET; + if (HAL_TIM_PWM_ConfigChannel (&htim15, &sConfigOC, TIM_CHANNEL_1) != HAL_OK) + { + Error_Handler(); + } + if (HAL_TIM_PWM_ConfigChannel (&htim15, &sConfigOC, TIM_CHANNEL_2) != HAL_OK) + { + Error_Handler(); + } + sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE; + sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE; + sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF; + sBreakDeadTimeConfig.DeadTime = 0; + sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE; + sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH; + sBreakDeadTimeConfig.BreakFilter = 0; + sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE; + if (HAL_TIMEx_ConfigBreakDeadTime (&htim15, &sBreakDeadTimeConfig) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN TIM15_Init 2 */ - /* USER CODE END TIM15_Init 2 */ - HAL_TIM_MspPostInit(&htim15); + /* USER CODE END TIM15_Init 2 */ + HAL_TIM_MspPostInit (&htim15); + HAL_TIM_PWM_Start (&htim15, TIM_CHANNEL_1); + HAL_TIM_PWM_Start (&htim15, TIM_CHANNEL_2); } -void HAL_TIM_IC_MspInit(TIM_HandleTypeDef* tim_icHandle) +void HAL_TIM_IC_MspInit (TIM_HandleTypeDef* tim_icHandle) { - GPIO_InitTypeDef GPIO_InitStruct = {0}; - RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; - if(tim_icHandle->Instance==TIM1) - { - /* USER CODE BEGIN TIM1_MspInit 0 */ + GPIO_InitTypeDef GPIO_InitStruct = {0}; + RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; + if (tim_icHandle->Instance == TIM1) + { + /* USER CODE BEGIN TIM1_MspInit 0 */ - /* USER CODE END TIM1_MspInit 0 */ + /* USER CODE END TIM1_MspInit 0 */ - /** Initializes the peripherals clocks - */ - PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_TIM1; - PeriphClkInit.Tim1ClockSelection = RCC_TIM1CLKSOURCE_PCLK1; - if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) - { - Error_Handler(); - } + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_TIM1; + PeriphClkInit.Tim1ClockSelection = RCC_TIM1CLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } - /* TIM1 clock enable */ - __HAL_RCC_TIM1_CLK_ENABLE(); + /* TIM1 clock enable */ + __HAL_RCC_TIM1_CLK_ENABLE(); - __HAL_RCC_GPIOC_CLK_ENABLE(); - /**TIM1 GPIO Configuration - PC8 ------> TIM1_CH1 - PC9 ------> TIM1_CH2 - */ - GPIO_InitStruct.Pin = DI1_Pin|DI2_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF2_TIM1; - HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); + __HAL_RCC_GPIOC_CLK_ENABLE(); + /**TIM1 GPIO Configuration + PC8 ------> TIM1_CH1 + PC9 ------> TIM1_CH2 + */ + GPIO_InitStruct.Pin = DI1_Pin | DI2_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF2_TIM1; + HAL_GPIO_Init (GPIOC, &GPIO_InitStruct); - /* USER CODE BEGIN TIM1_MspInit 1 */ + /* USER CODE BEGIN TIM1_MspInit 1 */ - /* USER CODE END TIM1_MspInit 1 */ - } + /* USER CODE END TIM1_MspInit 1 */ + } } -void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef* tim_pwmHandle) +void HAL_TIM_PWM_MspInit (TIM_HandleTypeDef* tim_pwmHandle) { - RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; - if(tim_pwmHandle->Instance==TIM3) - { - /* USER CODE BEGIN TIM3_MspInit 0 */ + RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; + if (tim_pwmHandle->Instance == TIM3) + { + /* USER CODE BEGIN TIM3_MspInit 0 */ - /* USER CODE END TIM3_MspInit 0 */ + /* USER CODE END TIM3_MspInit 0 */ - /* TIM3 clock enable */ - __HAL_RCC_TIM3_CLK_ENABLE(); - /* USER CODE BEGIN TIM3_MspInit 1 */ + /* TIM3 clock enable */ + __HAL_RCC_TIM3_CLK_ENABLE(); + /* USER CODE BEGIN TIM3_MspInit 1 */ - /* USER CODE END TIM3_MspInit 1 */ - } - else if(tim_pwmHandle->Instance==TIM15) - { - /* USER CODE BEGIN TIM15_MspInit 0 */ + /* USER CODE END TIM3_MspInit 1 */ + } + else if (tim_pwmHandle->Instance == TIM15) + { + /* USER CODE BEGIN TIM15_MspInit 0 */ - /* USER CODE END TIM15_MspInit 0 */ + /* USER CODE END TIM15_MspInit 0 */ - /** Initializes the peripherals clocks - */ - PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_TIM15; - PeriphClkInit.Tim15ClockSelection = RCC_TIM15CLKSOURCE_PCLK1; - if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) - { - Error_Handler(); - } + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_TIM15; + PeriphClkInit.Tim15ClockSelection = RCC_TIM15CLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } - /* TIM15 clock enable */ - __HAL_RCC_TIM15_CLK_ENABLE(); - /* USER CODE BEGIN TIM15_MspInit 1 */ + /* TIM15 clock enable */ + __HAL_RCC_TIM15_CLK_ENABLE(); + /* USER CODE BEGIN TIM15_MspInit 1 */ - /* USER CODE END TIM15_MspInit 1 */ - } + /* USER CODE END TIM15_MspInit 1 */ + } } -void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle) +void HAL_TIM_Base_MspInit (TIM_HandleTypeDef* tim_baseHandle) { - if(tim_baseHandle->Instance==TIM6) - { - /* USER CODE BEGIN TIM6_MspInit 0 */ + if (tim_baseHandle->Instance == TIM6) + { + /* USER CODE BEGIN TIM6_MspInit 0 */ - /* USER CODE END TIM6_MspInit 0 */ + /* USER CODE END TIM6_MspInit 0 */ - /* TIM6 clock enable */ - __HAL_RCC_TIM6_CLK_ENABLE(); - /* USER CODE BEGIN TIM6_MspInit 1 */ + /* TIM6 clock enable */ + __HAL_RCC_TIM6_CLK_ENABLE(); + /* USER CODE BEGIN TIM6_MspInit 1 */ - /* USER CODE END TIM6_MspInit 1 */ - } - else if(tim_baseHandle->Instance==TIM7) - { - /* USER CODE BEGIN TIM7_MspInit 0 */ + /* USER CODE END TIM6_MspInit 1 */ + } + else if (tim_baseHandle->Instance == TIM7) + { + /* USER CODE BEGIN TIM7_MspInit 0 */ - /* USER CODE END TIM7_MspInit 0 */ + /* USER CODE END TIM7_MspInit 0 */ - /* TIM7 clock enable */ - __HAL_RCC_TIM7_CLK_ENABLE(); + /* TIM7 clock enable */ + __HAL_RCC_TIM7_CLK_ENABLE(); - /* TIM7 interrupt Init */ - HAL_NVIC_SetPriority(TIM7_LPTIM2_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(TIM7_LPTIM2_IRQn); - /* USER CODE BEGIN TIM7_MspInit 1 */ + /* TIM7 interrupt Init */ + HAL_NVIC_SetPriority (TIM7_LPTIM2_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (TIM7_LPTIM2_IRQn); + /* USER CODE BEGIN TIM7_MspInit 1 */ - /* USER CODE END TIM7_MspInit 1 */ - } - else if(tim_baseHandle->Instance==TIM14) - { - /* USER CODE BEGIN TIM14_MspInit 0 */ + /* USER CODE END TIM7_MspInit 1 */ + } + else if (tim_baseHandle->Instance == TIM14) + { + /* USER CODE BEGIN TIM14_MspInit 0 */ - /* USER CODE END TIM14_MspInit 0 */ + /* USER CODE END TIM14_MspInit 0 */ - /* TIM14 clock enable */ - __HAL_RCC_TIM14_CLK_ENABLE(); + /* TIM14 clock enable */ + __HAL_RCC_TIM14_CLK_ENABLE(); - /* TIM14 interrupt Init */ - HAL_NVIC_SetPriority(TIM14_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(TIM14_IRQn); - /* USER CODE BEGIN TIM14_MspInit 1 */ + /* TIM14 interrupt Init */ + HAL_NVIC_SetPriority (TIM14_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (TIM14_IRQn); + /* USER CODE BEGIN TIM14_MspInit 1 */ - /* USER CODE END TIM14_MspInit 1 */ - } + /* USER CODE END TIM14_MspInit 1 */ + } } -void HAL_TIM_MspPostInit(TIM_HandleTypeDef* timHandle) +void HAL_TIM_MspPostInit (TIM_HandleTypeDef* timHandle) { - GPIO_InitTypeDef GPIO_InitStruct = {0}; - if(timHandle->Instance==TIM3) - { - /* USER CODE BEGIN TIM3_MspPostInit 0 */ + GPIO_InitTypeDef GPIO_InitStruct = {0}; + if (timHandle->Instance == TIM3) + { + /* USER CODE BEGIN TIM3_MspPostInit 0 */ - /* USER CODE END TIM3_MspPostInit 0 */ - __HAL_RCC_GPIOE_CLK_ENABLE(); - __HAL_RCC_GPIOB_CLK_ENABLE(); - /**TIM3 GPIO Configuration - PE4 ------> TIM3_CH2 - PE5 ------> TIM3_CH3 - PE6 ------> TIM3_CH4 - PB4 ------> TIM3_CH1 - */ - GPIO_InitStruct.Pin = PWM_CH2_Pin|PWM_CH3_Pin|PWM_CH4_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF1_TIM3; - HAL_GPIO_Init(GPIOE, &GPIO_InitStruct); + /* USER CODE END TIM3_MspPostInit 0 */ + __HAL_RCC_GPIOE_CLK_ENABLE(); + __HAL_RCC_GPIOB_CLK_ENABLE(); + /**TIM3 GPIO Configuration + PE4 ------> TIM3_CH2 + PE5 ------> TIM3_CH3 + PE6 ------> TIM3_CH4 + PB4 ------> TIM3_CH1 + */ + GPIO_InitStruct.Pin = PWM_CH2_Pin | PWM_CH3_Pin | PWM_CH4_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF1_TIM3; + HAL_GPIO_Init (GPIOE, &GPIO_InitStruct); - GPIO_InitStruct.Pin = PWM_CH1_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF1_TIM3; - HAL_GPIO_Init(PWM_CH1_GPIO_Port, &GPIO_InitStruct); + GPIO_InitStruct.Pin = PWM_CH1_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF1_TIM3; + HAL_GPIO_Init (PWM_CH1_GPIO_Port, &GPIO_InitStruct); - /* USER CODE BEGIN TIM3_MspPostInit 1 */ + /* USER CODE BEGIN TIM3_MspPostInit 1 */ - /* USER CODE END TIM3_MspPostInit 1 */ - } - else if(timHandle->Instance==TIM15) - { - /* USER CODE BEGIN TIM15_MspPostInit 0 */ + /* USER CODE END TIM3_MspPostInit 1 */ + } + else if (timHandle->Instance == TIM15) + { + /* USER CODE BEGIN TIM15_MspPostInit 0 */ - /* USER CODE END TIM15_MspPostInit 0 */ + /* USER CODE END TIM15_MspPostInit 0 */ - __HAL_RCC_GPIOF_CLK_ENABLE(); - /**TIM15 GPIO Configuration - PF12 ------> TIM15_CH1 - PF13 ------> TIM15_CH2 - */ - GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF0_TIM15; - HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); + __HAL_RCC_GPIOF_CLK_ENABLE(); + /**TIM15 GPIO Configuration + PF12 ------> TIM15_CH1 + PF13 ------> TIM15_CH2 + */ + GPIO_InitStruct.Pin = GPIO_PIN_12 | GPIO_PIN_13; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF0_TIM15; + HAL_GPIO_Init (GPIOF, &GPIO_InitStruct); - /* USER CODE BEGIN TIM15_MspPostInit 1 */ + /* USER CODE BEGIN TIM15_MspPostInit 1 */ - /* USER CODE END TIM15_MspPostInit 1 */ - } + /* USER CODE END TIM15_MspPostInit 1 */ + } } -void HAL_TIM_IC_MspDeInit(TIM_HandleTypeDef* tim_icHandle) +void HAL_TIM_IC_MspDeInit (TIM_HandleTypeDef* tim_icHandle) { - if(tim_icHandle->Instance==TIM1) - { - /* USER CODE BEGIN TIM1_MspDeInit 0 */ + if (tim_icHandle->Instance == TIM1) + { + /* USER CODE BEGIN TIM1_MspDeInit 0 */ - /* USER CODE END TIM1_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_TIM1_CLK_DISABLE(); + /* USER CODE END TIM1_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_TIM1_CLK_DISABLE(); - /**TIM1 GPIO Configuration - PC8 ------> TIM1_CH1 - PC9 ------> TIM1_CH2 - */ - HAL_GPIO_DeInit(GPIOC, DI1_Pin|DI2_Pin); + /**TIM1 GPIO Configuration + PC8 ------> TIM1_CH1 + PC9 ------> TIM1_CH2 + */ + HAL_GPIO_DeInit (GPIOC, DI1_Pin | DI2_Pin); - /* USER CODE BEGIN TIM1_MspDeInit 1 */ + /* USER CODE BEGIN TIM1_MspDeInit 1 */ - /* USER CODE END TIM1_MspDeInit 1 */ - } + /* USER CODE END TIM1_MspDeInit 1 */ + } } -void HAL_TIM_PWM_MspDeInit(TIM_HandleTypeDef* tim_pwmHandle) +void HAL_TIM_PWM_MspDeInit (TIM_HandleTypeDef* tim_pwmHandle) { - if(tim_pwmHandle->Instance==TIM3) - { - /* USER CODE BEGIN TIM3_MspDeInit 0 */ + if (tim_pwmHandle->Instance == TIM3) + { + /* USER CODE BEGIN TIM3_MspDeInit 0 */ - /* USER CODE END TIM3_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_TIM3_CLK_DISABLE(); - /* USER CODE BEGIN TIM3_MspDeInit 1 */ + /* USER CODE END TIM3_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_TIM3_CLK_DISABLE(); + /* USER CODE BEGIN TIM3_MspDeInit 1 */ - /* USER CODE END TIM3_MspDeInit 1 */ - } - else if(tim_pwmHandle->Instance==TIM15) - { - /* USER CODE BEGIN TIM15_MspDeInit 0 */ + /* USER CODE END TIM3_MspDeInit 1 */ + } + else if (tim_pwmHandle->Instance == TIM15) + { + /* USER CODE BEGIN TIM15_MspDeInit 0 */ - /* USER CODE END TIM15_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_TIM15_CLK_DISABLE(); - /* USER CODE BEGIN TIM15_MspDeInit 1 */ + /* USER CODE END TIM15_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_TIM15_CLK_DISABLE(); + /* USER CODE BEGIN TIM15_MspDeInit 1 */ - /* USER CODE END TIM15_MspDeInit 1 */ - } + /* USER CODE END TIM15_MspDeInit 1 */ + } } -void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle) +void HAL_TIM_Base_MspDeInit (TIM_HandleTypeDef* tim_baseHandle) { - if(tim_baseHandle->Instance==TIM6) - { - /* USER CODE BEGIN TIM6_MspDeInit 0 */ + if (tim_baseHandle->Instance == TIM6) + { + /* USER CODE BEGIN TIM6_MspDeInit 0 */ - /* USER CODE END TIM6_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_TIM6_CLK_DISABLE(); - /* USER CODE BEGIN TIM6_MspDeInit 1 */ + /* USER CODE END TIM6_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_TIM6_CLK_DISABLE(); + /* USER CODE BEGIN TIM6_MspDeInit 1 */ - /* USER CODE END TIM6_MspDeInit 1 */ - } - else if(tim_baseHandle->Instance==TIM7) - { - /* USER CODE BEGIN TIM7_MspDeInit 0 */ + /* USER CODE END TIM6_MspDeInit 1 */ + } + else if (tim_baseHandle->Instance == TIM7) + { + /* USER CODE BEGIN TIM7_MspDeInit 0 */ - /* USER CODE END TIM7_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_TIM7_CLK_DISABLE(); + /* USER CODE END TIM7_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_TIM7_CLK_DISABLE(); - /* TIM7 interrupt Deinit */ - HAL_NVIC_DisableIRQ(TIM7_LPTIM2_IRQn); - /* USER CODE BEGIN TIM7_MspDeInit 1 */ + /* TIM7 interrupt Deinit */ + HAL_NVIC_DisableIRQ (TIM7_LPTIM2_IRQn); + /* USER CODE BEGIN TIM7_MspDeInit 1 */ - /* USER CODE END TIM7_MspDeInit 1 */ - } - else if(tim_baseHandle->Instance==TIM14) - { - /* USER CODE BEGIN TIM14_MspDeInit 0 */ + /* USER CODE END TIM7_MspDeInit 1 */ + } + else if (tim_baseHandle->Instance == TIM14) + { + /* USER CODE BEGIN TIM14_MspDeInit 0 */ - /* USER CODE END TIM14_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_TIM14_CLK_DISABLE(); + /* USER CODE END TIM14_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_TIM14_CLK_DISABLE(); - /* TIM14 interrupt Deinit */ - HAL_NVIC_DisableIRQ(TIM14_IRQn); - /* USER CODE BEGIN TIM14_MspDeInit 1 */ + /* TIM14 interrupt Deinit */ + HAL_NVIC_DisableIRQ (TIM14_IRQn); + /* USER CODE BEGIN TIM14_MspDeInit 1 */ - /* USER CODE END TIM14_MspDeInit 1 */ - } + /* USER CODE END TIM14_MspDeInit 1 */ + } } /* USER CODE BEGIN 1 */ + +void MX_TIM_SetDuty (int index, uint32_t duty) +{ + TIM_OC_InitTypeDef sConfigOC = {0}; + TIM_MasterConfigTypeDef sMasterConfig = {0}; + sConfigOC.OCMode = TIM_OCMODE_PWM1; + sConfigOC.Pulse = duty * 640 / 100; + sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; + sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; + + + + +// sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; +// sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; +// if (HAL_TIMEx_MasterConfigSynchronization (&htim3, &sMasterConfig) != HAL_OK) +// { +// Error_Handler(); +// } + switch (index) + { + case 1: + if (HAL_TIM_PWM_ConfigChannel (&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK) + { + Error_Handler(); + } + HAL_TIM_PWM_Stop (&htim3, TIM_CHANNEL_1); + HAL_TIM_PWM_Start (&htim3, TIM_CHANNEL_1); + break; + case 2: + if (HAL_TIM_PWM_ConfigChannel (&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK) + { + Error_Handler(); + } + HAL_TIM_PWM_Stop (&htim3, TIM_CHANNEL_2); + HAL_TIM_PWM_Start (&htim3, TIM_CHANNEL_2); + break; + case 3: + if (HAL_TIM_PWM_ConfigChannel (&htim3, &sConfigOC, TIM_CHANNEL_3) != HAL_OK) + { + Error_Handler(); + } + HAL_TIM_PWM_Stop (&htim3, TIM_CHANNEL_3); + HAL_TIM_PWM_Start (&htim3, TIM_CHANNEL_3); + break; + case 4: + if (HAL_TIM_PWM_ConfigChannel (&htim3, &sConfigOC, TIM_CHANNEL_4) != HAL_OK) + { + Error_Handler(); + } + HAL_TIM_PWM_Stop (&htim3, TIM_CHANNEL_4); + HAL_TIM_PWM_Start (&htim3, TIM_CHANNEL_4); + break; + default: + break; + } + + +} + /* USER CODE END 1 */ diff --git a/Core/Src/usart.c b/Core/Src/usart.c index 90ceb54..b574c5d 100644 --- a/Core/Src/usart.c +++ b/Core/Src/usart.c @@ -41,830 +41,830 @@ DMA_HandleTypeDef hdma_lpuart1_rx; /* LPUART1 init function */ -void MX_LPUART1_UART_Init(void) +void MX_LPUART1_UART_Init (void) { - /* USER CODE BEGIN LPUART1_Init 0 */ + /* USER CODE BEGIN LPUART1_Init 0 */ - /* USER CODE END LPUART1_Init 0 */ + /* USER CODE END LPUART1_Init 0 */ - /* USER CODE BEGIN LPUART1_Init 1 */ + /* USER CODE BEGIN LPUART1_Init 1 */ - /* USER CODE END LPUART1_Init 1 */ - hlpuart1.Instance = LPUART1; - hlpuart1.Init.BaudRate = 209700; - hlpuart1.Init.WordLength = UART_WORDLENGTH_7B; - hlpuart1.Init.StopBits = UART_STOPBITS_1; - hlpuart1.Init.Parity = UART_PARITY_NONE; - hlpuart1.Init.Mode = UART_MODE_TX_RX; - hlpuart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; - hlpuart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; - hlpuart1.Init.ClockPrescaler = UART_PRESCALER_DIV1; - hlpuart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; - hlpuart1.FifoMode = UART_FIFOMODE_DISABLE; - if (HAL_UART_Init(&hlpuart1) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetTxFifoThreshold(&hlpuart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetRxFifoThreshold(&hlpuart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_DisableFifoMode(&hlpuart1) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN LPUART1_Init 2 */ + /* USER CODE END LPUART1_Init 1 */ + hlpuart1.Instance = LPUART1; + hlpuart1.Init.BaudRate = 209700; + hlpuart1.Init.WordLength = UART_WORDLENGTH_7B; + hlpuart1.Init.StopBits = UART_STOPBITS_1; + hlpuart1.Init.Parity = UART_PARITY_NONE; + hlpuart1.Init.Mode = UART_MODE_TX_RX; + hlpuart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; + hlpuart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; + hlpuart1.Init.ClockPrescaler = UART_PRESCALER_DIV1; + hlpuart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; + hlpuart1.FifoMode = UART_FIFOMODE_DISABLE; + if (HAL_UART_Init (&hlpuart1) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetTxFifoThreshold (&hlpuart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetRxFifoThreshold (&hlpuart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_DisableFifoMode (&hlpuart1) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN LPUART1_Init 2 */ - /* USER CODE END LPUART1_Init 2 */ + /* USER CODE END LPUART1_Init 2 */ } /* LPUART2 init function */ -void MX_LPUART2_UART_Init(void) +void MX_LPUART2_UART_Init (void) { - /* USER CODE BEGIN LPUART2_Init 0 */ + /* USER CODE BEGIN LPUART2_Init 0 */ - /* USER CODE END LPUART2_Init 0 */ + /* USER CODE END LPUART2_Init 0 */ - /* USER CODE BEGIN LPUART2_Init 1 */ + /* USER CODE BEGIN LPUART2_Init 1 */ - /* USER CODE END LPUART2_Init 1 */ - hlpuart2.Instance = LPUART2; - hlpuart2.Init.BaudRate = 209700; - hlpuart2.Init.WordLength = UART_WORDLENGTH_7B; - hlpuart2.Init.StopBits = UART_STOPBITS_1; - hlpuart2.Init.Parity = UART_PARITY_NONE; - hlpuart2.Init.Mode = UART_MODE_TX_RX; - hlpuart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; - hlpuart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; - hlpuart2.Init.ClockPrescaler = UART_PRESCALER_DIV1; - hlpuart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; - hlpuart2.FifoMode = UART_FIFOMODE_DISABLE; - if (HAL_UART_Init(&hlpuart2) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetTxFifoThreshold(&hlpuart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetRxFifoThreshold(&hlpuart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_DisableFifoMode(&hlpuart2) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN LPUART2_Init 2 */ + /* USER CODE END LPUART2_Init 1 */ + hlpuart2.Instance = LPUART2; + hlpuart2.Init.BaudRate = 209700; + hlpuart2.Init.WordLength = UART_WORDLENGTH_7B; + hlpuart2.Init.StopBits = UART_STOPBITS_1; + hlpuart2.Init.Parity = UART_PARITY_NONE; + hlpuart2.Init.Mode = UART_MODE_TX_RX; + hlpuart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; + hlpuart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; + hlpuart2.Init.ClockPrescaler = UART_PRESCALER_DIV1; + hlpuart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; + hlpuart2.FifoMode = UART_FIFOMODE_DISABLE; + if (HAL_UART_Init (&hlpuart2) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetTxFifoThreshold (&hlpuart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetRxFifoThreshold (&hlpuart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_DisableFifoMode (&hlpuart2) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN LPUART2_Init 2 */ - /* USER CODE END LPUART2_Init 2 */ + /* USER CODE END LPUART2_Init 2 */ } /* USART1 init function */ -void MX_USART1_UART_Init(void) +void MX_USART1_UART_Init (void) { - /* USER CODE BEGIN USART1_Init 0 */ + /* USER CODE BEGIN USART1_Init 0 */ - /* USER CODE END USART1_Init 0 */ + /* USER CODE END USART1_Init 0 */ - /* USER CODE BEGIN USART1_Init 1 */ + /* USER CODE BEGIN USART1_Init 1 */ - /* USER CODE END USART1_Init 1 */ - huart1.Instance = USART1; - huart1.Init.BaudRate = 115200; - huart1.Init.WordLength = UART_WORDLENGTH_8B; - huart1.Init.StopBits = UART_STOPBITS_1; - huart1.Init.Parity = UART_PARITY_NONE; - huart1.Init.Mode = UART_MODE_TX_RX; - huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; - huart1.Init.OverSampling = UART_OVERSAMPLING_16; - huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; - huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1; - huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; - if (HAL_UART_Init(&huart1) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN USART1_Init 2 */ + /* USER CODE END USART1_Init 1 */ + huart1.Instance = USART1; + huart1.Init.BaudRate = 115200; + huart1.Init.WordLength = UART_WORDLENGTH_8B; + huart1.Init.StopBits = UART_STOPBITS_1; + huart1.Init.Parity = UART_PARITY_NONE; + huart1.Init.Mode = UART_MODE_TX_RX; + huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; + huart1.Init.OverSampling = UART_OVERSAMPLING_16; + huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; + huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1; + huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; + if (HAL_UART_Init (&huart1) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetTxFifoThreshold (&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetRxFifoThreshold (&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_DisableFifoMode (&huart1) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN USART1_Init 2 */ - /* USER CODE END USART1_Init 2 */ + /* USER CODE END USART1_Init 2 */ } /* USART2 init function */ -void MX_USART2_UART_Init(void) +void MX_USART2_UART_Init (void) { - /* USER CODE BEGIN USART2_Init 0 */ + /* USER CODE BEGIN USART2_Init 0 */ - /* USER CODE END USART2_Init 0 */ + /* USER CODE END USART2_Init 0 */ - /* USER CODE BEGIN USART2_Init 1 */ + /* USER CODE BEGIN USART2_Init 1 */ - /* USER CODE END USART2_Init 1 */ - huart2.Instance = USART2; - huart2.Init.BaudRate = 115200; - huart2.Init.WordLength = UART_WORDLENGTH_8B; - huart2.Init.StopBits = UART_STOPBITS_1; - huart2.Init.Parity = UART_PARITY_NONE; - huart2.Init.Mode = UART_MODE_TX_RX; - huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; - huart2.Init.OverSampling = UART_OVERSAMPLING_16; - huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; - huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1; - huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; - if (HAL_UART_Init(&huart2) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetTxFifoThreshold(&huart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetRxFifoThreshold(&huart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_DisableFifoMode(&huart2) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN USART2_Init 2 */ + /* USER CODE END USART2_Init 1 */ + huart2.Instance = USART2; + huart2.Init.BaudRate = 115200; + huart2.Init.WordLength = UART_WORDLENGTH_8B; + huart2.Init.StopBits = UART_STOPBITS_1; + huart2.Init.Parity = UART_PARITY_NONE; + huart2.Init.Mode = UART_MODE_TX_RX; + huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; + huart2.Init.OverSampling = UART_OVERSAMPLING_16; + huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; + huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1; + huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; + if (HAL_UART_Init (&huart2) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetTxFifoThreshold (&huart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetRxFifoThreshold (&huart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_DisableFifoMode (&huart2) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN USART2_Init 2 */ __HAL_UART_ENABLE_IT (&huart2, UART_IT_RXNE); // USART2->TDR = 0x31; - /* USER CODE END USART2_Init 2 */ + /* USER CODE END USART2_Init 2 */ } /* USART3 init function */ -void MX_USART3_UART_Init(void) +void MX_USART3_UART_Init (void) { - /* USER CODE BEGIN USART3_Init 0 */ + /* USER CODE BEGIN USART3_Init 0 */ - /* USER CODE END USART3_Init 0 */ + /* USER CODE END USART3_Init 0 */ - /* USER CODE BEGIN USART3_Init 1 */ + /* USER CODE BEGIN USART3_Init 1 */ - /* USER CODE END USART3_Init 1 */ - huart3.Instance = USART3; - huart3.Init.BaudRate = 115200; - huart3.Init.WordLength = UART_WORDLENGTH_8B; - huart3.Init.StopBits = UART_STOPBITS_1; - huart3.Init.Parity = UART_PARITY_NONE; - huart3.Init.Mode = UART_MODE_TX_RX; - huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE; - huart3.Init.OverSampling = UART_OVERSAMPLING_16; - huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; - huart3.Init.ClockPrescaler = UART_PRESCALER_DIV1; - huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; - if (HAL_UART_Init(&huart3) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetTxFifoThreshold(&huart3, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_SetRxFifoThreshold(&huart3, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) - { - Error_Handler(); - } - if (HAL_UARTEx_DisableFifoMode(&huart3) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN USART3_Init 2 */ + /* USER CODE END USART3_Init 1 */ + huart3.Instance = USART3; + huart3.Init.BaudRate = 115200; + huart3.Init.WordLength = UART_WORDLENGTH_8B; + huart3.Init.StopBits = UART_STOPBITS_1; + huart3.Init.Parity = UART_PARITY_NONE; + huart3.Init.Mode = UART_MODE_TX_RX; + huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE; + huart3.Init.OverSampling = UART_OVERSAMPLING_16; + huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; + huart3.Init.ClockPrescaler = UART_PRESCALER_DIV1; + huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; + if (HAL_UART_Init (&huart3) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetTxFifoThreshold (&huart3, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_SetRxFifoThreshold (&huart3, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) + { + Error_Handler(); + } + if (HAL_UARTEx_DisableFifoMode (&huart3) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN USART3_Init 2 */ - /* USER CODE END USART3_Init 2 */ + /* USER CODE END USART3_Init 2 */ } /* USART4 init function */ -void MX_USART4_UART_Init(void) +void MX_USART4_UART_Init (void) { - /* USER CODE BEGIN USART4_Init 0 */ - /* USER CODE END USART4_Init 0 */ + /* USER CODE BEGIN USART4_Init 0 */ + /* USER CODE END USART4_Init 0 */ - /* USER CODE BEGIN USART4_Init 1 */ + /* USER CODE BEGIN USART4_Init 1 */ - /* USER CODE END USART4_Init 1 */ - huart4.Instance = USART4; - huart4.Init.BaudRate = 115200; - huart4.Init.WordLength = UART_WORDLENGTH_8B; - huart4.Init.StopBits = UART_STOPBITS_1; - huart4.Init.Parity = UART_PARITY_NONE; - huart4.Init.Mode = UART_MODE_TX_RX; - huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE; - huart4.Init.OverSampling = UART_OVERSAMPLING_16; - huart4.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; - huart4.Init.ClockPrescaler = UART_PRESCALER_DIV1; - huart4.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; - if (HAL_UART_Init(&huart4) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN USART4_Init 2 */ + /* USER CODE END USART4_Init 1 */ + huart4.Instance = USART4; + huart4.Init.BaudRate = 115200; + huart4.Init.WordLength = UART_WORDLENGTH_8B; + huart4.Init.StopBits = UART_STOPBITS_1; + huart4.Init.Parity = UART_PARITY_NONE; + huart4.Init.Mode = UART_MODE_TX_RX; + huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE; + huart4.Init.OverSampling = UART_OVERSAMPLING_16; + huart4.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; + huart4.Init.ClockPrescaler = UART_PRESCALER_DIV1; + huart4.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; + if (HAL_UART_Init (&huart4) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN USART4_Init 2 */ __HAL_UART_ENABLE_IT (&huart4, UART_IT_RXNE); - /* USER CODE END USART4_Init 2 */ + /* USER CODE END USART4_Init 2 */ } /* USART5 init function */ -void MX_USART5_UART_Init(void) +void MX_USART5_UART_Init (void) { - /* USER CODE BEGIN USART5_Init 0 */ + /* USER CODE BEGIN USART5_Init 0 */ - /* USER CODE END USART5_Init 0 */ + /* USER CODE END USART5_Init 0 */ - /* USER CODE BEGIN USART5_Init 1 */ + /* USER CODE BEGIN USART5_Init 1 */ - /* USER CODE END USART5_Init 1 */ - huart5.Instance = USART5; - huart5.Init.BaudRate = 115200; - huart5.Init.WordLength = UART_WORDLENGTH_8B; - huart5.Init.StopBits = UART_STOPBITS_1; - huart5.Init.Parity = UART_PARITY_NONE; - huart5.Init.Mode = UART_MODE_TX_RX; - huart5.Init.HwFlowCtl = UART_HWCONTROL_NONE; - huart5.Init.OverSampling = UART_OVERSAMPLING_16; - huart5.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; - huart5.Init.ClockPrescaler = UART_PRESCALER_DIV1; - huart5.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; - if (HAL_UART_Init(&huart5) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN USART5_Init 2 */ + /* USER CODE END USART5_Init 1 */ + huart5.Instance = USART5; + huart5.Init.BaudRate = 115200; + huart5.Init.WordLength = UART_WORDLENGTH_8B; + huart5.Init.StopBits = UART_STOPBITS_1; + huart5.Init.Parity = UART_PARITY_NONE; + huart5.Init.Mode = UART_MODE_TX_RX; + huart5.Init.HwFlowCtl = UART_HWCONTROL_NONE; + huart5.Init.OverSampling = UART_OVERSAMPLING_16; + huart5.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; + huart5.Init.ClockPrescaler = UART_PRESCALER_DIV1; + huart5.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; + if (HAL_UART_Init (&huart5) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN USART5_Init 2 */ - /* USER CODE END USART5_Init 2 */ + /* USER CODE END USART5_Init 2 */ } /* USART6 init function */ -void MX_USART6_UART_Init(void) +void MX_USART6_UART_Init (void) { - /* USER CODE BEGIN USART6_Init 0 */ + /* USER CODE BEGIN USART6_Init 0 */ - /* USER CODE END USART6_Init 0 */ + /* USER CODE END USART6_Init 0 */ - /* USER CODE BEGIN USART6_Init 1 */ + /* USER CODE BEGIN USART6_Init 1 */ - /* USER CODE END USART6_Init 1 */ - huart6.Instance = USART6; - huart6.Init.BaudRate = 115200; - huart6.Init.WordLength = UART_WORDLENGTH_8B; - huart6.Init.StopBits = UART_STOPBITS_1; - huart6.Init.Parity = UART_PARITY_NONE; - huart6.Init.Mode = UART_MODE_TX_RX; - huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE; - huart6.Init.OverSampling = UART_OVERSAMPLING_16; - huart6.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; - huart6.Init.ClockPrescaler = UART_PRESCALER_DIV1; - huart6.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; - if (HAL_UART_Init(&huart6) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN USART6_Init 2 */ + /* USER CODE END USART6_Init 1 */ + huart6.Instance = USART6; + huart6.Init.BaudRate = 115200; + huart6.Init.WordLength = UART_WORDLENGTH_8B; + huart6.Init.StopBits = UART_STOPBITS_1; + huart6.Init.Parity = UART_PARITY_NONE; + huart6.Init.Mode = UART_MODE_TX_RX; + huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE; + huart6.Init.OverSampling = UART_OVERSAMPLING_16; + huart6.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; + huart6.Init.ClockPrescaler = UART_PRESCALER_DIV1; + huart6.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; + if (HAL_UART_Init (&huart6) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN USART6_Init 2 */ - /* USER CODE END USART6_Init 2 */ + /* USER CODE END USART6_Init 2 */ } -void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle) +void HAL_UART_MspInit (UART_HandleTypeDef* uartHandle) { - GPIO_InitTypeDef GPIO_InitStruct = {0}; - RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; - if(uartHandle->Instance==LPUART1) - { - /* USER CODE BEGIN LPUART1_MspInit 0 */ + GPIO_InitTypeDef GPIO_InitStruct = {0}; + RCC_PeriphCLKInitTypeDef PeriphClkInit = {0}; + if (uartHandle->Instance == LPUART1) + { + /* USER CODE BEGIN LPUART1_MspInit 0 */ - /* USER CODE END LPUART1_MspInit 0 */ + /* USER CODE END LPUART1_MspInit 0 */ - /** Initializes the peripherals clocks - */ - PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_LPUART1; - PeriphClkInit.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_PCLK1; - if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) - { - Error_Handler(); - } + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_LPUART1; + PeriphClkInit.Lpuart1ClockSelection = RCC_LPUART1CLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } - /* LPUART1 clock enable */ - __HAL_RCC_LPUART1_CLK_ENABLE(); + /* LPUART1 clock enable */ + __HAL_RCC_LPUART1_CLK_ENABLE(); - __HAL_RCC_GPIOF_CLK_ENABLE(); - /**LPUART1 GPIO Configuration - PF4 ------> LPUART1_TX - PF5 ------> LPUART1_RX - */ - GPIO_InitStruct.Pin = ETH2_TX_Pin|ETH2_RX_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF1_LPUART1; - HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); + __HAL_RCC_GPIOF_CLK_ENABLE(); + /**LPUART1 GPIO Configuration + PF4 ------> LPUART1_TX + PF5 ------> LPUART1_RX + */ + GPIO_InitStruct.Pin = ETH2_TX_Pin | ETH2_RX_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF1_LPUART1; + HAL_GPIO_Init (GPIOF, &GPIO_InitStruct); - /* LPUART1 DMA Init */ - /* LPUART1_RX Init */ - hdma_lpuart1_rx.Instance = DMA1_Channel2; - hdma_lpuart1_rx.Init.Request = DMA_REQUEST_LPUART1_RX; - hdma_lpuart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; - hdma_lpuart1_rx.Init.PeriphInc = DMA_PINC_DISABLE; - hdma_lpuart1_rx.Init.MemInc = DMA_MINC_ENABLE; - hdma_lpuart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; - hdma_lpuart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; - hdma_lpuart1_rx.Init.Mode = DMA_NORMAL; - hdma_lpuart1_rx.Init.Priority = DMA_PRIORITY_LOW; - if (HAL_DMA_Init(&hdma_lpuart1_rx) != HAL_OK) - { - Error_Handler(); - } + /* LPUART1 DMA Init */ + /* LPUART1_RX Init */ + hdma_lpuart1_rx.Instance = DMA1_Channel2; + hdma_lpuart1_rx.Init.Request = DMA_REQUEST_LPUART1_RX; + hdma_lpuart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; + hdma_lpuart1_rx.Init.PeriphInc = DMA_PINC_DISABLE; + hdma_lpuart1_rx.Init.MemInc = DMA_MINC_ENABLE; + hdma_lpuart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; + hdma_lpuart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; + hdma_lpuart1_rx.Init.Mode = DMA_NORMAL; + hdma_lpuart1_rx.Init.Priority = DMA_PRIORITY_LOW; + if (HAL_DMA_Init (&hdma_lpuart1_rx) != HAL_OK) + { + Error_Handler(); + } - __HAL_LINKDMA(uartHandle,hdmarx,hdma_lpuart1_rx); + __HAL_LINKDMA (uartHandle, hdmarx, hdma_lpuart1_rx); - /* LPUART1 interrupt Init */ - HAL_NVIC_SetPriority(USART3_4_5_6_LPUART1_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(USART3_4_5_6_LPUART1_IRQn); - /* USER CODE BEGIN LPUART1_MspInit 1 */ + /* LPUART1 interrupt Init */ + HAL_NVIC_SetPriority (USART3_4_5_6_LPUART1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (USART3_4_5_6_LPUART1_IRQn); + /* USER CODE BEGIN LPUART1_MspInit 1 */ - /* USER CODE END LPUART1_MspInit 1 */ - } - else if(uartHandle->Instance==LPUART2) - { - /* USER CODE BEGIN LPUART2_MspInit 0 */ + /* USER CODE END LPUART1_MspInit 1 */ + } + else if (uartHandle->Instance == LPUART2) + { + /* USER CODE BEGIN LPUART2_MspInit 0 */ - /* USER CODE END LPUART2_MspInit 0 */ + /* USER CODE END LPUART2_MspInit 0 */ - /** Initializes the peripherals clocks - */ - PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_LPUART2; - PeriphClkInit.Lpuart2ClockSelection = RCC_LPUART2CLKSOURCE_PCLK1; - if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) - { - Error_Handler(); - } + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_LPUART2; + PeriphClkInit.Lpuart2ClockSelection = RCC_LPUART2CLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } - /* LPUART2 clock enable */ - __HAL_RCC_LPUART2_CLK_ENABLE(); + /* LPUART2 clock enable */ + __HAL_RCC_LPUART2_CLK_ENABLE(); - __HAL_RCC_GPIOC_CLK_ENABLE(); - /**LPUART2 GPIO Configuration - PC6 ------> LPUART2_TX - PC7 ------> LPUART2_RX - */ - GPIO_InitStruct.Pin = GSM_TX_Pin|GSM_RX_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF3_LPUART2; - HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); + __HAL_RCC_GPIOC_CLK_ENABLE(); + /**LPUART2 GPIO Configuration + PC6 ------> LPUART2_TX + PC7 ------> LPUART2_RX + */ + GPIO_InitStruct.Pin = GSM_TX_Pin | GSM_RX_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF3_LPUART2; + HAL_GPIO_Init (GPIOC, &GPIO_InitStruct); - /* LPUART2 interrupt Init */ - HAL_NVIC_SetPriority(USART2_LPUART2_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(USART2_LPUART2_IRQn); - /* USER CODE BEGIN LPUART2_MspInit 1 */ + /* LPUART2 interrupt Init */ + HAL_NVIC_SetPriority (USART2_LPUART2_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (USART2_LPUART2_IRQn); + /* USER CODE BEGIN LPUART2_MspInit 1 */ - /* USER CODE END LPUART2_MspInit 1 */ - } - else if(uartHandle->Instance==USART1) - { - /* USER CODE BEGIN USART1_MspInit 0 */ + /* USER CODE END LPUART2_MspInit 1 */ + } + else if (uartHandle->Instance == USART1) + { + /* USER CODE BEGIN USART1_MspInit 0 */ - /* USER CODE END USART1_MspInit 0 */ + /* USER CODE END USART1_MspInit 0 */ - /** Initializes the peripherals clocks - */ - PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1; - PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK1; - if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) - { - Error_Handler(); - } + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1; + PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } - /* USART1 clock enable */ - __HAL_RCC_USART1_CLK_ENABLE(); + /* USART1 clock enable */ + __HAL_RCC_USART1_CLK_ENABLE(); - __HAL_RCC_GPIOB_CLK_ENABLE(); - /**USART1 GPIO Configuration - PB6 ------> USART1_TX - PB7 ------> USART1_RX - */ - GPIO_InitStruct.Pin = S4852_TX_Pin|S4852_RX_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF0_USART1; - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + __HAL_RCC_GPIOB_CLK_ENABLE(); + /**USART1 GPIO Configuration + PB6 ------> USART1_TX + PB7 ------> USART1_RX + */ + GPIO_InitStruct.Pin = S4852_TX_Pin | S4852_RX_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF0_USART1; + HAL_GPIO_Init (GPIOB, &GPIO_InitStruct); - /* USART1 interrupt Init */ - HAL_NVIC_SetPriority(USART1_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(USART1_IRQn); - /* USER CODE BEGIN USART1_MspInit 1 */ + /* USART1 interrupt Init */ + HAL_NVIC_SetPriority (USART1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (USART1_IRQn); + /* USER CODE BEGIN USART1_MspInit 1 */ - /* USER CODE END USART1_MspInit 1 */ - } - else if(uartHandle->Instance==USART2) - { - /* USER CODE BEGIN USART2_MspInit 0 */ + /* USER CODE END USART1_MspInit 1 */ + } + else if (uartHandle->Instance == USART2) + { + /* USER CODE BEGIN USART2_MspInit 0 */ - /* USER CODE END USART2_MspInit 0 */ + /* USER CODE END USART2_MspInit 0 */ - /** Initializes the peripherals clocks - */ - PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2; - PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1; - if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) - { - Error_Handler(); - } + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2; + PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } - /* USART2 clock enable */ - __HAL_RCC_USART2_CLK_ENABLE(); + /* USART2 clock enable */ + __HAL_RCC_USART2_CLK_ENABLE(); - __HAL_RCC_GPIOA_CLK_ENABLE(); - /**USART2 GPIO Configuration - PA2 ------> USART2_TX - PA3 ------> USART2_RX - */ - GPIO_InitStruct.Pin = DBG_TX_Pin|DBG_RX_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF1_USART2; - HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + __HAL_RCC_GPIOA_CLK_ENABLE(); + /**USART2 GPIO Configuration + PA2 ------> USART2_TX + PA3 ------> USART2_RX + */ + GPIO_InitStruct.Pin = DBG_TX_Pin | DBG_RX_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF1_USART2; + HAL_GPIO_Init (GPIOA, &GPIO_InitStruct); - /* USART2 interrupt Init */ - HAL_NVIC_SetPriority(USART2_LPUART2_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(USART2_LPUART2_IRQn); - /* USER CODE BEGIN USART2_MspInit 1 */ + /* USART2 interrupt Init */ + HAL_NVIC_SetPriority (USART2_LPUART2_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (USART2_LPUART2_IRQn); + /* USER CODE BEGIN USART2_MspInit 1 */ - /* USER CODE END USART2_MspInit 1 */ - } - else if(uartHandle->Instance==USART3) - { - /* USER CODE BEGIN USART3_MspInit 0 */ + /* USER CODE END USART2_MspInit 1 */ + } + else if (uartHandle->Instance == USART3) + { + /* USER CODE BEGIN USART3_MspInit 0 */ - /* USER CODE END USART3_MspInit 0 */ + /* USER CODE END USART3_MspInit 0 */ - /** Initializes the peripherals clocks - */ - PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART3; - PeriphClkInit.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1; - if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) - { - Error_Handler(); - } + /** Initializes the peripherals clocks + */ + PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART3; + PeriphClkInit.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1; + if (HAL_RCCEx_PeriphCLKConfig (&PeriphClkInit) != HAL_OK) + { + Error_Handler(); + } - /* USART3 clock enable */ - __HAL_RCC_USART3_CLK_ENABLE(); + /* USART3 clock enable */ + __HAL_RCC_USART3_CLK_ENABLE(); - __HAL_RCC_GPIOB_CLK_ENABLE(); - /**USART3 GPIO Configuration - PB9 ------> USART3_RX - PB8 ------> USART3_TX - */ - GPIO_InitStruct.Pin = S4851_RX_Pin|S4851_TX_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF4_USART3; - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + __HAL_RCC_GPIOB_CLK_ENABLE(); + /**USART3 GPIO Configuration + PB9 ------> USART3_RX + PB8 ------> USART3_TX + */ + GPIO_InitStruct.Pin = S4851_RX_Pin | S4851_TX_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF4_USART3; + HAL_GPIO_Init (GPIOB, &GPIO_InitStruct); - /* USART3 interrupt Init */ - HAL_NVIC_SetPriority(USART3_4_5_6_LPUART1_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(USART3_4_5_6_LPUART1_IRQn); - /* USER CODE BEGIN USART3_MspInit 1 */ + /* USART3 interrupt Init */ + HAL_NVIC_SetPriority (USART3_4_5_6_LPUART1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (USART3_4_5_6_LPUART1_IRQn); + /* USER CODE BEGIN USART3_MspInit 1 */ - /* USER CODE END USART3_MspInit 1 */ - } - else if(uartHandle->Instance==USART4) - { - /* USER CODE BEGIN USART4_MspInit 0 */ + /* USER CODE END USART3_MspInit 1 */ + } + else if (uartHandle->Instance == USART4) + { + /* USER CODE BEGIN USART4_MspInit 0 */ - /* USER CODE END USART4_MspInit 0 */ + /* USER CODE END USART4_MspInit 0 */ - /* USART4 clock enable */ - __HAL_RCC_USART4_CLK_ENABLE(); + /* USART4 clock enable */ + __HAL_RCC_USART4_CLK_ENABLE(); - __HAL_RCC_GPIOC_CLK_ENABLE(); - /**USART4 GPIO Configuration - PC10 ------> USART4_TX - PC11 ------> USART4_RX - */ - GPIO_InitStruct.Pin = ETH1_TX_Pin|ETH1_RX_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF1_USART4; - HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); + __HAL_RCC_GPIOC_CLK_ENABLE(); + /**USART4 GPIO Configuration + PC10 ------> USART4_TX + PC11 ------> USART4_RX + */ + GPIO_InitStruct.Pin = ETH1_TX_Pin | ETH1_RX_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF1_USART4; + HAL_GPIO_Init (GPIOC, &GPIO_InitStruct); - /* USART4 interrupt Init */ - HAL_NVIC_SetPriority(USART3_4_5_6_LPUART1_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(USART3_4_5_6_LPUART1_IRQn); - /* USER CODE BEGIN USART4_MspInit 1 */ + /* USART4 interrupt Init */ + HAL_NVIC_SetPriority (USART3_4_5_6_LPUART1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (USART3_4_5_6_LPUART1_IRQn); + /* USER CODE BEGIN USART4_MspInit 1 */ - /* USER CODE END USART4_MspInit 1 */ - } - else if(uartHandle->Instance==USART5) - { - /* USER CODE BEGIN USART5_MspInit 0 */ + /* USER CODE END USART4_MspInit 1 */ + } + else if (uartHandle->Instance == USART5) + { + /* USER CODE BEGIN USART5_MspInit 0 */ - /* USER CODE END USART5_MspInit 0 */ + /* USER CODE END USART5_MspInit 0 */ - /* USART5 clock enable */ - __HAL_RCC_USART5_CLK_ENABLE(); + /* USART5 clock enable */ + __HAL_RCC_USART5_CLK_ENABLE(); - __HAL_RCC_GPIOB_CLK_ENABLE(); - /**USART5 GPIO Configuration - PB0 ------> USART5_TX - PB1 ------> USART5_RX - */ - GPIO_InitStruct.Pin = U485_TX_Pin|U485_RX_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_PULLUP; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF8_USART5; - HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + __HAL_RCC_GPIOB_CLK_ENABLE(); + /**USART5 GPIO Configuration + PB0 ------> USART5_TX + PB1 ------> USART5_RX + */ + GPIO_InitStruct.Pin = U485_TX_Pin | U485_RX_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF8_USART5; + HAL_GPIO_Init (GPIOB, &GPIO_InitStruct); - /* USART5 interrupt Init */ - HAL_NVIC_SetPriority(USART3_4_5_6_LPUART1_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(USART3_4_5_6_LPUART1_IRQn); - /* USER CODE BEGIN USART5_MspInit 1 */ + /* USART5 interrupt Init */ + HAL_NVIC_SetPriority (USART3_4_5_6_LPUART1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (USART3_4_5_6_LPUART1_IRQn); + /* USER CODE BEGIN USART5_MspInit 1 */ - /* USER CODE END USART5_MspInit 1 */ - } - else if(uartHandle->Instance==USART6) - { - /* USER CODE BEGIN USART6_MspInit 0 */ + /* USER CODE END USART5_MspInit 1 */ + } + else if (uartHandle->Instance == USART6) + { + /* USER CODE BEGIN USART6_MspInit 0 */ - /* USER CODE END USART6_MspInit 0 */ + /* USER CODE END USART6_MspInit 0 */ - /* USART6 clock enable */ - __HAL_RCC_USART6_CLK_ENABLE(); + /* USART6 clock enable */ + __HAL_RCC_USART6_CLK_ENABLE(); - __HAL_RCC_GPIOC_CLK_ENABLE(); - /**USART6 GPIO Configuration - PC0 ------> USART6_TX - PC1 ------> USART6_RX - */ - GPIO_InitStruct.Pin = LCD_TX_Pin|LCD_RX_Pin; - GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; - GPIO_InitStruct.Pull = GPIO_NOPULL; - GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; - GPIO_InitStruct.Alternate = GPIO_AF4_USART6; - HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); + __HAL_RCC_GPIOC_CLK_ENABLE(); + /**USART6 GPIO Configuration + PC0 ------> USART6_TX + PC1 ------> USART6_RX + */ + GPIO_InitStruct.Pin = LCD_TX_Pin | LCD_RX_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF4_USART6; + HAL_GPIO_Init (GPIOC, &GPIO_InitStruct); - /* USART6 interrupt Init */ - HAL_NVIC_SetPriority(USART3_4_5_6_LPUART1_IRQn, 0, 0); - HAL_NVIC_EnableIRQ(USART3_4_5_6_LPUART1_IRQn); - /* USER CODE BEGIN USART6_MspInit 1 */ + /* USART6 interrupt Init */ + HAL_NVIC_SetPriority (USART3_4_5_6_LPUART1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ (USART3_4_5_6_LPUART1_IRQn); + /* USER CODE BEGIN USART6_MspInit 1 */ - /* USER CODE END USART6_MspInit 1 */ - } + /* USER CODE END USART6_MspInit 1 */ + } } -void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle) +void HAL_UART_MspDeInit (UART_HandleTypeDef* uartHandle) { - if(uartHandle->Instance==LPUART1) - { - /* USER CODE BEGIN LPUART1_MspDeInit 0 */ + if (uartHandle->Instance == LPUART1) + { + /* USER CODE BEGIN LPUART1_MspDeInit 0 */ - /* USER CODE END LPUART1_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_LPUART1_CLK_DISABLE(); + /* USER CODE END LPUART1_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_LPUART1_CLK_DISABLE(); - /**LPUART1 GPIO Configuration - PF4 ------> LPUART1_TX - PF5 ------> LPUART1_RX - */ - HAL_GPIO_DeInit(GPIOF, ETH2_TX_Pin|ETH2_RX_Pin); + /**LPUART1 GPIO Configuration + PF4 ------> LPUART1_TX + PF5 ------> LPUART1_RX + */ + HAL_GPIO_DeInit (GPIOF, ETH2_TX_Pin | ETH2_RX_Pin); - /* LPUART1 DMA DeInit */ - HAL_DMA_DeInit(uartHandle->hdmarx); + /* LPUART1 DMA DeInit */ + HAL_DMA_DeInit (uartHandle->hdmarx); - /* LPUART1 interrupt Deinit */ - /* USER CODE BEGIN LPUART1:USART3_4_5_6_LPUART1_IRQn disable */ + /* LPUART1 interrupt Deinit */ + /* USER CODE BEGIN LPUART1:USART3_4_5_6_LPUART1_IRQn disable */ /** * Uncomment the line below to disable the "USART3_4_5_6_LPUART1_IRQn" interrupt * Be aware, disabling shared interrupt may affect other IPs */ /* HAL_NVIC_DisableIRQ(USART3_4_5_6_LPUART1_IRQn); */ - /* USER CODE END LPUART1:USART3_4_5_6_LPUART1_IRQn disable */ + /* USER CODE END LPUART1:USART3_4_5_6_LPUART1_IRQn disable */ - /* USER CODE BEGIN LPUART1_MspDeInit 1 */ + /* USER CODE BEGIN LPUART1_MspDeInit 1 */ - /* USER CODE END LPUART1_MspDeInit 1 */ - } - else if(uartHandle->Instance==LPUART2) - { - /* USER CODE BEGIN LPUART2_MspDeInit 0 */ + /* USER CODE END LPUART1_MspDeInit 1 */ + } + else if (uartHandle->Instance == LPUART2) + { + /* USER CODE BEGIN LPUART2_MspDeInit 0 */ - /* USER CODE END LPUART2_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_LPUART2_CLK_DISABLE(); + /* USER CODE END LPUART2_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_LPUART2_CLK_DISABLE(); - /**LPUART2 GPIO Configuration - PC6 ------> LPUART2_TX - PC7 ------> LPUART2_RX - */ - HAL_GPIO_DeInit(GPIOC, GSM_TX_Pin|GSM_RX_Pin); + /**LPUART2 GPIO Configuration + PC6 ------> LPUART2_TX + PC7 ------> LPUART2_RX + */ + HAL_GPIO_DeInit (GPIOC, GSM_TX_Pin | GSM_RX_Pin); - /* LPUART2 interrupt Deinit */ - /* USER CODE BEGIN LPUART2:USART2_LPUART2_IRQn disable */ + /* LPUART2 interrupt Deinit */ + /* USER CODE BEGIN LPUART2:USART2_LPUART2_IRQn disable */ /** * Uncomment the line below to disable the "USART2_LPUART2_IRQn" interrupt * Be aware, disabling shared interrupt may affect other IPs */ /* HAL_NVIC_DisableIRQ(USART2_LPUART2_IRQn); */ - /* USER CODE END LPUART2:USART2_LPUART2_IRQn disable */ + /* USER CODE END LPUART2:USART2_LPUART2_IRQn disable */ - /* USER CODE BEGIN LPUART2_MspDeInit 1 */ + /* USER CODE BEGIN LPUART2_MspDeInit 1 */ - /* USER CODE END LPUART2_MspDeInit 1 */ - } - else if(uartHandle->Instance==USART1) - { - /* USER CODE BEGIN USART1_MspDeInit 0 */ + /* USER CODE END LPUART2_MspDeInit 1 */ + } + else if (uartHandle->Instance == USART1) + { + /* USER CODE BEGIN USART1_MspDeInit 0 */ - /* USER CODE END USART1_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_USART1_CLK_DISABLE(); + /* USER CODE END USART1_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_USART1_CLK_DISABLE(); - /**USART1 GPIO Configuration - PB6 ------> USART1_TX - PB7 ------> USART1_RX - */ - HAL_GPIO_DeInit(GPIOB, S4852_TX_Pin|S4852_RX_Pin); + /**USART1 GPIO Configuration + PB6 ------> USART1_TX + PB7 ------> USART1_RX + */ + HAL_GPIO_DeInit (GPIOB, S4852_TX_Pin | S4852_RX_Pin); - /* USART1 interrupt Deinit */ - HAL_NVIC_DisableIRQ(USART1_IRQn); - /* USER CODE BEGIN USART1_MspDeInit 1 */ + /* USART1 interrupt Deinit */ + HAL_NVIC_DisableIRQ (USART1_IRQn); + /* USER CODE BEGIN USART1_MspDeInit 1 */ - /* USER CODE END USART1_MspDeInit 1 */ - } - else if(uartHandle->Instance==USART2) - { - /* USER CODE BEGIN USART2_MspDeInit 0 */ + /* USER CODE END USART1_MspDeInit 1 */ + } + else if (uartHandle->Instance == USART2) + { + /* USER CODE BEGIN USART2_MspDeInit 0 */ - /* USER CODE END USART2_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_USART2_CLK_DISABLE(); + /* USER CODE END USART2_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_USART2_CLK_DISABLE(); - /**USART2 GPIO Configuration - PA2 ------> USART2_TX - PA3 ------> USART2_RX - */ - HAL_GPIO_DeInit(GPIOA, DBG_TX_Pin|DBG_RX_Pin); + /**USART2 GPIO Configuration + PA2 ------> USART2_TX + PA3 ------> USART2_RX + */ + HAL_GPIO_DeInit (GPIOA, DBG_TX_Pin | DBG_RX_Pin); - /* USART2 interrupt Deinit */ - /* USER CODE BEGIN USART2:USART2_LPUART2_IRQn disable */ + /* USART2 interrupt Deinit */ + /* USER CODE BEGIN USART2:USART2_LPUART2_IRQn disable */ /** * Uncomment the line below to disable the "USART2_LPUART2_IRQn" interrupt * Be aware, disabling shared interrupt may affect other IPs */ /* HAL_NVIC_DisableIRQ(USART2_LPUART2_IRQn); */ - /* USER CODE END USART2:USART2_LPUART2_IRQn disable */ + /* USER CODE END USART2:USART2_LPUART2_IRQn disable */ - /* USER CODE BEGIN USART2_MspDeInit 1 */ + /* USER CODE BEGIN USART2_MspDeInit 1 */ - /* USER CODE END USART2_MspDeInit 1 */ - } - else if(uartHandle->Instance==USART3) - { - /* USER CODE BEGIN USART3_MspDeInit 0 */ + /* USER CODE END USART2_MspDeInit 1 */ + } + else if (uartHandle->Instance == USART3) + { + /* USER CODE BEGIN USART3_MspDeInit 0 */ - /* USER CODE END USART3_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_USART3_CLK_DISABLE(); + /* USER CODE END USART3_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_USART3_CLK_DISABLE(); - /**USART3 GPIO Configuration - PB9 ------> USART3_RX - PB8 ------> USART3_TX - */ - HAL_GPIO_DeInit(GPIOB, S4851_RX_Pin|S4851_TX_Pin); + /**USART3 GPIO Configuration + PB9 ------> USART3_RX + PB8 ------> USART3_TX + */ + HAL_GPIO_DeInit (GPIOB, S4851_RX_Pin | S4851_TX_Pin); - /* USART3 interrupt Deinit */ - /* USER CODE BEGIN USART3:USART3_4_5_6_LPUART1_IRQn disable */ + /* USART3 interrupt Deinit */ + /* USER CODE BEGIN USART3:USART3_4_5_6_LPUART1_IRQn disable */ /** * Uncomment the line below to disable the "USART3_4_5_6_LPUART1_IRQn" interrupt * Be aware, disabling shared interrupt may affect other IPs */ /* HAL_NVIC_DisableIRQ(USART3_4_5_6_LPUART1_IRQn); */ - /* USER CODE END USART3:USART3_4_5_6_LPUART1_IRQn disable */ + /* USER CODE END USART3:USART3_4_5_6_LPUART1_IRQn disable */ - /* USER CODE BEGIN USART3_MspDeInit 1 */ + /* USER CODE BEGIN USART3_MspDeInit 1 */ - /* USER CODE END USART3_MspDeInit 1 */ - } - else if(uartHandle->Instance==USART4) - { - /* USER CODE BEGIN USART4_MspDeInit 0 */ + /* USER CODE END USART3_MspDeInit 1 */ + } + else if (uartHandle->Instance == USART4) + { + /* USER CODE BEGIN USART4_MspDeInit 0 */ - /* USER CODE END USART4_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_USART4_CLK_DISABLE(); + /* USER CODE END USART4_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_USART4_CLK_DISABLE(); - /**USART4 GPIO Configuration - PC10 ------> USART4_TX - PC11 ------> USART4_RX - */ - HAL_GPIO_DeInit(GPIOC, ETH1_TX_Pin|ETH1_RX_Pin); + /**USART4 GPIO Configuration + PC10 ------> USART4_TX + PC11 ------> USART4_RX + */ + HAL_GPIO_DeInit (GPIOC, ETH1_TX_Pin | ETH1_RX_Pin); - /* USART4 interrupt Deinit */ - /* USER CODE BEGIN USART4:USART3_4_5_6_LPUART1_IRQn disable */ + /* USART4 interrupt Deinit */ + /* USER CODE BEGIN USART4:USART3_4_5_6_LPUART1_IRQn disable */ /** * Uncomment the line below to disable the "USART3_4_5_6_LPUART1_IRQn" interrupt * Be aware, disabling shared interrupt may affect other IPs */ /* HAL_NVIC_DisableIRQ(USART3_4_5_6_LPUART1_IRQn); */ - /* USER CODE END USART4:USART3_4_5_6_LPUART1_IRQn disable */ + /* USER CODE END USART4:USART3_4_5_6_LPUART1_IRQn disable */ - /* USER CODE BEGIN USART4_MspDeInit 1 */ + /* USER CODE BEGIN USART4_MspDeInit 1 */ - /* USER CODE END USART4_MspDeInit 1 */ - } - else if(uartHandle->Instance==USART5) - { - /* USER CODE BEGIN USART5_MspDeInit 0 */ + /* USER CODE END USART4_MspDeInit 1 */ + } + else if (uartHandle->Instance == USART5) + { + /* USER CODE BEGIN USART5_MspDeInit 0 */ - /* USER CODE END USART5_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_USART5_CLK_DISABLE(); + /* USER CODE END USART5_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_USART5_CLK_DISABLE(); - /**USART5 GPIO Configuration - PB0 ------> USART5_TX - PB1 ------> USART5_RX - */ - HAL_GPIO_DeInit(GPIOB, U485_TX_Pin|U485_RX_Pin); + /**USART5 GPIO Configuration + PB0 ------> USART5_TX + PB1 ------> USART5_RX + */ + HAL_GPIO_DeInit (GPIOB, U485_TX_Pin | U485_RX_Pin); - /* USART5 interrupt Deinit */ - /* USER CODE BEGIN USART5:USART3_4_5_6_LPUART1_IRQn disable */ + /* USART5 interrupt Deinit */ + /* USER CODE BEGIN USART5:USART3_4_5_6_LPUART1_IRQn disable */ /** * Uncomment the line below to disable the "USART3_4_5_6_LPUART1_IRQn" interrupt * Be aware, disabling shared interrupt may affect other IPs */ /* HAL_NVIC_DisableIRQ(USART3_4_5_6_LPUART1_IRQn); */ - /* USER CODE END USART5:USART3_4_5_6_LPUART1_IRQn disable */ + /* USER CODE END USART5:USART3_4_5_6_LPUART1_IRQn disable */ - /* USER CODE BEGIN USART5_MspDeInit 1 */ + /* USER CODE BEGIN USART5_MspDeInit 1 */ - /* USER CODE END USART5_MspDeInit 1 */ - } - else if(uartHandle->Instance==USART6) - { - /* USER CODE BEGIN USART6_MspDeInit 0 */ + /* USER CODE END USART5_MspDeInit 1 */ + } + else if (uartHandle->Instance == USART6) + { + /* USER CODE BEGIN USART6_MspDeInit 0 */ - /* USER CODE END USART6_MspDeInit 0 */ - /* Peripheral clock disable */ - __HAL_RCC_USART6_CLK_DISABLE(); + /* USER CODE END USART6_MspDeInit 0 */ + /* Peripheral clock disable */ + __HAL_RCC_USART6_CLK_DISABLE(); - /**USART6 GPIO Configuration - PC0 ------> USART6_TX - PC1 ------> USART6_RX - */ - HAL_GPIO_DeInit(GPIOC, LCD_TX_Pin|LCD_RX_Pin); + /**USART6 GPIO Configuration + PC0 ------> USART6_TX + PC1 ------> USART6_RX + */ + HAL_GPIO_DeInit (GPIOC, LCD_TX_Pin | LCD_RX_Pin); - /* USART6 interrupt Deinit */ - /* USER CODE BEGIN USART6:USART3_4_5_6_LPUART1_IRQn disable */ + /* USART6 interrupt Deinit */ + /* USER CODE BEGIN USART6:USART3_4_5_6_LPUART1_IRQn disable */ /** * Uncomment the line below to disable the "USART3_4_5_6_LPUART1_IRQn" interrupt * Be aware, disabling shared interrupt may affect other IPs */ /* HAL_NVIC_DisableIRQ(USART3_4_5_6_LPUART1_IRQn); */ - /* USER CODE END USART6:USART3_4_5_6_LPUART1_IRQn disable */ + /* USER CODE END USART6:USART3_4_5_6_LPUART1_IRQn disable */ - /* USER CODE BEGIN USART6_MspDeInit 1 */ + /* USER CODE BEGIN USART6_MspDeInit 1 */ - /* USER CODE END USART6_MspDeInit 1 */ - } + /* USER CODE END USART6_MspDeInit 1 */ + } } /* USER CODE BEGIN 1 */ diff --git a/Core/Src/wwdg.c b/Core/Src/wwdg.c index a65ee76..ec14ed7 100644 --- a/Core/Src/wwdg.c +++ b/Core/Src/wwdg.c @@ -27,50 +27,50 @@ WWDG_HandleTypeDef hwwdg; /* WWDG init function */ -void MX_WWDG_Init(void) +void MX_WWDG_Init (void) { - /* USER CODE BEGIN WWDG_Init 0 */ + /* USER CODE BEGIN WWDG_Init 0 */ - /* USER CODE END WWDG_Init 0 */ + /* USER CODE END WWDG_Init 0 */ - /* USER CODE BEGIN WWDG_Init 1 */ + /* USER CODE BEGIN WWDG_Init 1 */ - /* USER CODE END WWDG_Init 1 */ - hwwdg.Instance = WWDG; - hwwdg.Init.Prescaler = WWDG_PRESCALER_1; - hwwdg.Init.Window = 64; - hwwdg.Init.Counter = 64; - hwwdg.Init.EWIMode = WWDG_EWI_DISABLE; - if (HAL_WWDG_Init(&hwwdg) != HAL_OK) - { - Error_Handler(); - } - /* USER CODE BEGIN WWDG_Init 2 */ + /* USER CODE END WWDG_Init 1 */ + hwwdg.Instance = WWDG; + hwwdg.Init.Prescaler = WWDG_PRESCALER_1; + hwwdg.Init.Window = 64; + hwwdg.Init.Counter = 64; + hwwdg.Init.EWIMode = WWDG_EWI_DISABLE; + if (HAL_WWDG_Init (&hwwdg) != HAL_OK) + { + Error_Handler(); + } + /* USER CODE BEGIN WWDG_Init 2 */ - /* USER CODE END WWDG_Init 2 */ + /* USER CODE END WWDG_Init 2 */ } -void HAL_WWDG_MspInit(WWDG_HandleTypeDef* wwdgHandle) +void HAL_WWDG_MspInit (WWDG_HandleTypeDef* wwdgHandle) { - if(wwdgHandle->Instance==WWDG) - { - /* USER CODE BEGIN WWDG_MspInit 0 */ + if (wwdgHandle->Instance == WWDG) + { + /* USER CODE BEGIN WWDG_MspInit 0 */ - /* USER CODE END WWDG_MspInit 0 */ - /* WWDG clock enable */ - __HAL_RCC_WWDG_CLK_ENABLE(); - /* USER CODE BEGIN WWDG_MspInit 1 */ + /* USER CODE END WWDG_MspInit 0 */ + /* WWDG clock enable */ + __HAL_RCC_WWDG_CLK_ENABLE(); + /* USER CODE BEGIN WWDG_MspInit 1 */ - /* USER CODE END WWDG_MspInit 1 */ - } + /* USER CODE END WWDG_MspInit 1 */ + } } /* USER CODE BEGIN 1 */ -void MX_WWDG_Relad(void) +void MX_WWDG_Relad (void) { - HAL_WWDG_Refresh(&hwwdg); + HAL_WWDG_Refresh (&hwwdg); } /* USER CODE END 1 */ diff --git a/GB01VETx.ioc b/GB01VETx.ioc index 82ca368..1558e50 100644 --- a/GB01VETx.ioc +++ b/GB01VETx.ioc @@ -143,31 +143,32 @@ Mcu.Pin45=PD3 Mcu.Pin46=PF12 Mcu.Pin47=PF13 Mcu.Pin48=PB4 -Mcu.Pin49=PE0 +Mcu.Pin49=PB5 Mcu.Pin5=PE6 -Mcu.Pin50=PE1 -Mcu.Pin51=PE2 -Mcu.Pin52=PE3 -Mcu.Pin53=PB6 -Mcu.Pin54=PB7 -Mcu.Pin55=PB8 -Mcu.Pin56=VP_ADC1_TempSens_Input -Mcu.Pin57=VP_CRC_VS_CRC -Mcu.Pin58=VP_IWDG_VS_IWDG -Mcu.Pin59=VP_RTC_VS_RTC_Activate +Mcu.Pin50=PE0 +Mcu.Pin51=PE1 +Mcu.Pin52=PE2 +Mcu.Pin53=PE3 +Mcu.Pin54=PB6 +Mcu.Pin55=PB7 +Mcu.Pin56=PB8 +Mcu.Pin57=VP_ADC1_TempSens_Input +Mcu.Pin58=VP_CRC_VS_CRC +Mcu.Pin59=VP_IWDG_VS_IWDG Mcu.Pin6=PC12 -Mcu.Pin60=VP_SYS_VS_tim2 -Mcu.Pin61=VP_SYS_VS_DBSignals -Mcu.Pin62=VP_TIM6_VS_ClockSourceINT -Mcu.Pin63=VP_TIM7_VS_ClockSourceINT -Mcu.Pin64=VP_TIM14_VS_ClockSourceINT -Mcu.Pin65=VP_WWDG_VS_WWDG -Mcu.Pin66=VP_RealThread.RT-Thread_VS_RTOSJjkernel_3.1.5_3.1.5 -Mcu.Pin67=VP_RealThread.RT-Thread_VS_RTOSJjdevice_3.1.5_3.1.5 +Mcu.Pin60=VP_RTC_VS_RTC_Activate +Mcu.Pin61=VP_SYS_VS_tim2 +Mcu.Pin62=VP_SYS_VS_DBSignals +Mcu.Pin63=VP_TIM6_VS_ClockSourceINT +Mcu.Pin64=VP_TIM7_VS_ClockSourceINT +Mcu.Pin65=VP_TIM14_VS_ClockSourceINT +Mcu.Pin66=VP_WWDG_VS_WWDG +Mcu.Pin67=VP_RealThread.RT-Thread_VS_RTOSJjkernel_3.1.5_3.1.5 +Mcu.Pin68=VP_RealThread.RT-Thread_VS_RTOSJjdevice_3.1.5_3.1.5 Mcu.Pin7=PC13 Mcu.Pin8=PC14-OSC32_IN (PC14) Mcu.Pin9=PC15-OSC32_OUT (PC15) -Mcu.PinsNb=68 +Mcu.PinsNb=69 Mcu.ThirdParty0=RealThread.RT-Thread.3.1.5 Mcu.ThirdPartyNb=1 Mcu.UserConstants= @@ -275,6 +276,10 @@ PB4.GPIOParameters=GPIO_Label PB4.GPIO_Label=PWM_CH1 PB4.Locked=true PB4.Signal=S_TIM3_CH1 +PB5.GPIOParameters=GPIO_Label +PB5.GPIO_Label=LOCK +PB5.Locked=true +PB5.Signal=GPIO_Output PB6.GPIOParameters=GPIO_Label PB6.GPIO_Label=S4852_TX PB6.Locked=true @@ -497,7 +502,7 @@ RCC.USART3Freq_Value=64000000 RCC.USBFreq_Value=48000000 RCC.VCOInputFreq_Value=8000000 RCC.VCOOutputFreq_Value=128000000 -RealThread.RT-Thread.3.1.5.IPParameters=RT_MAIN_THREAD_STACK_SIZE,RT_USING_EVENT,RT_USING_MAILBOX,RT_USING_MESSAGEQUEUE,RT_USING_HEAP,RTOSJjkernel,RTOSJjdevice +RealThread.RT-Thread.3.1.5.IPParameters=RT_MAIN_THREAD_STACK_SIZE,RT_USING_EVENT,RT_USING_MAILBOX,RT_USING_MESSAGEQUEUE,RT_USING_HEAP,RT_USING_MUTEX,RTOSJjkernel,RTOSJjdevice RealThread.RT-Thread.3.1.5.RTOSJjdevice=true RealThread.RT-Thread.3.1.5.RTOSJjdevice_Checked=true RealThread.RT-Thread.3.1.5.RTOSJjkernel=true @@ -508,6 +513,7 @@ RealThread.RT-Thread.3.1.5.RT_USING_EVENT=1 RealThread.RT-Thread.3.1.5.RT_USING_HEAP=1 RealThread.RT-Thread.3.1.5.RT_USING_MAILBOX=1 RealThread.RT-Thread.3.1.5.RT_USING_MESSAGEQUEUE=1 +RealThread.RT-Thread.3.1.5.RT_USING_MUTEX=1 RealThread.RT-Thread.3.1.5_SwParameter=RTOSJjkernel\:true;RTOSJjshell\:true;RTOSJjdevice\:true; SH.COMP_DAC12_group.0=DAC1_OUT2 SH.COMP_DAC12_group.ConfNb=1 diff --git a/MDK-ARM/.rtt-studio/makefile.targets b/MDK-ARM/.rtt-studio/makefile.targets new file mode 100644 index 0000000..b8b6aa1 --- /dev/null +++ b/MDK-ARM/.rtt-studio/makefile.targets @@ -0,0 +1,14 @@ +RM := rm -rf +BRIDGE_EXE := studio-mdk-bridge.exe +UV4_EXE := "C:\Keil_v5\UV4\UV4.exe" +UVPROJX_LOC := "J:\add_by_zhangpeng\Project\SLUICE\Sluice\GB0VETx\g0b1vetx-board\MDK-ARM\GB01VETx.uvprojx" + +.PHONY: mdk_all + +mdk_all: + -$(BRIDGE_EXE) --build --uv4-path $(UV4_EXE) $(UVPROJX_LOC) + +mdk_clean: + -@$(RM) * + @echo 'success' + diff --git a/MDK-ARM/GB01VETx.uvguix.Memory b/MDK-ARM/GB01VETx.uvguix.Memory index b3a9695..650e83c 100644 --- a/MDK-ARM/GB01VETx.uvguix.Memory +++ b/MDK-ARM/GB01VETx.uvguix.Memory @@ -97,17 +97,17 @@ -1 - 210 - -47 - 1393 - 969 + 337 + 2503 + 3943 + 1096 0 - 1746 - 0100000004000000010000000100000001000000010000000000000002000000000000000100000001000000000000002800000028000000010000000B0000000100000001000000874A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C636F6D706F6E656E74735C6465766963655C6465766963652E6300000000086465766963652E6300000000C5D4F200FFFFFFFF594A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C52542D5468726561645C7274636F6E6669672E68000000000A7274636F6E6669672E6800000000FFDC7800FFFFFFFF904A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C6273705C5F74656D706C6174655C637562656D785F636F6E6669675C626F6172642E630000000007626F6172642E6300000000BECEA100FFFFFFFF794A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C447269766572735C53544D3332473078785F48414C5F4472697665725C496E635C73746D3332673078785F68616C5F6465662E68000000001373746D3332673078785F68616C5F6465662E6800000000F0A0A100FFFFFFFF544A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C436F72655C5372635C6D61696E2E6300000000066D61696E2E6300000000BCA8E100FFFFFFFF624A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C4D444B2D41524D5C737461727475705F73746D33326730623178782E730000000015737461727475705F73746D33326730623178782E73000000009CC1B600FFFFFFFF7D4A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C7372635C636F6D706F6E656E74732E63000000000C636F6D706F6E656E74732E6300000000F7B88600FFFFFFFF7E4A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C66696E73685C66696E73685F6170692E68000000000B66696E73685F6170692E6800000000D9ADC200FFFFFFFF774A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C7372635C69646C652E63000000000669646C652E6300000000A5C2D700FFFFFFFF554A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C436F72655C5372635C75736172742E63000000000775736172742E6300000000B3A6BE00FFFFFFFF814A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745CB2E2BFD8D2BBCCE5D5A25C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C66696E73685C66696E73685F636F6E6669672E68000000000E66696E73685F636F6E6669672E6800000000EAD6A300FFFFFFFF0100000010000000C5D4F200FFDC7800BECEA100F0A0A100BCA8E1009CC1B600F7B88600D9ADC200A5C2D700B3A6BE00EAD6A300F6FA7D00B5E99D005FC3CF00C1838300CACAD500010000000000000002000000480100006600000080070000D8020000 + 1394 + 010000000400000001000000010000000100000001000000000000000200000000000000010000000100000000000000280000002800000001000000090000000400000001000000834A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745C534C554943455C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C636F6D706F6E656E74735C6465766963655C6465766963652E6300000000086465766963652E6300000000C5D4F200FFFFFFFF554A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745C534C554943455C536C756963655C474230564554785C67306231766574782D626F6172645C52542D5468726561645C7274636F6E6669672E68000000000A7274636F6E6669672E6800000000FFDC7800FFFFFFFF8C4A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745C534C554943455C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C6273705C5F74656D706C6174655C637562656D785F636F6E6669675C626F6172642E630000000007626F6172642E6300000000BECEA100FFFFFFFF754A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745C534C554943455C536C756963655C474230564554785C67306231766574782D626F6172645C447269766572735C53544D3332473078785F48414C5F4472697665725C496E635C73746D3332673078785F68616C5F6465662E68000000001373746D3332673078785F68616C5F6465662E6800000000F0A0A100FFFFFFFF504A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745C534C554943455C536C756963655C474230564554785C67306231766574782D626F6172645C436F72655C5372635C6D61696E2E6300000000066D61696E2E6300000000BCA8E100FFFFFFFF5E4A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745C534C554943455C536C756963655C474230564554785C67306231766574782D626F6172645C4D444B2D41524D5C737461727475705F73746D33326730623178782E730000000015737461727475705F73746D33326730623178782E73000000009CC1B600FFFFFFFF794A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745C534C554943455C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C7372635C636F6D706F6E656E74732E63000000000C636F6D706F6E656E74732E6300000000F7B88600FFFFFFFF734A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745C534C554943455C536C756963655C474230564554785C67306231766574782D626F6172645C4D6964646C6577617265735C54686972645F50617274795C5265616C5468726561645F52544F535C7372635C69646C652E63000000000669646C652E6300000000D9ADC200FFFFFFFF514A3A5C6164645F62795F7A68616E6770656E675C50726F6A6563745C534C554943455C536C756963655C474230564554785C67306231766574782D626F6172645C436F72655C5372635C75736172742E63000000000775736172742E6300000000A5C2D700FFFFFFFF0100000010000000C5D4F200FFDC7800BECEA100F0A0A100BCA8E1009CC1B600F7B88600D9ADC200A5C2D700B3A6BE00EAD6A300F6FA7D00B5E99D005FC3CF00C1838300CACAD500010000000000000002000000C808000066000000000F0000D8020000 @@ -130,7 +130,7 @@ 16 - F40000006600000090050000F6000000 + 7408000066000000100D0000F6000000 @@ -1795,14 +1795,14 @@ 3312 - 000000000B000000000000000020000000000000FFFFFFFFFFFFFFFFF4000000DF00000090050000E3000000000000000100000004000000010000000000000000000000FFFFFFFF08000000CB00000057010000CC000000F08B00005A01000079070000D601000045890000FFFF02000B004354616262656450616E650020000000000000F40000006600000090050000F6000000F40000004F00000090050000DF0000000000000040280046080000000B446973617373656D626C7900000000CB00000001000000FFFFFFFFFFFFFFFF14506572666F726D616E636520416E616C797A6572000000005701000001000000FFFFFFFFFFFFFFFF14506572666F726D616E636520416E616C797A657200000000CC00000001000000FFFFFFFFFFFFFFFF0E4C6F67696320416E616C797A657200000000F08B000001000000FFFFFFFFFFFFFFFF0D436F646520436F766572616765000000005A01000001000000FFFFFFFFFFFFFFFF11496E737472756374696F6E205472616365000000007907000001000000FFFFFFFFFFFFFFFF0F53797374656D20416E616C797A657200000000D601000001000000FFFFFFFFFFFFFFFF104576656E742053746174697374696373000000004589000001000000FFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000000000000000000001000000FFFFFFFFCB00000001000000FFFFFFFFCB000000000000000040000000000000FFFFFFFFFFFFFFFF9C0400004F000000A004000029020000000000000200000004000000010000000000000000000000FFFFFFFF2B000000E2050000CA0900002D8C00002E8C00002F8C0000308C0000318C0000328C0000338C0000348C0000358C0000368C0000378C0000388C0000398C00003A8C00003B8C00003C8C00003D8C00003E8C00003F8C0000408C0000418C000050C3000051C3000052C3000053C3000054C3000055C3000056C3000057C3000058C3000059C300005AC300005BC300005CC300005DC300005EC300005FC3000060C3000061C3000062C3000063C3000001800040000000000000A0040000660000009005000040020000A00400004F000000900500002902000000000000404100462B0000000753796D626F6C7300000000E205000001000000FFFFFFFFFFFFFFFF0A5472616365204461746100000000CA09000001000000FFFFFFFFFFFFFFFF00000000002D8C000001000000FFFFFFFFFFFFFFFF00000000002E8C000001000000FFFFFFFFFFFFFFFF00000000002F8C000001000000FFFFFFFFFFFFFFFF0000000000308C000001000000FFFFFFFFFFFFFFFF0000000000318C000001000000FFFFFFFFFFFFFFFF0000000000328C000001000000FFFFFFFFFFFFFFFF0000000000338C000001000000FFFFFFFFFFFFFFFF0000000000348C000001000000FFFFFFFFFFFFFFFF0000000000358C000001000000FFFFFFFFFFFFFFFF0000000000368C000001000000FFFFFFFFFFFFFFFF0000000000378C000001000000FFFFFFFFFFFFFFFF0000000000388C000001000000FFFFFFFFFFFFFFFF0000000000398C000001000000FFFFFFFFFFFFFFFF00000000003A8C000001000000FFFFFFFFFFFFFFFF00000000003B8C000001000000FFFFFFFFFFFFFFFF00000000003C8C000001000000FFFFFFFFFFFFFFFF00000000003D8C000001000000FFFFFFFFFFFFFFFF00000000003E8C000001000000FFFFFFFFFFFFFFFF00000000003F8C000001000000FFFFFFFFFFFFFFFF0000000000408C000001000000FFFFFFFFFFFFFFFF0000000000418C000001000000FFFFFFFFFFFFFFFF000000000050C3000001000000FFFFFFFFFFFFFFFF000000000051C3000001000000FFFFFFFFFFFFFFFF000000000052C3000001000000FFFFFFFFFFFFFFFF000000000053C3000001000000FFFFFFFFFFFFFFFF000000000054C3000001000000FFFFFFFFFFFFFFFF000000000055C3000001000000FFFFFFFFFFFFFFFF000000000056C3000001000000FFFFFFFFFFFFFFFF000000000057C3000001000000FFFFFFFFFFFFFFFF000000000058C3000001000000FFFFFFFFFFFFFFFF000000000059C3000001000000FFFFFFFFFFFFFFFF00000000005AC3000001000000FFFFFFFFFFFFFFFF00000000005BC3000001000000FFFFFFFFFFFFFFFF00000000005CC3000001000000FFFFFFFFFFFFFFFF00000000005DC3000001000000FFFFFFFFFFFFFFFF00000000005EC3000001000000FFFFFFFFFFFFFFFF00000000005FC3000001000000FFFFFFFFFFFFFFFF000000000060C3000001000000FFFFFFFFFFFFFFFF000000000061C3000001000000FFFFFFFFFFFFFFFF000000000062C3000001000000FFFFFFFFFFFFFFFF000000000063C3000001000000FFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000000000000000000001000000FFFFFFFFE205000001000000FFFFFFFFE2050000000000000010000001000000FFFFFFFFFFFFFFFF440100004F00000048010000C102000001000000020000100400000001000000C7FEFFFF3C060000FFFFFFFF05000000ED0300006D000000C3000000C40000007394000001800010000001000000000000006600000044010000D8020000000000004F00000044010000C10200000000000040410056050000000750726F6A65637401000000ED03000001000000FFFFFFFFFFFFFFFF05426F6F6B73010000006D00000001000000FFFFFFFFFFFFFFFF0946756E6374696F6E7301000000C300000001000000FFFFFFFFFFFFFFFF0954656D706C6174657301000000C400000001000000FFFFFFFFFFFFFFFF09526567697374657273000000007394000001000000FFFFFFFFFFFFFFFF00000000000000000000000000000000000000000000000001000000FFFFFFFFED03000001000000FFFFFFFFED030000000000000080000000000000FFFFFFFFFFFFFFFF0000000015020000900500001902000000000000010000000400000001000000000000000000000000000000000000000000000001000000C6000000FFFFFFFF0F0000008F070000930700009407000095070000960700009007000091070000B5010000B801000038030000B9050000BA050000BB050000BC050000CB09000001800080000000000000000000003002000090050000D4020000000000001902000090050000BD02000000000000404100460F0000001343616C6C20537461636B202B204C6F63616C73000000008F07000001000000FFFFFFFFFFFFFFFF0755415254202331000000009307000001000000FFFFFFFFFFFFFFFF0755415254202332000000009407000001000000FFFFFFFFFFFFFFFF0755415254202333000000009507000001000000FFFFFFFFFFFFFFFF15446562756720287072696E74662920566965776572000000009607000001000000FFFFFFFFFFFFFFFF0757617463682031000000009007000001000000FFFFFFFFFFFFFFFF0757617463682032000000009107000001000000FFFFFFFFFFFFFFFF10547261636520457863657074696F6E7300000000B501000001000000FFFFFFFFFFFFFFFF0E4576656E7420436F756E7465727300000000B801000001000000FFFFFFFFFFFFFFFF09554C494E4B706C7573000000003803000001000000FFFFFFFFFFFFFFFF084D656D6F7279203100000000B905000001000000FFFFFFFFFFFFFFFF084D656D6F7279203200000000BA05000001000000FFFFFFFFFFFFFFFF084D656D6F7279203300000000BB05000001000000FFFFFFFFFFFFFFFF084D656D6F7279203400000000BC05000001000000FFFFFFFFFFFFFFFF105472616365204E617669676174696F6E00000000CB09000001000000FFFFFFFFFFFFFFFFFFFFFFFF0000000001000000000000000000000001000000FFFFFFFFC802000019020000CC020000BD02000000000000020000000400000000000000000000000000000000000000000000000000000002000000C6000000FFFFFFFF8F07000001000000FFFFFFFF8F07000001000000C6000000000000000080000001000000FFFFFFFFFFFFFFFF00000000C102000080070000C5020000010000000100001004000000010000004CFDFFFF8E000000FFFFFFFF06000000C5000000C7000000B4010000D2010000CF010000779400000180008000000100000000000000DC02000080070000FD03000000000000C502000080070000E60300000000000040820056060000000C4275696C64204F757470757401000000C500000001000000FFFFFFFFFFFFFFFF0D46696E6420496E2046696C657301000000C700000001000000FFFFFFFFFFFFFFFF0A4572726F72204C69737400000000B401000001000000FFFFFFFFFFFFFFFF0E536F757263652042726F7773657200000000D201000001000000FFFFFFFFFFFFFFFF0E416C6C205265666572656E63657300000000CF01000001000000FFFFFFFFFFFFFFFF0742726F77736572010000007794000001000000FFFFFFFFFFFFFFFF00000000000000000000000000000000000000000000000001000000FFFFFFFFC500000001000000FFFFFFFFC5000000000000000000000000000000 + 000000000B000000000000000020000000000000FFFFFFFFFFFFFFFFF4000000DF00000090050000E3000000000000000100000004000000010000000000000000000000FFFFFFFF08000000CB00000057010000CC000000F08B00005A01000079070000D601000045890000FFFF02000B004354616262656450616E6500200000000000007408000066000000100D0000F6000000F40000004F00000090050000DF0000000000000040280046080000000B446973617373656D626C7900000000CB00000001000000FFFFFFFFFFFFFFFF14506572666F726D616E636520416E616C797A6572000000005701000001000000FFFFFFFFFFFFFFFF14506572666F726D616E636520416E616C797A657200000000CC00000001000000FFFFFFFFFFFFFFFF0E4C6F67696320416E616C797A657200000000F08B000001000000FFFFFFFFFFFFFFFF0D436F646520436F766572616765000000005A01000001000000FFFFFFFFFFFFFFFF11496E737472756374696F6E205472616365000000007907000001000000FFFFFFFFFFFFFFFF0F53797374656D20416E616C797A657200000000D601000001000000FFFFFFFFFFFFFFFF104576656E742053746174697374696373000000004589000001000000FFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000000000000000000001000000FFFFFFFFCB00000001000000FFFFFFFFCB000000000000000040000000000000FFFFFFFFFFFFFFFF9C0400004F000000A004000029020000000000000200000004000000010000000000000000000000FFFFFFFF2B000000E2050000CA0900002D8C00002E8C00002F8C0000308C0000318C0000328C0000338C0000348C0000358C0000368C0000378C0000388C0000398C00003A8C00003B8C00003C8C00003D8C00003E8C00003F8C0000408C0000418C000050C3000051C3000052C3000053C3000054C3000055C3000056C3000057C3000058C3000059C300005AC300005BC300005CC300005DC300005EC300005FC3000060C3000061C3000062C3000063C3000001800040000000000000200C000066000000100D000040020000A00400004F000000900500002902000000000000404100462B0000000753796D626F6C7300000000E205000001000000FFFFFFFFFFFFFFFF0A5472616365204461746100000000CA09000001000000FFFFFFFFFFFFFFFF00000000002D8C000001000000FFFFFFFFFFFFFFFF00000000002E8C000001000000FFFFFFFFFFFFFFFF00000000002F8C000001000000FFFFFFFFFFFFFFFF0000000000308C000001000000FFFFFFFFFFFFFFFF0000000000318C000001000000FFFFFFFFFFFFFFFF0000000000328C000001000000FFFFFFFFFFFFFFFF0000000000338C000001000000FFFFFFFFFFFFFFFF0000000000348C000001000000FFFFFFFFFFFFFFFF0000000000358C000001000000FFFFFFFFFFFFFFFF0000000000368C000001000000FFFFFFFFFFFFFFFF0000000000378C000001000000FFFFFFFFFFFFFFFF0000000000388C000001000000FFFFFFFFFFFFFFFF0000000000398C000001000000FFFFFFFFFFFFFFFF00000000003A8C000001000000FFFFFFFFFFFFFFFF00000000003B8C000001000000FFFFFFFFFFFFFFFF00000000003C8C000001000000FFFFFFFFFFFFFFFF00000000003D8C000001000000FFFFFFFFFFFFFFFF00000000003E8C000001000000FFFFFFFFFFFFFFFF00000000003F8C000001000000FFFFFFFFFFFFFFFF0000000000408C000001000000FFFFFFFFFFFFFFFF0000000000418C000001000000FFFFFFFFFFFFFFFF000000000050C3000001000000FFFFFFFFFFFFFFFF000000000051C3000001000000FFFFFFFFFFFFFFFF000000000052C3000001000000FFFFFFFFFFFFFFFF000000000053C3000001000000FFFFFFFFFFFFFFFF000000000054C3000001000000FFFFFFFFFFFFFFFF000000000055C3000001000000FFFFFFFFFFFFFFFF000000000056C3000001000000FFFFFFFFFFFFFFFF000000000057C3000001000000FFFFFFFFFFFFFFFF000000000058C3000001000000FFFFFFFFFFFFFFFF000000000059C3000001000000FFFFFFFFFFFFFFFF00000000005AC3000001000000FFFFFFFFFFFFFFFF00000000005BC3000001000000FFFFFFFFFFFFFFFF00000000005CC3000001000000FFFFFFFFFFFFFFFF00000000005DC3000001000000FFFFFFFFFFFFFFFF00000000005EC3000001000000FFFFFFFFFFFFFFFF00000000005FC3000001000000FFFFFFFFFFFFFFFF000000000060C3000001000000FFFFFFFFFFFFFFFF000000000061C3000001000000FFFFFFFFFFFFFFFF000000000062C3000001000000FFFFFFFFFFFFFFFF000000000063C3000001000000FFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000000000000000000001000000FFFFFFFFE205000001000000FFFFFFFFE2050000000000000010000001000000FFFFFFFFFFFFFFFF440100004F00000048010000C102000001000000020000100400000001000000C7FEFFFF3C060000FFFFFFFF05000000ED0300006D000000C3000000C400000073940000018000100000010000008007000066000000C4080000D8020000000000004F00000044010000C10200000000000040410056050000000750726F6A65637401000000ED03000001000000FFFFFFFFFFFFFFFF05426F6F6B73010000006D00000001000000FFFFFFFFFFFFFFFF0946756E6374696F6E7301000000C300000001000000FFFFFFFFFFFFFFFF0954656D706C6174657301000000C400000001000000FFFFFFFFFFFFFFFF09526567697374657273000000007394000001000000FFFFFFFFFFFFFFFF00000000000000000000000000000000000000000000000001000000FFFFFFFFED03000001000000FFFFFFFFED030000000000000080000000000000FFFFFFFFFFFFFFFF0000000015020000900500001902000000000000010000000400000001000000000000000000000000000000000000000000000001000000C6000000FFFFFFFF0F0000008F070000930700009407000095070000960700009007000091070000B5010000B801000038030000B9050000BA050000BB050000BC050000CB090000018000800000000000008007000030020000100D0000D4020000000000001902000090050000BD02000000000000404100460F0000001343616C6C20537461636B202B204C6F63616C73000000008F07000001000000FFFFFFFFFFFFFFFF0755415254202331000000009307000001000000FFFFFFFFFFFFFFFF0755415254202332000000009407000001000000FFFFFFFFFFFFFFFF0755415254202333000000009507000001000000FFFFFFFFFFFFFFFF15446562756720287072696E74662920566965776572000000009607000001000000FFFFFFFFFFFFFFFF0757617463682031000000009007000001000000FFFFFFFFFFFFFFFF0757617463682032000000009107000001000000FFFFFFFFFFFFFFFF10547261636520457863657074696F6E7300000000B501000001000000FFFFFFFFFFFFFFFF0E4576656E7420436F756E7465727300000000B801000001000000FFFFFFFFFFFFFFFF09554C494E4B706C7573000000003803000001000000FFFFFFFFFFFFFFFF084D656D6F7279203100000000B905000001000000FFFFFFFFFFFFFFFF084D656D6F7279203200000000BA05000001000000FFFFFFFFFFFFFFFF084D656D6F7279203300000000BB05000001000000FFFFFFFFFFFFFFFF084D656D6F7279203400000000BC05000001000000FFFFFFFFFFFFFFFF105472616365204E617669676174696F6E00000000CB09000001000000FFFFFFFFFFFFFFFFFFFFFFFF0000000001000000000000000000000001000000FFFFFFFFC802000019020000CC020000BD02000000000000020000000400000000000000000000000000000000000000000000000000000002000000C6000000FFFFFFFF8F07000001000000FFFFFFFF8F07000001000000C6000000000000000080000001000000FFFFFFFFFFFFFFFF00000000C102000080070000C5020000010000000100001004000000010000004CFDFFFF8E000000FFFFFFFF06000000C5000000C7000000B4010000D2010000CF010000779400000180008000000100000080070000DC020000000F0000FD03000000000000C502000080070000E60300000000000040820056060000000C4275696C64204F757470757401000000C500000001000000FFFFFFFFFFFFFFFF0D46696E6420496E2046696C657301000000C700000001000000FFFFFFFFFFFFFFFF0A4572726F72204C69737400000000B401000001000000FFFFFFFFFFFFFFFF0E536F757263652042726F7773657200000000D201000001000000FFFFFFFFFFFFFFFF0E416C6C205265666572656E63657300000000CF01000001000000FFFFFFFFFFFFFFFF0742726F77736572010000007794000001000000FFFFFFFFFFFFFFFF00000000000000000000000000000000000000000000000001000000FFFFFFFFC500000001000000FFFFFFFFC5000000000000000000000000000000 59392 File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uild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ebug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iddlewares/Third_Party/RealThread_RTOS/components/device/device.c 26 @@ -3611,9 +3611,9 @@ ../RT-Thread/rtconfig.h - 7 - 122 - 134 + 24 + 119 + 133 1 0 @@ -3638,9 +3638,9 @@ ../Core/Src/main.c - 23 - 124 - 136 + 25 + 199 + 207 1 0 @@ -3663,15 +3663,6 @@ 0 - - J:\add_by_zhangpeng\Project\测控一体闸\Sluice\GB0VETx\g0b1vetx-board\Middlewares\Third_Party\RealThread_RTOS\finsh\finsh_api.h - 0 - 87 - 94 - 1 - - 0 - ../Middlewares/Third_Party/RealThread_RTOS/src/idle.c 26 @@ -3683,22 +3674,13 @@ ../Core/Src/usart.c - 1 + 4 97 98 1 0 - - J:\add_by_zhangpeng\Project\测控一体闸\Sluice\GB0VETx\g0b1vetx-board\Middlewares\Third_Party\RealThread_RTOS\finsh\finsh_config.h - 19 - 1 - 12 - 1 - - 0 - diff --git a/MDK-ARM/GB01VETx.uvoptx b/MDK-ARM/GB01VETx.uvoptx index 66ffb66..b3d6062 100644 --- a/MDK-ARM/GB01VETx.uvoptx +++ b/MDK-ARM/GB01VETx.uvoptx @@ -26,7 +26,7 @@ 0x4 ARM-ADS - 12000000 + 8000000 1 1 @@ -1209,7 +1209,7 @@ Middlewares/RT-Thread/RTOS/device - 1 + 0 0 0 0 diff --git a/MDK-ARM/GB01VETx.uvprojx b/MDK-ARM/GB01VETx.uvprojx index 009fb52..9af12b1 100644 --- a/MDK-ARM/GB01VETx.uvprojx +++ b/MDK-ARM/GB01VETx.uvprojx @@ -1,5 +1,5 @@ - - + + 2.1 @@ -19,28 +19,28 @@ Keil.STM32G0xx_DFP.1.4.0 http://www.keil.com/pack/ IRAM(0x20000000,0x00024000) IROM(0x08000000,0x00080000) CPUTYPE("Cortex-M0+") CLOCK(12000000) ELITTLE - - + + UL2CM3(-S0 -C0 -P0 -FD20000000 -FC8000 -FN1 -FF0STM32G0Bx_512 -FS08000000 -FL080000 -FP0($$Device:STM32G0B1VETx$CMSIS\Flash\STM32G0Bx_512.FLM)) 0 $$Device:STM32G0B1VETx$Drivers\CMSIS\Device\ST\STM32G0xx\Include\stm32g0xx.h - - - - - - - - - + + + + + + + + + $$Device:STM32G0B1VETx$CMSIS\SVD\STM32G0B1.svd 0 0 - - - - - + + + + + 0 0 @@ -62,8 +62,8 @@ 0 0 - - + + 0 0 0 @@ -72,8 +72,8 @@ 0 0 - - + + 0 0 0 @@ -82,15 +82,15 @@ 0 0 - - + + 0 0 0 0 1 - + 0 @@ -104,8 +104,8 @@ 0 0 3 - - + + 0 @@ -114,7 +114,7 @@ DARMCM1.DLL -pCM0+ SARMCM3.DLL - + TARMCM1.DLL -pCM0+ @@ -138,11 +138,11 @@ 1 BIN\UL2CM3.DLL - - - - - + + + + + 0 @@ -175,7 +175,7 @@ 0 0 "Cortex-M0+" - + 0 0 0 @@ -308,7 +308,7 @@ 0x0 - + 1 @@ -335,9 +335,9 @@ 0 0 - + USE_HAL_DRIVER,STM32G0B1xx - + ../Core/Inc;../Drivers/STM32G0xx_HAL_Driver/Inc;../Drivers/STM32G0xx_HAL_Driver/Inc/Legacy;../Drivers/CMSIS/Device/ST/STM32G0xx/Include;../Drivers/CMSIS/Include;../middleware/sfud/inc;../middleware/nr_micro_shell/inc;../middleware/xcmd/inc;../middleware/easyflash/inc;../App;../middleware/easylogger/inc;../Comm;../middleware/fifo;../middleware/at-command/include;../middleware/softimer;../RT-Thread;../Middlewares/Third_Party/RealThread_RTOS/include/;../Middlewares/Third_Party/RealThread_RTOS/bsp/_template/cubemx_config @@ -353,10 +353,10 @@ 0 0 - - - - + + + + @@ -366,20 +366,247 @@ 0 1 0 - - - - - - - - - + + + + + + + + + - Application/User/Coremain.c1../Core/Src/main.cgpio.c1../Core/Src/gpio.cadc.c1../Core/Src/adc.ccrc.c1../Core/Src/crc.cdma.c1../Core/Src/dma.c200001222211120222222220222220022222iwdg.c1../Core/Src/iwdg.cusart.c1../Core/Src/usart.crtc.c1../Core/Src/rtc.cspi.c1../Core/Src/spi.c200001222211120222222220222220022222tim.c1../Core/Src/tim.cwwdg.c1../Core/Src/wwdg.cstm32g0xx_it.c1../Core/Src/stm32g0xx_it.cstm32g0xx_hal_msp.c1../Core/Src/stm32g0xx_hal_msp.cstm32g0xx_hal_timebase_tim.c1../Core/Src/stm32g0xx_hal_timebase_tim.c200001222211120222222220222220022222 + + Application/User/Core + + + main.c + 1 + ../Core/Src/main.c + + + gpio.c + 1 + ../Core/Src/gpio.c + + + adc.c + 1 + ../Core/Src/adc.c + + + crc.c + 1 + ../Core/Src/crc.c + + + dma.c + 1 + ../Core/Src/dma.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + iwdg.c + 1 + ../Core/Src/iwdg.c + + + usart.c + 1 + ../Core/Src/usart.c + + + rtc.c + 1 + ../Core/Src/rtc.c + + + spi.c + 1 + ../Core/Src/spi.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + tim.c + 1 + ../Core/Src/tim.c + + + wwdg.c + 1 + ../Core/Src/wwdg.c + + + stm32g0xx_it.c + 1 + ../Core/Src/stm32g0xx_it.c + + + stm32g0xx_hal_msp.c + 1 + ../Core/Src/stm32g0xx_hal_msp.c + + + stm32g0xx_hal_timebase_tim.c + 1 + ../Core/Src/stm32g0xx_hal_timebase_tim.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + midderware/sfud @@ -465,42 +692,1498 @@ - Drivers/CMSISstartup_stm32g0b1xx.s2.\startup_stm32g0b1xx.ssystem_stm32g0xx.c1../Core/Src/system_stm32g0xx.c - Drivers/STM32G0xx_HAL_Driverstm32g0xx_hal_adc.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_adc.cstm32g0xx_hal_adc_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_adc_ex.cstm32g0xx_ll_adc.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_ll_adc.cstm32g0xx_hal_rcc.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_rcc.cstm32g0xx_hal_rcc_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_rcc_ex.cstm32g0xx_ll_rcc.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_ll_rcc.cstm32g0xx_hal_flash.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_flash.cstm32g0xx_hal_flash_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_flash_ex.cstm32g0xx_hal_gpio.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_gpio.cstm32g0xx_hal_dma.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_dma.cstm32g0xx_hal_dma_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_dma_ex.cstm32g0xx_ll_dma.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_ll_dma.cstm32g0xx_hal_pwr.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_pwr.cstm32g0xx_hal_pwr_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_pwr_ex.cstm32g0xx_hal_cortex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_cortex.cstm32g0xx_hal.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal.cstm32g0xx_hal_exti.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_exti.cstm32g0xx_hal_crc.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_crc.cstm32g0xx_hal_crc_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_crc_ex.cstm32g0xx_hal_iwdg.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_iwdg.cstm32g0xx_hal_uart.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_uart.cstm32g0xx_hal_uart_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_uart_ex.cstm32g0xx_hal_rtc.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_rtc.cstm32g0xx_hal_rtc_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_rtc_ex.cstm32g0xx_hal_spi.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_spi.c200001222211120222222220222220022222stm32g0xx_hal_spi_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_spi_ex.c200001222211120222222220222220022222stm32g0xx_hal_tim.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_tim.cstm32g0xx_hal_tim_ex.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_tim_ex.cstm32g0xx_hal_wwdg.c1../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_wwdg.c + + Drivers/CMSIS + + + startup_stm32g0b1xx.s + 2 + .\startup_stm32g0b1xx.s + + + system_stm32g0xx.c + 1 + ../Core/Src/system_stm32g0xx.c + + + + + Drivers/STM32G0xx_HAL_Driver + + + stm32g0xx_hal_adc.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_adc.c + + + stm32g0xx_hal_adc_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_adc_ex.c + + + stm32g0xx_ll_adc.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_ll_adc.c + + + stm32g0xx_hal_rcc.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_rcc.c + + + stm32g0xx_hal_rcc_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_rcc_ex.c + + + stm32g0xx_ll_rcc.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_ll_rcc.c + + + stm32g0xx_hal_flash.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_flash.c + + + stm32g0xx_hal_flash_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_flash_ex.c + + + stm32g0xx_hal_gpio.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_gpio.c + + + stm32g0xx_hal_dma.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_dma.c + + + stm32g0xx_hal_dma_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_dma_ex.c + + + stm32g0xx_ll_dma.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_ll_dma.c + + + stm32g0xx_hal_pwr.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_pwr.c + + + stm32g0xx_hal_pwr_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_pwr_ex.c + + + stm32g0xx_hal_cortex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_cortex.c + + + stm32g0xx_hal.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal.c + + + stm32g0xx_hal_exti.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_exti.c + + + stm32g0xx_hal_crc.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_crc.c + + + stm32g0xx_hal_crc_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_crc_ex.c + + + stm32g0xx_hal_iwdg.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_iwdg.c + + + stm32g0xx_hal_uart.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_uart.c + + + stm32g0xx_hal_uart_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_uart_ex.c + + + stm32g0xx_hal_rtc.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_rtc.c + + + stm32g0xx_hal_rtc_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_rtc_ex.c + + + stm32g0xx_hal_spi.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_spi.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + stm32g0xx_hal_spi_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_spi_ex.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + stm32g0xx_hal_tim.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_tim.c + + + stm32g0xx_hal_tim_ex.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_tim_ex.c + + + stm32g0xx_hal_wwdg.c + 1 + ../Drivers/STM32G0xx_HAL_Driver/Src/stm32g0xx_hal_wwdg.c + + + Board - - + + Middlewares/RT-Thread/RTOS/kernel + + + 0 + 0 + 0 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 4 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + context_rvds.S + 2 + ../Middlewares/Third_Party/RealThread_RTOS/libcpu/arm/cortex-m0/context_rvds.S + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + clock.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/clock.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + components.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/components.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + cpu.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/cpu.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + idle.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/idle.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + ipc.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/ipc.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + irq.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/irq.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + kservice.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/kservice.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + mem.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/mem.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + memheap.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/memheap.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + mempool.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/mempool.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + object.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/object.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + scheduler.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/scheduler.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + slab.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/slab.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + thread.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/thread.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + timer.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/src/timer.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + cpuport.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/libcpu/arm/cortex-m0/cpuport.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + board.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/bsp/_template/cubemx_config/board.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + + + Middlewares/RT-Thread/RTOS/device + + + 0 + 0 + 0 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 4 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + device.c + 1 + ../Middlewares/Third_Party/RealThread_RTOS/components/device/device.c + + + 2 + 0 + 0 + 0 + 0 + 1 + 2 + 2 + 2 + 2 + 11 + + + 1 + + + + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 0 + 2 + 2 + 2 + 2 + 2 + 0 + 0 + 2 + 2 + 2 + 2 + 2 + + + + + + + + + + + + ::CMSIS - Middlewares/RT-Thread/RTOS/kernel00000222221112022222222422222002222222222222212000012222111202222222202222200222222222222221context_rvds.S2../Middlewares/Third_Party/RealThread_RTOS/libcpu/arm/cortex-m0/context_rvds.S2000012222111202222222202222200222222222222221clock.c1../Middlewares/Third_Party/RealThread_RTOS/src/clock.c2000012222111202222222202222200222222222222221components.c1../Middlewares/Third_Party/RealThread_RTOS/src/components.c2000012222111202222222202222200222222222222221cpu.c1../Middlewares/Third_Party/RealThread_RTOS/src/cpu.c2000012222111202222222202222200222222222222221idle.c1../Middlewares/Third_Party/RealThread_RTOS/src/idle.c2000012222111202222222202222200222222222222221ipc.c1../Middlewares/Third_Party/RealThread_RTOS/src/ipc.c2000012222111202222222202222200222222222222221irq.c1../Middlewares/Third_Party/RealThread_RTOS/src/irq.c2000012222111202222222202222200222222222222221kservice.c1../Middlewares/Third_Party/RealThread_RTOS/src/kservice.c2000012222111202222222202222200222222222222221mem.c1../Middlewares/Third_Party/RealThread_RTOS/src/mem.c2000012222111202222222202222200222222222222221memheap.c1../Middlewares/Third_Party/RealThread_RTOS/src/memheap.c2000012222111202222222202222200222222222222221mempool.c1../Middlewares/Third_Party/RealThread_RTOS/src/mempool.c2000012222111202222222202222200222222222222221object.c1../Middlewares/Third_Party/RealThread_RTOS/src/object.c2000012222111202222222202222200222222222222221scheduler.c1../Middlewares/Third_Party/RealThread_RTOS/src/scheduler.c2000012222111202222222202222200222222222222221slab.c1../Middlewares/Third_Party/RealThread_RTOS/src/slab.c2000012222111202222222202222200222222222222221thread.c1../Middlewares/Third_Party/RealThread_RTOS/src/thread.c2000012222111202222222202222200222222222222221timer.c1../Middlewares/Third_Party/RealThread_RTOS/src/timer.c2000012222111202222222202222200222222222222221cpuport.c1../Middlewares/Third_Party/RealThread_RTOS/libcpu/arm/cortex-m0/cpuport.c2000012222111202222222202222200222222222222221board.c1../Middlewares/Third_Party/RealThread_RTOS/bsp/_template/cubemx_config/board.c2000012222111202222222202222200222222222222221Middlewares/RT-Thread/RTOS/device00000222221112022222222422222002222222222222212000012222111202222222202222200222222222222221device.c1../Middlewares/Third_Party/RealThread_RTOS/components/device/device.c2000012222111202222222202222200222222222222221 + - + - + - + RTE\Device\STM32G0B1VETx\startup_stm32g0b1xx.s - - - - - - RTE\Device\STM32G0B1VETx\system_stm32g0xx.c - - - + + + diff --git a/MDK-ARM/startup_stm32g0b1xx.s b/MDK-ARM/startup_stm32g0b1xx.s index 396a059..1f29a62 100644 --- a/MDK-ARM/startup_stm32g0b1xx.s +++ b/MDK-ARM/startup_stm32g0b1xx.s @@ -29,7 +29,7 @@ ; Stack Size (in Bytes) <0x0-0xFFFFFFFF:8> ; -Stack_Size EQU 0x00001000 +Stack_Size EQU 0x2000 AREA STACK, NOINIT, READWRITE, ALIGN=3 Stack_Mem SPACE Stack_Size @@ -40,7 +40,7 @@ __initial_sp ; Heap Size (in Bytes) <0x0-0xFFFFFFFF:8> ; -Heap_Size EQU 0x00001000 +Heap_Size EQU 0x2000 AREA HEAP, NOINIT, READWRITE, ALIGN=3 __heap_base diff --git a/Middlewares/Third_Party/RealThread_RTOS/bsp/_template/cubemx_config/board.c b/Middlewares/Third_Party/RealThread_RTOS/bsp/_template/cubemx_config/board.c index 02a3311..2d1a0fa 100644 --- a/Middlewares/Third_Party/RealThread_RTOS/bsp/_template/cubemx_config/board.c +++ b/Middlewares/Third_Party/RealThread_RTOS/bsp/_template/cubemx_config/board.c @@ -12,13 +12,14 @@ #include #include "main.h" +#include "data.h" #if defined(RT_USING_USER_MAIN) && defined(RT_USING_HEAP) /* * Please modify RT_HEAP_SIZE if you enable RT_USING_HEAP * the RT_HEAP_SIZE max value = (sram size - ZI size), 1024 means 1024 bytes */ -#define RT_HEAP_SIZE (15*1024) +#define RT_HEAP_SIZE (30*1024) static rt_uint8_t rt_heap[RT_HEAP_SIZE]; RT_WEAK void *rt_heap_begin_get(void) @@ -93,6 +94,11 @@ INIT_BOARD_EXPORT(uart_init); void rt_hw_console_output(const char *str) { + + if (g_ifconfig == 1) + { + return ; + } rt_size_t i = 0, size = 0; char a = '\r'; @@ -108,6 +114,7 @@ void rt_hw_console_output(const char *str) } HAL_UART_Transmit(&UartHandle, (uint8_t *)(str + i), 1, 1); } + } #endif diff --git a/Project/g0b1vetx-sluice b/Project/g0b1vetx-sluice new file mode 160000 index 0000000..38d2e6b --- /dev/null +++ b/Project/g0b1vetx-sluice @@ -0,0 +1 @@ +Subproject commit 38d2e6b239cf12f35cc10a3b03de211c06d34aad diff --git a/RT-Thread/rtconfig.h b/RT-Thread/rtconfig.h index c464726..a19976e 100644 --- a/RT-Thread/rtconfig.h +++ b/RT-Thread/rtconfig.h @@ -88,7 +88,7 @@ // Using Mutex // Using Mutex -//#define RT_USING_MUTEX +#define RT_USING_MUTEX // // Using Event @@ -136,7 +136,7 @@ // the buffer size of console <1-1024> // the buffer size of console // Default: 128 (128Byte) -#define RT_CONSOLEBUF_SIZE 128 +#define RT_CONSOLEBUF_SIZE 1024 // // Enable FinSH Configuration diff --git a/middleware/Util/util.c b/middleware/Util/util.c index bdf0ce7..812476f 100644 --- a/middleware/Util/util.c +++ b/middleware/Util/util.c @@ -1,7 +1,7 @@ #include "util.h" +#include - -float Bytes2Float(char * data) +float Bytes2Float (char * data) { Float ff ; ff.byte[0] = data[1]; @@ -11,6 +11,85 @@ float Bytes2Float(char * data) return ff.data; } +uint32_t Bytes2Int (char * data) +{ + Int I; + I.byte[0] = data[1]; + I.byte[1] = data[0]; + I.byte[2] = data[3]; + I.byte[3] = data[2]; + return I.data; +} + + +// ----------------------------------------------------------------- +// º¯Êý¹¦ÄÜ: hex×Ö·û´®×ªbyteÊý×é +// º¯ÊýÃû³Æ: hexbyte_to_hex_str +// ²ÎÊý1 : src Ô´×Ö·û´® +// ²ÎÊý2 : obj Ä¿±ê×Ö½ÚÊý×é +// ˵Ã÷ : "01020304" --> {0x01,0x03,0x03,x04} »ò "01 02 03 04"->{0x01,0x03,0x03,x04} +// ·µ»ØÖµ : 1 ³É¹¦ +// ----------------------------------------------------------------- +int hexstr_to_hexbyte (char *src, char *obj, uint16_t length) +{ + char h1, h2; + uint8_t s1, s2; + int i; + length = length / 2; + for (i = 0; i < length; i++) + { + h1 = src[2 * i]; + h2 = src[2 * i + 1]; + + s1 = toupper (h1) - 0x30; + if (s1 > 9) + s1 -= 7; + s2 = toupper (h2) - 0x30; + if (s2 > 9) + s2 -= 7; + obj[i] = s1 * 16 + s2; + } + return length; +} + + +// 754 תfloat +float float_to_iee754 (float ff1,char * data) +{ + Float ff; + ff.data = ff1; + data[0] = ff.byte[3]; + data[1] = ff.byte[2]; + data[2] = ff.byte[1]; + data[3] = ff.byte[0]; + + return ff.data; +} + + + +// 754 תfloat +float iee754_to_float (char * data) +{ + Float ff; + ff.byte[3] = data[0]; + ff.byte[2] = data[1]; + ff.byte[1] = data[2]; + ff.byte[0] = data[3]; + return ff.data; +} + + + +uint32_t byte_to_Inverse(char * data) +{ + Int I; + I.byte[0] = data[3]; + I.byte[1] = data[2]; + I.byte[2] = data[1]; + I.byte[3] = data[0]; + return I.data; +} diff --git a/middleware/Util/util.h b/middleware/Util/util.h index 9f5e29b..4b1a5d1 100644 --- a/middleware/Util/util.h +++ b/middleware/Util/util.h @@ -3,18 +3,26 @@ #include -typedef union { +typedef union +{ uint32_t data; char byte[4]; } Int; -typedef union { +typedef union +{ float data; char byte[4]; } Float; -float Bytes2Float(char * data); +float Bytes2Float (char * data); +uint32_t Bytes2Int (char * data); +int hexstr_to_hexbyte (char *src, char *obj, uint16_t length); +float iee754_to_float (char * data); +uint32_t byte_to_Inverse(char * data); +// 754 תfloat +float float_to_iee754 (float ff1,char * data); -#endif +#endif diff --git a/middleware/cjson/cjson-master/cjson-master/cJSON.c b/middleware/cjson/cjson-master/cjson-master/cJSON.c new file mode 100644 index 0000000..72a1af3 --- /dev/null +++ b/middleware/cjson/cjson-master/cjson-master/cJSON.c @@ -0,0 +1,3116 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +/* cJSON */ +/* JSON parser in C. */ + +/* disable warnings about old C89 functions in MSVC */ +#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) +#define _CRT_SECURE_NO_DEPRECATE +#endif + +#ifdef __GNUC__ +#pragma GCC visibility push(default) +#endif +#if defined(_MSC_VER) +#pragma warning (push) +/* disable warning about single line comments in system headers */ +#pragma warning (disable : 4001) +#endif + +#include +#include +#include +#include +#include +#include +#include + +#ifdef ENABLE_LOCALES +#include +#endif + +#if defined(_MSC_VER) +#pragma warning (pop) +#endif +#ifdef __GNUC__ +#pragma GCC visibility pop +#endif + +#include "cJSON.h" +// ƽ̨֧³ÖÍ·Îļþ +#include + +/* define our own boolean type */ +#ifdef true +#undef true +#endif +#define true ((cJSON_bool)1) + +#ifdef false +#undef false +#endif +#define false ((cJSON_bool)0) + +/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */ +#ifndef isinf +#define isinf(d) (isnan((d - d)) && !isnan(d)) +#endif +#ifndef isnan +#define isnan(d) (d != d) +#endif + +#ifndef NAN +#ifdef _WIN32 +#define NAN sqrt(-1.0) +#else +#define NAN 0.0/0.0 +#endif +#endif + +typedef struct { + const unsigned char *json; + size_t position; +} error; +static error global_error = { NULL, 0 }; + +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) +{ + return (const char*) (global_error.json + global_error.position); +} + +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item) +{ + if (!cJSON_IsString(item)) + { + return NULL; + } + + return item->valuestring; +} + +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item) +{ + if (!cJSON_IsNumber(item)) + { + return (double) NAN; + } + + return item->valuedouble; +} + +/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ +#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 15) + #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. +#endif + +char* cJSON_Version(void) +{ + static char version[15]; + sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH); + + return version; +} + +/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */ +static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) +{ + if ((string1 == NULL) || (string2 == NULL)) + { + return 1; + } + + if (string1 == string2) + { + return 0; + } + + for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) + { + if (*string1 == '\0') + { + return 0; + } + } + + return tolower(*string1) - tolower(*string2); +} + +typedef struct internal_hooks +{ + void *(CJSON_CDECL *allocate)(rt_size_t size); + void (CJSON_CDECL *deallocate)(void *pointer); + void *(CJSON_CDECL *reallocate)(void *pointer, rt_size_t size); +} internal_hooks; + +#if defined(_MSC_VER) +/* work around MSVC error C2322: '...' address of dllimport '...' is not static */ +static void * CJSON_CDECL internal_malloc(size_t size) +{ + return malloc(size); +} +static void CJSON_CDECL internal_free(void *pointer) +{ + free(pointer); +} +static void * CJSON_CDECL internal_realloc(void *pointer, size_t size) +{ + return realloc(pointer, size); +} +#else +#define internal_malloc malloc +#define internal_free free +#define internal_realloc realloc +#endif + +/* strlen of character literals resolved at compile time */ +#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) + +static internal_hooks global_hooks;// = { internal_malloc, internal_free, internal_realloc }; + +static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) +{ + size_t length = 0; + unsigned char *copy = NULL; + + if (string == NULL) + { + return NULL; + } + + length = strlen((const char*)string) + sizeof(""); + copy = (unsigned char*)hooks->allocate(length); + if (copy == NULL) + { + return NULL; + } + memcpy(copy, string, length); + + return copy; +} + +CJSON_PUBLIC(void) cJSON_InitHooks(void) +{ +// if (hooks == NULL) +// { + /* Reset hooks */ + global_hooks.allocate = rt_malloc; + global_hooks.deallocate = rt_free; + global_hooks.reallocate = rt_realloc; + return; + // } + +// global_hooks.allocate = malloc; +// if (hooks->malloc_fn != NULL) +// { +// global_hooks.allocate = hooks->malloc_fn; +// } + +// global_hooks.deallocate = free; +// if (hooks->free_fn != NULL) +// { +// global_hooks.deallocate = hooks->free_fn; +// } + +// /* use realloc only if both free and malloc are used */ +// global_hooks.reallocate = NULL; +// if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) +// { +// global_hooks.reallocate = realloc; +// } +} + +/* Internal constructor. */ +static cJSON *cJSON_New_Item(const internal_hooks * const hooks) +{ + cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); + if (node) + { + memset(node, '\0', sizeof(cJSON)); + } + + return node; +} + +/* Delete a cJSON structure. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) +{ + cJSON *next = NULL; + while (item != NULL) + { + next = item->next; + if (!(item->type & cJSON_IsReference) && (item->child != NULL)) + { + cJSON_Delete(item->child); + } + if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) + { + global_hooks.deallocate(item->valuestring); + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + } + global_hooks.deallocate(item); + item = next; + } +} + +/* get the decimal point character of the current locale */ +static unsigned char get_decimal_point(void) +{ +#ifdef ENABLE_LOCALES + struct lconv *lconv = localeconv(); + return (unsigned char) lconv->decimal_point[0]; +#else + return '.'; +#endif +} + +typedef struct +{ + const unsigned char *content; + size_t length; + size_t offset; + size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ + internal_hooks hooks; +} parse_buffer; + +/* check if the given size is left to read in a given parse buffer (starting with 1) */ +#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) +/* check if the buffer can be accessed at the given index (starting with 0) */ +#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) +#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) +/* get a pointer to the buffer at the position */ +#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) + +/* Parse the input text to generate a number, and populate the result into item. */ +static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) +{ + double number = 0; + unsigned char *after_end = NULL; + unsigned char number_c_string[64]; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; + } + + /* copy the number into a temporary buffer and replace '.' with the decimal point + * of the current locale (for strtod) + * This also takes care of '\0' not necessarily being available for marking the end of the input */ + for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) + { + switch (buffer_at_offset(input_buffer)[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '+': + case '-': + case 'e': + case 'E': + number_c_string[i] = buffer_at_offset(input_buffer)[i]; + break; + + case '.': + number_c_string[i] = decimal_point; + break; + + default: + goto loop_end; + } + } +loop_end: + number_c_string[i] = '\0'; + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + return false; /* parse_error */ + } + + item->valuedouble = number; + + /* use saturation in case of overflow */ + if (number >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)number; + } + + item->type = cJSON_Number; + + input_buffer->offset += (size_t)(after_end - number_c_string); + return true; +} + +/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number) +{ + if (number >= INT_MAX) + { + object->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + object->valueint = INT_MIN; + } + else + { + object->valueint = (int)number; + } + + return object->valuedouble = number; +} + +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring) +{ + char *copy = NULL; + /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */ + if (!(object->type & cJSON_String) || (object->type & cJSON_IsReference)) + { + return NULL; + } + if (strlen(valuestring) <= strlen(object->valuestring)) + { + strcpy(object->valuestring, valuestring); + return object->valuestring; + } + copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks); + if (copy == NULL) + { + return NULL; + } + if (object->valuestring != NULL) + { + cJSON_free(object->valuestring); + } + object->valuestring = copy; + + return copy; +} + +typedef struct +{ + unsigned char *buffer; + size_t length; + size_t offset; + size_t depth; /* current nesting depth (for formatted printing) */ + cJSON_bool noalloc; + cJSON_bool format; /* is this print a formatted print */ + internal_hooks hooks; +} printbuffer; + +/* realloc printbuffer if necessary to have at least "needed" bytes more */ +static unsigned char* ensure(printbuffer * const p, size_t needed) +{ + unsigned char *newbuffer = NULL; + size_t newsize = 0; + + if ((p == NULL) || (p->buffer == NULL)) + { + return NULL; + } + + if ((p->length > 0) && (p->offset >= p->length)) + { + /* make sure that offset is valid */ + return NULL; + } + + if (needed > INT_MAX) + { + /* sizes bigger than INT_MAX are currently not supported */ + return NULL; + } + + needed += p->offset + 1; + if (needed <= p->length) + { + return p->buffer + p->offset; + } + + if (p->noalloc) { + return NULL; + } + + /* calculate new buffer size */ + if (needed > (INT_MAX / 2)) + { + /* overflow of int, use INT_MAX if possible */ + if (needed <= INT_MAX) + { + newsize = INT_MAX; + } + else + { + return NULL; + } + } + else + { + newsize = needed * 2; + } + + if (p->hooks.reallocate != NULL) + { + /* reallocate with realloc if available */ + newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); + if (newbuffer == NULL) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + } + else + { + /* otherwise reallocate manually */ + newbuffer = (unsigned char*)p->hooks.allocate(newsize); + if (!newbuffer) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + + memcpy(newbuffer, p->buffer, p->offset + 1); + p->hooks.deallocate(p->buffer); + } + p->length = newsize; + p->buffer = newbuffer; + + return newbuffer + p->offset; +} + +/* calculate the new length of the string in a printbuffer and update the offset */ +static void update_offset(printbuffer * const buffer) +{ + const unsigned char *buffer_pointer = NULL; + if ((buffer == NULL) || (buffer->buffer == NULL)) + { + return; + } + buffer_pointer = buffer->buffer + buffer->offset; + + buffer->offset += strlen((const char*)buffer_pointer); +} + +/* securely comparison of floating-point variables */ +static cJSON_bool compare_double(double a, double b) +{ + double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); + return (fabs(a - b) <= maxVal * DBL_EPSILON); +} + +/* Render the number nicely from the given item into a string. */ +static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + double d = item->valuedouble; + int length = 0; + size_t i = 0; + unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ + unsigned char decimal_point = get_decimal_point(); + double test = 0.0; + + if (output_buffer == NULL) + { + return false; + } + + /* This checks for NaN and Infinity */ + if (isnan(d) || isinf(d)) + { + length = sprintf((char*)number_buffer, "null"); + } + else if(d == (double)item->valueint) + { + length = sprintf((char*)number_buffer, "%d", item->valueint); + } + else + { + /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ + length = sprintf((char*)number_buffer, "%1.15g", d); + + /* Check whether the original double can be recovered */ + if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) + { + /* If not, print with 17 decimal places of precision */ + length = sprintf((char*)number_buffer, "%1.17g", d); + } + } + + /* sprintf failed or buffer overrun occurred */ + if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) + { + return false; + } + + /* reserve appropriate space in the output */ + output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); + if (output_pointer == NULL) + { + return false; + } + + /* copy the printed number to the output and replace locale + * dependent decimal point with '.' */ + for (i = 0; i < ((size_t)length); i++) + { + if (number_buffer[i] == decimal_point) + { + output_pointer[i] = '.'; + continue; + } + + output_pointer[i] = number_buffer[i]; + } + output_pointer[i] = '\0'; + + output_buffer->offset += (size_t)length; + + return true; +} + +/* parse 4 digit hexadecimal number */ +static unsigned parse_hex4(const unsigned char * const input) +{ + unsigned int h = 0; + size_t i = 0; + + for (i = 0; i < 4; i++) + { + /* parse digit */ + if ((input[i] >= '0') && (input[i] <= '9')) + { + h += (unsigned int) input[i] - '0'; + } + else if ((input[i] >= 'A') && (input[i] <= 'F')) + { + h += (unsigned int) 10 + input[i] - 'A'; + } + else if ((input[i] >= 'a') && (input[i] <= 'f')) + { + h += (unsigned int) 10 + input[i] - 'a'; + } + else /* invalid */ + { + return 0; + } + + if (i < 3) + { + /* shift left to make place for the next nibble */ + h = h << 4; + } + } + + return h; +} + +/* converts a UTF-16 literal to UTF-8 + * A literal can be one or two sequences of the form \uXXXX */ +static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer) +{ + long unsigned int codepoint = 0; + unsigned int first_code = 0; + const unsigned char *first_sequence = input_pointer; + unsigned char utf8_length = 0; + unsigned char utf8_position = 0; + unsigned char sequence_length = 0; + unsigned char first_byte_mark = 0; + + if ((input_end - first_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + /* get the first utf16 sequence */ + first_code = parse_hex4(first_sequence + 2); + + /* check that the code is valid */ + if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) + { + goto fail; + } + + /* UTF16 surrogate pair */ + if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) + { + const unsigned char *second_sequence = first_sequence + 6; + unsigned int second_code = 0; + sequence_length = 12; /* \uXXXX\uXXXX */ + + if ((input_end - second_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) + { + /* missing second half of the surrogate pair */ + goto fail; + } + + /* get the second utf16 sequence */ + second_code = parse_hex4(second_sequence + 2); + /* check that the code is valid */ + if ((second_code < 0xDC00) || (second_code > 0xDFFF)) + { + /* invalid second half of the surrogate pair */ + goto fail; + } + + + /* calculate the unicode codepoint from the surrogate pair */ + codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); + } + else + { + sequence_length = 6; /* \uXXXX */ + codepoint = first_code; + } + + /* encode as UTF-8 + * takes at maximum 4 bytes to encode: + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ + if (codepoint < 0x80) + { + /* normal ascii, encoding 0xxxxxxx */ + utf8_length = 1; + } + else if (codepoint < 0x800) + { + /* two bytes, encoding 110xxxxx 10xxxxxx */ + utf8_length = 2; + first_byte_mark = 0xC0; /* 11000000 */ + } + else if (codepoint < 0x10000) + { + /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ + utf8_length = 3; + first_byte_mark = 0xE0; /* 11100000 */ + } + else if (codepoint <= 0x10FFFF) + { + /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ + utf8_length = 4; + first_byte_mark = 0xF0; /* 11110000 */ + } + else + { + /* invalid unicode codepoint */ + goto fail; + } + + /* encode as utf8 */ + for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) + { + /* 10xxxxxx */ + (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); + codepoint >>= 6; + } + /* encode first byte */ + if (utf8_length > 1) + { + (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); + } + else + { + (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); + } + + *output_pointer += utf8_length; + + return sequence_length; + +fail: + return 0; +} + +/* Parse the input text into an unescaped cinput, and populate item. */ +static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer) +{ + const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; + const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; + unsigned char *output_pointer = NULL; + unsigned char *output = NULL; + + /* not a string */ + if (buffer_at_offset(input_buffer)[0] != '\"') + { + goto fail; + } + + { + /* calculate approximate size of the output (overestimate) */ + size_t allocation_length = 0; + size_t skipped_bytes = 0; + while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) + { + /* is escape sequence */ + if (input_end[0] == '\\') + { + if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) + { + /* prevent buffer overflow when last input character is a backslash */ + goto fail; + } + skipped_bytes++; + input_end++; + } + input_end++; + } + if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) + { + goto fail; /* string ended unexpectedly */ + } + + /* This is at most how much we need for the output */ + allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; + output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); + if (output == NULL) + { + goto fail; /* allocation failure */ + } + } + + output_pointer = output; + /* loop through the string literal */ + while (input_pointer < input_end) + { + if (*input_pointer != '\\') + { + *output_pointer++ = *input_pointer++; + } + /* escape sequence */ + else + { + unsigned char sequence_length = 2; + if ((input_end - input_pointer) < 1) + { + goto fail; + } + + switch (input_pointer[1]) + { + case 'b': + *output_pointer++ = '\b'; + break; + case 'f': + *output_pointer++ = '\f'; + break; + case 'n': + *output_pointer++ = '\n'; + break; + case 'r': + *output_pointer++ = '\r'; + break; + case 't': + *output_pointer++ = '\t'; + break; + case '\"': + case '\\': + case '/': + *output_pointer++ = input_pointer[1]; + break; + + /* UTF-16 literal */ + case 'u': + sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); + if (sequence_length == 0) + { + /* failed to convert UTF16-literal to UTF-8 */ + goto fail; + } + break; + + default: + goto fail; + } + input_pointer += sequence_length; + } + } + + /* zero terminate the output */ + *output_pointer = '\0'; + + item->type = cJSON_String; + item->valuestring = (char*)output; + + input_buffer->offset = (size_t) (input_end - input_buffer->content); + input_buffer->offset++; + + return true; + +fail: + if (output != NULL) + { + input_buffer->hooks.deallocate(output); + } + + if (input_pointer != NULL) + { + input_buffer->offset = (size_t)(input_pointer - input_buffer->content); + } + + return false; +} + +/* Render the cstring provided to an escaped version that can be printed. */ +static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer) +{ + const unsigned char *input_pointer = NULL; + unsigned char *output = NULL; + unsigned char *output_pointer = NULL; + size_t output_length = 0; + /* numbers of additional characters needed for escaping */ + size_t escape_characters = 0; + + if (output_buffer == NULL) + { + return false; + } + + /* empty string */ + if (input == NULL) + { + output = ensure(output_buffer, sizeof("\"\"")); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "\"\""); + + return true; + } + + /* set "flag" to 1 if something needs to be escaped */ + for (input_pointer = input; *input_pointer; input_pointer++) + { + switch (*input_pointer) + { + case '\"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + /* one character escape sequence */ + escape_characters++; + break; + default: + if (*input_pointer < 32) + { + /* UTF-16 escape sequence uXXXX */ + escape_characters += 5; + } + break; + } + } + output_length = (size_t)(input_pointer - input) + escape_characters; + + output = ensure(output_buffer, output_length + sizeof("\"\"")); + if (output == NULL) + { + return false; + } + + /* no characters have to be escaped */ + if (escape_characters == 0) + { + output[0] = '\"'; + memcpy(output + 1, input, output_length); + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; + } + + output[0] = '\"'; + output_pointer = output + 1; + /* copy the string */ + for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) + { + if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) + { + /* normal character, copy */ + *output_pointer = *input_pointer; + } + else + { + /* character needs to be escaped */ + *output_pointer++ = '\\'; + switch (*input_pointer) + { + case '\\': + *output_pointer = '\\'; + break; + case '\"': + *output_pointer = '\"'; + break; + case '\b': + *output_pointer = 'b'; + break; + case '\f': + *output_pointer = 'f'; + break; + case '\n': + *output_pointer = 'n'; + break; + case '\r': + *output_pointer = 'r'; + break; + case '\t': + *output_pointer = 't'; + break; + default: + /* escape and print as unicode codepoint */ + sprintf((char*)output_pointer, "u%04x", *input_pointer); + output_pointer += 4; + break; + } + } + } + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; +} + +/* Invoke print_string_ptr (which is useful) on an item. */ +static cJSON_bool print_string(const cJSON * const item, printbuffer * const p) +{ + return print_string_ptr((unsigned char*)item->valuestring, p); +} + +/* Predeclare these prototypes. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer); + +/* Utility to jump whitespace and cr/lf */ +static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL)) + { + return NULL; + } + + if (cannot_access_at_index(buffer, 0)) + { + return buffer; + } + + while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) + { + buffer->offset++; + } + + if (buffer->offset == buffer->length) + { + buffer->offset--; + } + + return buffer; +} + +/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */ +static parse_buffer *skip_utf8_bom(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) + { + return NULL; + } + + if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) + { + buffer->offset += 3; + } + + return buffer; +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + size_t buffer_length; + + if (NULL == value) + { + return NULL; + } + + /* Adding null character size due to require_null_terminated. */ + buffer_length = strlen(value) + sizeof(""); + + return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); +} + +/* Parse an object - create a new root, and populate. */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; + cJSON *item = NULL; + + /* reset error position */ + global_error.json = NULL; + global_error.position = 0; + + if (value == NULL || 0 == buffer_length) + { + goto fail; + } + + buffer.content = (const unsigned char*)value; + buffer.length = buffer_length; + buffer.offset = 0; + buffer.hooks = global_hooks; + + item = cJSON_New_Item(&global_hooks); + if (item == NULL) /* memory fail */ + { + goto fail; + } + + if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) + { + /* parse failure. ep is set. */ + goto fail; + } + + /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ + if (require_null_terminated) + { + buffer_skip_whitespace(&buffer); + if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') + { + goto fail; + } + } + if (return_parse_end) + { + *return_parse_end = (const char*)buffer_at_offset(&buffer); + } + + return item; + +fail: + if (item != NULL) + { + cJSON_Delete(item); + } + + if (value != NULL) + { + error local_error; + local_error.json = (const unsigned char*)value; + local_error.position = 0; + + if (buffer.offset < buffer.length) + { + local_error.position = buffer.offset; + } + else if (buffer.length > 0) + { + local_error.position = buffer.length - 1; + } + + if (return_parse_end != NULL) + { + *return_parse_end = (const char*)local_error.json + local_error.position; + } + + global_error = local_error; + } + + return NULL; +} + +/* Default options for cJSON_Parse */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) +{ + return cJSON_ParseWithOpts(value, 0, 0); +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length) +{ + return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0); +} + +#define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) + +static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks) +{ + static const size_t default_buffer_size = 256; + printbuffer buffer[1]; + unsigned char *printed = NULL; + + memset(buffer, 0, sizeof(buffer)); + + /* create buffer */ + buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); + buffer->length = default_buffer_size; + buffer->format = format; + buffer->hooks = *hooks; + if (buffer->buffer == NULL) + { + goto fail; + } + + /* print the value */ + if (!print_value(item, buffer)) + { + goto fail; + } + update_offset(buffer); + + /* check if reallocate is available */ + if (hooks->reallocate != NULL) + { + printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); + if (printed == NULL) { + goto fail; + } + buffer->buffer = NULL; + } + else /* otherwise copy the JSON over to a new buffer */ + { + printed = (unsigned char*) hooks->allocate(buffer->offset + 1); + if (printed == NULL) + { + goto fail; + } + memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); + printed[buffer->offset] = '\0'; /* just to be sure */ + + /* free the buffer */ + hooks->deallocate(buffer->buffer); + } + + return printed; + +fail: + if (buffer->buffer != NULL) + { + hooks->deallocate(buffer->buffer); + } + + if (printed != NULL) + { + hooks->deallocate(printed); + } + + return NULL; +} + +/* Render a cJSON item/entity/structure to text. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item) +{ + return (char*)print(item, true, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item) +{ + return (char*)print(item, false, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if (prebuffer < 0) + { + return NULL; + } + + p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); + if (!p.buffer) + { + return NULL; + } + + p.length = (size_t)prebuffer; + p.offset = 0; + p.noalloc = false; + p.format = fmt; + p.hooks = global_hooks; + + if (!print_value(item, &p)) + { + global_hooks.deallocate(p.buffer); + return NULL; + } + + return (char*)p.buffer; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if ((length < 0) || (buffer == NULL)) + { + return false; + } + + p.buffer = (unsigned char*)buffer; + p.length = (size_t)length; + p.offset = 0; + p.noalloc = true; + p.format = format; + p.hooks = global_hooks; + + return print_value(item, &p); +} + +/* Parser core - when encountering text, process appropriately. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer) +{ + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; /* no input */ + } + + /* parse the different types of values */ + /* null */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) + { + item->type = cJSON_NULL; + input_buffer->offset += 4; + return true; + } + /* false */ + if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) + { + item->type = cJSON_False; + input_buffer->offset += 5; + return true; + } + /* true */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) + { + item->type = cJSON_True; + item->valueint = 1; + input_buffer->offset += 4; + return true; + } + /* string */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) + { + return parse_string(item, input_buffer); + } + /* number */ + if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) + { + return parse_number(item, input_buffer); + } + /* array */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) + { + return parse_array(item, input_buffer); + } + /* object */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) + { + return parse_object(item, input_buffer); + } + + return false; +} + +/* Render a value to text. */ +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output = NULL; + + if ((item == NULL) || (output_buffer == NULL)) + { + return false; + } + + switch ((item->type) & 0xFF) + { + case cJSON_NULL: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "null"); + return true; + + case cJSON_False: + output = ensure(output_buffer, 6); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "false"); + return true; + + case cJSON_True: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "true"); + return true; + + case cJSON_Number: + return print_number(item, output_buffer); + + case cJSON_Raw: + { + size_t raw_length = 0; + if (item->valuestring == NULL) + { + return false; + } + + raw_length = strlen(item->valuestring) + sizeof(""); + output = ensure(output_buffer, raw_length); + if (output == NULL) + { + return false; + } + memcpy(output, item->valuestring, raw_length); + return true; + } + + case cJSON_String: + return print_string(item, output_buffer); + + case cJSON_Array: + return print_array(item, output_buffer); + + case cJSON_Object: + return print_object(item, output_buffer); + + default: + return false; + } +} + +/* Build an array from input text. */ +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* head of the linked list */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (buffer_at_offset(input_buffer)[0] != '[') + { + /* not an array */ + goto fail; + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) + { + /* empty array */ + goto success; + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse next value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') + { + goto fail; /* expected end of array */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Array; + item->child = head; + + input_buffer->offset++; + + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an array to text */ +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_element = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output array. */ + /* opening square bracket */ + output_pointer = ensure(output_buffer, 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer = '['; + output_buffer->offset++; + output_buffer->depth++; + + while (current_element != NULL) + { + if (!print_value(current_element, output_buffer)) + { + return false; + } + update_offset(output_buffer); + if (current_element->next) + { + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ','; + if(output_buffer->format) + { + *output_pointer++ = ' '; + } + *output_pointer = '\0'; + output_buffer->offset += length; + } + current_element = current_element->next; + } + + output_pointer = ensure(output_buffer, 2); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ']'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Build an object from the text. */ +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* linked list head */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) + { + goto fail; /* not an object */ + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) + { + goto success; /* empty object */ + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse the name of the child */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_string(current_item, input_buffer)) + { + goto fail; /* failed to parse name */ + } + buffer_skip_whitespace(input_buffer); + + /* swap valuestring and string, because we parsed the name */ + current_item->string = current_item->valuestring; + current_item->valuestring = NULL; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) + { + goto fail; /* invalid object */ + } + + /* parse the value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) + { + goto fail; /* expected end of object */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Object; + item->child = head; + + input_buffer->offset++; + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an object to text. */ +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_item = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output: */ + length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer++ = '{'; + output_buffer->depth++; + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + output_buffer->offset += length; + + while (current_item) + { + if (output_buffer->format) + { + size_t i; + output_pointer = ensure(output_buffer, output_buffer->depth); + if (output_pointer == NULL) + { + return false; + } + for (i = 0; i < output_buffer->depth; i++) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += output_buffer->depth; + } + + /* print key */ + if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ':'; + if (output_buffer->format) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += length; + + /* print value */ + if (!print_value(current_item, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + /* print comma if not last */ + length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + if (current_item->next) + { + *output_pointer++ = ','; + } + + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + *output_pointer = '\0'; + output_buffer->offset += length; + + current_item = current_item->next; + } + + output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); + if (output_pointer == NULL) + { + return false; + } + if (output_buffer->format) + { + size_t i; + for (i = 0; i < (output_buffer->depth - 1); i++) + { + *output_pointer++ = '\t'; + } + } + *output_pointer++ = '}'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Get Array size/item / object item. */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) +{ + cJSON *child = NULL; + size_t size = 0; + + if (array == NULL) + { + return 0; + } + + child = array->child; + + while(child != NULL) + { + size++; + child = child->next; + } + + /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ + + return (int)size; +} + +static cJSON* get_array_item(const cJSON *array, size_t index) +{ + cJSON *current_child = NULL; + + if (array == NULL) + { + return NULL; + } + + current_child = array->child; + while ((current_child != NULL) && (index > 0)) + { + index--; + current_child = current_child->next; + } + + return current_child; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) +{ + if (index < 0) + { + return NULL; + } + + return get_array_item(array, (size_t)index); +} + +static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive) +{ + cJSON *current_element = NULL; + + if ((object == NULL) || (name == NULL)) + { + return NULL; + } + + current_element = object->child; + if (case_sensitive) + { + while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0)) + { + current_element = current_element->next; + } + } + else + { + while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) + { + current_element = current_element->next; + } + } + + if ((current_element == NULL) || (current_element->string == NULL)) { + return NULL; + } + + return current_element; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, false); +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) +{ + return cJSON_GetObjectItem(object, string) ? 1 : 0; +} + +/* Utility for array list handling. */ +static void suffix_object(cJSON *prev, cJSON *item) +{ + prev->next = item; + item->prev = prev; +} + +/* Utility for handling references. */ +static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks) +{ + cJSON *reference = NULL; + if (item == NULL) + { + return NULL; + } + + reference = cJSON_New_Item(hooks); + if (reference == NULL) + { + return NULL; + } + + memcpy(reference, item, sizeof(cJSON)); + reference->string = NULL; + reference->type |= cJSON_IsReference; + reference->next = reference->prev = NULL; + return reference; +} + +static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) +{ + cJSON *child = NULL; + + if ((item == NULL) || (array == NULL) || (array == item)) + { + return false; + } + + child = array->child; + /* + * To find the last item in array quickly, we use prev in array + */ + if (child == NULL) + { + /* list is empty, start new one */ + array->child = item; + item->prev = item; + item->next = NULL; + } + else + { + /* append to the end */ + if (child->prev) + { + suffix_object(child->prev, item); + array->child->prev = item; + } + } + + return true; +} + +/* Add item to array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item) +{ + return add_item_to_array(array, item); +} + +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic push +#endif +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif +/* helper function to cast away const */ +static void* cast_away_const(const void* string) +{ + return (void*)string; +} +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic pop +#endif + + +static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key) +{ + char *new_key = NULL; + int new_type = cJSON_Invalid; + + if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item)) + { + return false; + } + + if (constant_key) + { + new_key = (char*)cast_away_const(string); + new_type = item->type | cJSON_StringIsConst; + } + else + { + new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks); + if (new_key == NULL) + { + return false; + } + + new_type = item->type & ~cJSON_StringIsConst; + } + + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + hooks->deallocate(item->string); + } + + item->string = new_key; + item->type = new_type; + + return add_item_to_array(object, item); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, false); +} + +/* Add an item to an object with constant string as key */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) +{ + if (array == NULL) + { + return false; + } + + return add_item_to_array(array, create_reference(item, &global_hooks)); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) +{ + if ((object == NULL) || (string == NULL)) + { + return false; + } + + return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false); +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name) +{ + cJSON *null = cJSON_CreateNull(); + if (add_item_to_object(object, name, null, &global_hooks, false)) + { + return null; + } + + cJSON_Delete(null); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name) +{ + cJSON *true_item = cJSON_CreateTrue(); + if (add_item_to_object(object, name, true_item, &global_hooks, false)) + { + return true_item; + } + + cJSON_Delete(true_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name) +{ + cJSON *false_item = cJSON_CreateFalse(); + if (add_item_to_object(object, name, false_item, &global_hooks, false)) + { + return false_item; + } + + cJSON_Delete(false_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean) +{ + cJSON *bool_item = cJSON_CreateBool(boolean); + if (add_item_to_object(object, name, bool_item, &global_hooks, false)) + { + return bool_item; + } + + cJSON_Delete(bool_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number) +{ + cJSON *number_item = cJSON_CreateNumber(number); + if (add_item_to_object(object, name, number_item, &global_hooks, false)) + { + return number_item; + } + + cJSON_Delete(number_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) +{ + cJSON *string_item = cJSON_CreateString(string); + if (add_item_to_object(object, name, string_item, &global_hooks, false)) + { + return string_item; + } + + cJSON_Delete(string_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw) +{ + cJSON *raw_item = cJSON_CreateRaw(raw); + if (add_item_to_object(object, name, raw_item, &global_hooks, false)) + { + return raw_item; + } + + cJSON_Delete(raw_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name) +{ + cJSON *object_item = cJSON_CreateObject(); + if (add_item_to_object(object, name, object_item, &global_hooks, false)) + { + return object_item; + } + + cJSON_Delete(object_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name) +{ + cJSON *array = cJSON_CreateArray(); + if (add_item_to_object(object, name, array, &global_hooks, false)) + { + return array; + } + + cJSON_Delete(array); + return NULL; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item) +{ + if ((parent == NULL) || (item == NULL)) + { + return NULL; + } + + if (item != parent->child) + { + /* not the first element */ + item->prev->next = item->next; + } + if (item->next != NULL) + { + /* not the last element */ + item->next->prev = item->prev; + } + + if (item == parent->child) + { + /* first element */ + parent->child = item->next; + } + else if (item->next == NULL) + { + /* last element */ + parent->child->prev = item->prev; + } + + /* make sure the detached item doesn't point anywhere anymore */ + item->prev = NULL; + item->next = NULL; + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) +{ + if (which < 0) + { + return NULL; + } + + return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) +{ + cJSON_Delete(cJSON_DetachItemFromArray(array, which)); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItem(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObject(object, string)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); +} + +/* Replace array/object items with new ones. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) +{ + cJSON *after_inserted = NULL; + + if (which < 0) + { + return false; + } + + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + return add_item_to_array(array, newitem); + } + + newitem->next = after_inserted; + newitem->prev = after_inserted->prev; + after_inserted->prev = newitem; + if (after_inserted == array->child) + { + array->child = newitem; + } + else + { + newitem->prev->next = newitem; + } + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) +{ + if ((parent == NULL) || (replacement == NULL) || (item == NULL)) + { + return false; + } + + if (replacement == item) + { + return true; + } + + replacement->next = item->next; + replacement->prev = item->prev; + + if (replacement->next != NULL) + { + replacement->next->prev = replacement; + } + if (parent->child == item) + { + if (parent->child->prev == parent->child) + { + replacement->prev = replacement; + } + parent->child = replacement; + } + else + { /* + * To find the last item in array quickly, we use prev in array. + * We can't modify the last item's next pointer where this item was the parent's child + */ + if (replacement->prev != NULL) + { + replacement->prev->next = replacement; + } + if (replacement->next == NULL) + { + parent->child->prev = replacement; + } + } + + item->next = NULL; + item->prev = NULL; + cJSON_Delete(item); + + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) +{ + if (which < 0) + { + return false; + } + + return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem); +} + +static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) +{ + if ((replacement == NULL) || (string == NULL)) + { + return false; + } + + /* replace the name in the replacement */ + if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) + { + cJSON_free(replacement->string); + } + replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + replacement->type &= ~cJSON_StringIsConst; + + return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, false); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, true); +} + +/* Create basic types: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_NULL; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_True; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = boolean ? cJSON_True : cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Number; + item->valuedouble = num; + + /* use saturation in case of overflow */ + if (num >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (num <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)num; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_String; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) + { + item->type = cJSON_String | cJSON_IsReference; + item->valuestring = (char*)cast_away_const(string); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Object | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) { + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Array | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Raw; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type=cJSON_Array; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item) + { + item->type = cJSON_Object; + } + + return item; +} + +/* Create Arrays: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if (!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber((double)numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (strings == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for (i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateString(strings[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p,n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +/* Duplication */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + cJSON *newitem = NULL; + cJSON *child = NULL; + cJSON *next = NULL; + cJSON *newchild = NULL; + + /* Bail on bad ptr */ + if (!item) + { + goto fail; + } + /* Create new item */ + newitem = cJSON_New_Item(&global_hooks); + if (!newitem) + { + goto fail; + } + /* Copy over all vars */ + newitem->type = item->type & (~cJSON_IsReference); + newitem->valueint = item->valueint; + newitem->valuedouble = item->valuedouble; + if (item->valuestring) + { + newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); + if (!newitem->valuestring) + { + goto fail; + } + } + if (item->string) + { + newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); + if (!newitem->string) + { + goto fail; + } + } + /* If non-recursive, then we're done! */ + if (!recurse) + { + return newitem; + } + /* Walk the ->next chain for the child. */ + child = item->child; + while (child != NULL) + { + newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) + { + goto fail; + } + if (next != NULL) + { + /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + next->next = newchild; + newchild->prev = next; + next = newchild; + } + else + { + /* Set newitem->child and move to it */ + newitem->child = newchild; + next = newchild; + } + child = child->next; + } + if (newitem && newitem->child) + { + newitem->child->prev = newchild; + } + + return newitem; + +fail: + if (newitem != NULL) + { + cJSON_Delete(newitem); + } + + return NULL; +} + +static void skip_oneline_comment(char **input) +{ + *input += static_strlen("//"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if ((*input)[0] == '\n') { + *input += static_strlen("\n"); + return; + } + } +} + +static void skip_multiline_comment(char **input) +{ + *input += static_strlen("/*"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if (((*input)[0] == '*') && ((*input)[1] == '/')) + { + *input += static_strlen("*/"); + return; + } + } +} + +static void minify_string(char **input, char **output) { + (*output)[0] = (*input)[0]; + *input += static_strlen("\""); + *output += static_strlen("\""); + + + for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { + (*output)[0] = (*input)[0]; + + if ((*input)[0] == '\"') { + (*output)[0] = '\"'; + *input += static_strlen("\""); + *output += static_strlen("\""); + return; + } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { + (*output)[1] = (*input)[1]; + *input += static_strlen("\""); + *output += static_strlen("\""); + } + } +} + +CJSON_PUBLIC(void) cJSON_Minify(char *json) +{ + char *into = json; + + if (json == NULL) + { + return; + } + + while (json[0] != '\0') + { + switch (json[0]) + { + case ' ': + case '\t': + case '\r': + case '\n': + json++; + break; + + case '/': + if (json[1] == '/') + { + skip_oneline_comment(&json); + } + else if (json[1] == '*') + { + skip_multiline_comment(&json); + } else { + json++; + } + break; + + case '\"': + minify_string(&json, (char**)&into); + break; + + default: + into[0] = json[0]; + json++; + into++; + } + } + + /* and null-terminate. */ + *into = '\0'; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Invalid; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_False; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xff) == cJSON_True; +} + + +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & (cJSON_True | cJSON_False)) != 0; +} +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_NULL; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Number; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_String; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Array; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Object; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Raw; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) +{ + if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF))) + { + return false; + } + + /* check if type is valid */ + switch (a->type & 0xFF) + { + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + case cJSON_Number: + case cJSON_String: + case cJSON_Raw: + case cJSON_Array: + case cJSON_Object: + break; + + default: + return false; + } + + /* identical objects are equal */ + if (a == b) + { + return true; + } + + switch (a->type & 0xFF) + { + /* in these cases and equal type is enough */ + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + return true; + + case cJSON_Number: + if (compare_double(a->valuedouble, b->valuedouble)) + { + return true; + } + return false; + + case cJSON_String: + case cJSON_Raw: + if ((a->valuestring == NULL) || (b->valuestring == NULL)) + { + return false; + } + if (strcmp(a->valuestring, b->valuestring) == 0) + { + return true; + } + + return false; + + case cJSON_Array: + { + cJSON *a_element = a->child; + cJSON *b_element = b->child; + + for (; (a_element != NULL) && (b_element != NULL);) + { + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + + a_element = a_element->next; + b_element = b_element->next; + } + + /* one of the arrays is longer than the other */ + if (a_element != b_element) { + return false; + } + + return true; + } + + case cJSON_Object: + { + cJSON *a_element = NULL; + cJSON *b_element = NULL; + cJSON_ArrayForEach(a_element, a) + { + /* TODO This has O(n^2) runtime, which is horrible! */ + b_element = get_object_item(b, a_element->string, case_sensitive); + if (b_element == NULL) + { + return false; + } + + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + } + + /* doing this twice, once on a and b to prevent true comparison if a subset of b + * TODO: Do this the proper way, this is just a fix for now */ + cJSON_ArrayForEach(b_element, b) + { + a_element = get_object_item(a, b_element->string, case_sensitive); + if (a_element == NULL) + { + return false; + } + + if (!cJSON_Compare(b_element, a_element, case_sensitive)) + { + return false; + } + } + + return true; + } + + default: + return false; + } +} + +CJSON_PUBLIC(void *) cJSON_malloc(size_t size) +{ + return global_hooks.allocate(size); +} + +CJSON_PUBLIC(void) cJSON_free(void *object) +{ + global_hooks.deallocate(object); +} diff --git a/middleware/cjson/cjson-master/cjson-master/cJSON.h b/middleware/cjson/cjson-master/cjson-master/cJSON.h new file mode 100644 index 0000000..6ad205c --- /dev/null +++ b/middleware/cjson/cjson-master/cjson-master/cJSON.h @@ -0,0 +1,294 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#ifdef __cplusplus +extern "C" +{ +#endif + +#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) +#define __WINDOWS__ +#endif + +#ifdef __WINDOWS__ + +/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 3 define options: + +CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols +CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) +CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol + +For *nix builds that support visibility attribute, you can define similar behavior by + +setting default visibility to hidden by adding +-fvisibility=hidden (for gcc) +or +-xldscope=hidden (for sun cc) +to CFLAGS + +then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does + +*/ + +#define CJSON_CDECL __cdecl +#define CJSON_STDCALL __stdcall + +/* export symbols by default, this is necessary for copy pasting the C and header file */ +#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_EXPORT_SYMBOLS +#endif + +#if defined(CJSON_HIDE_SYMBOLS) +#define CJSON_PUBLIC(type) type CJSON_STDCALL +#elif defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL +#elif defined(CJSON_IMPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL +#endif +#else /* !__WINDOWS__ */ +#define CJSON_CDECL +#define CJSON_STDCALL + +#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) +#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type +#else +#define CJSON_PUBLIC(type) type +#endif +#endif + +/* project version */ +#define CJSON_VERSION_MAJOR 1 +#define CJSON_VERSION_MINOR 7 +#define CJSON_VERSION_PATCH 15 + +#include + +/* cJSON Types: */ +#define cJSON_Invalid (0) +#define cJSON_False (1 << 0) +#define cJSON_True (1 << 1) +#define cJSON_NULL (1 << 2) +#define cJSON_Number (1 << 3) +#define cJSON_String (1 << 4) +#define cJSON_Array (1 << 5) +#define cJSON_Object (1 << 6) +#define cJSON_Raw (1 << 7) /* raw json */ + +#define cJSON_IsReference 256 +#define cJSON_StringIsConst 512 + +/* The cJSON structure: */ +typedef struct cJSON +{ + /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *next; + struct cJSON *prev; + /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + struct cJSON *child; + + /* The type of the item, as above. */ + int type; + + /* The item's string, if type==cJSON_String and type == cJSON_Raw */ + char *valuestring; + /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ + int valueint; + /* The item's number, if type==cJSON_Number */ + double valuedouble; + + /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ + char *string; +} cJSON; + +typedef struct cJSON_Hooks +{ + /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */ + void *(CJSON_CDECL *malloc_fn)(size_t sz); + void (CJSON_CDECL *free_fn)(void *ptr); +} cJSON_Hooks; + +typedef int cJSON_bool; + +/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_NESTING_LIMIT +#define CJSON_NESTING_LIMIT 1000 +#endif + +/* returns the version of cJSON as a string */ +char* cJSON_Version(void); + +/* Supply malloc, realloc and free functions to cJSON */ +//CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); +CJSON_PUBLIC(void) cJSON_InitHooks(void); + +/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ +/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length); +/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ +/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated); + +/* Render a cJSON entity to text for transfer/storage. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); +/* Render a cJSON entity to text for transfer/storage without any formatting. */ +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); +/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); +/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ +/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); +/* Delete a cJSON entity and all subentities. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item); + +/* Returns the number of items in an array (or object). */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); +/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); +/* Get item "string" from object. Case insensitive. */ +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); +/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); + +/* Check item type and return its value */ +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item); +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item); + +/* These functions check the type of an item */ +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item); + +/* These calls create a cJSON item of the appropriate type. */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean); +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num); +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string); +/* raw json */ +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw); +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); + +/* Create a string where valuestring references a string so + * it will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); +/* Create an object/array that only references it's elements so + * they will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); + +/* These utilities create an Array of count items. + * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count); + +/* Append item to the specified array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); +/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. + * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before + * writing to `item->string` */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); +/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); + +/* Remove/Detach items from Arrays/Objects. */ +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); + +/* Update array items. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); + +/* Duplicate a cJSON item */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); +/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will + * need to be released. With recurse!=0, it will duplicate any children connected to the item. + * The item->next and ->prev pointers are always zero on return from Duplicate. */ +/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. + * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); + +/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings. + * The input pointer json cannot point to a read-only address area, such as a string constant, + * but should point to a readable and writable address area. */ +CJSON_PUBLIC(void) cJSON_Minify(char *json); + +/* Helper functions for creating and adding items to an object at the same time. + * They return the added item or NULL on failure. */ +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); + +/* When assigning an integer value, it needs to be propagated to valuedouble too. */ +#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) +/* helper for the cJSON_SetNumberValue macro */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); +#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) +/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring); + +/* Macro for iterating over an array or object */ +#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) + +/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ +CJSON_PUBLIC(void *) cJSON_malloc(size_t size); +CJSON_PUBLIC(void) cJSON_free(void *object); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/middleware/easyflash/inc/ef_api.h b/middleware/easyflash/inc/ef_api.h new file mode 100644 index 0000000..2ab3417 --- /dev/null +++ b/middleware/easyflash/inc/ef_api.h @@ -0,0 +1,24 @@ +#include "stm32g0xx_hal.h" +#include +#include +#include + + +// »ñÈ¡uint32_t µÄÊýÖµ +uint32_t ef_get_integer(const char * key); + +// »ñÈ¡double µÄÊýÖµ +double ef_get_double(const char* key); + +// »ñÈ¡×Ö·û´®µÄÊýÖµ +char* ef_get_string(const char* key); + + +// ´æ´¢ÎÞ·ûºÅÕû +void ef_save_uint(const char* key, unsigned int value); + +// ´æ´¢stringÀàÐÍ +void ef_save_string(const char* key, char* value, int size); + + + diff --git a/middleware/easyflash/port/ef_api.c b/middleware/easyflash/port/ef_api.c index 857202b..1b8b24a 100644 --- a/middleware/easyflash/port/ef_api.c +++ b/middleware/easyflash/port/ef_api.c @@ -2,19 +2,19 @@ #include #include #include +#include "rtthread.h" // »ñÈ¡uint32_t µÄÊýÖµ uint32_t ef_get_integer(const char * key) { uint32_t integer = NULL; - char * value_ptr; + char * value_ptr; /* get the boot count number from Env */ value_ptr = ef_get_env (key); - - integer = atol (value_ptr); - + + integer = atoi (value_ptr); return integer; } @@ -42,3 +42,24 @@ char * ef_get_string(const char * key) } +// ´æ´¢ÎÞ·ûºÅÕû +void ef_save_uint(const char* key, unsigned int value) +{ + char valuebuff[128]; + rt_sprintf(valuebuff, "%u", value); + ef_set_env(key, valuebuff); + ef_save_env(); +} + +// ´æ´¢stringÀàÐÍ +void ef_save_string(const char* key, char* value, int size) +{ + char valuebuff[128]; + rt_sprintf(valuebuff, "%*.s", size, value); + //rt_kprintf("%s\r\n",valuebuff); + ef_set_env(key, valuebuff); + ef_save_env(); +} + + + diff --git a/middleware/easyflash/port/ef_port.c b/middleware/easyflash/port/ef_port.c index d6f877d..bf4450f 100644 --- a/middleware/easyflash/port/ef_port.c +++ b/middleware/easyflash/port/ef_port.c @@ -40,15 +40,21 @@ static const ef_env default_env_set[] = { {"iap_need_uart_update", "0"}, // ÐèҪͨ¹ý´®¿ÚÉý¼¶ {"iap_app_filename", "App.bin"}, {"stop_in_bootloader", "0"}, - {"device_id", "0000000001"}, + {"boot_times", "0"}, + {"jump_boot_time", "10"}, // BOOT µÈ´ýʱ¼ä 10s + // »ù´¡²ÎÊýÉèÖà + {"device_id", "0000000003"}, + {"app_id", "220000"}, // ÒµÎñID + {"user_pass", "123456"}, + {"sys_pass", "898909"}, {"mqtt_user", "admin"}, {"mqtt_pass", "admin"}, {"mqtt_addr", "mqtt.zyjzjs.cn"}, {"mqtt_port", "1883"}, - {"boot_times", "0"}, - {"jump_boot_time", "10"}, // BOOT µÈ´ýʱ¼ä 10s - {"net_drv", "dtu"}, // mqtt dtu ec200 - {"eth2_chann", "1"}, //ÒÔÌ«ÍøͨµÀ2 + {"mqtt_topic", "sluice"}, //¶©ÔÄtopic + + {"net_drv", "dtu"}, // mqtt dtu ec200 eth + {"eth2_chann", "0"}, //ÒÔÌ«ÍøͨµÀ2 Ö§³Ömodbus // ´«¸ÐÆ÷»ù´¡²ÎÊýÅäÖà {"di1", "0"},// 0 ±íʾ䶨Òå 1 ±íʾ ÉÏÏÞ룬2£ºÏÂÏÞλ 3£º ¿ª¹Ø4£º¹Ø 5£ºÍ£Ö¹ @@ -58,14 +64,10 @@ static const ef_env default_env_set[] = { {"di5", "0"},// 0 ±íʾ䶨Òå 1 ±íʾ ÉÏÏÞ룬2£ºÏÂÏÞλ 3£º ¿ª¹Ø4£º¹Ø 5£ºÍ£Ö¹ {"di6", "0"},// 0 ±íʾ䶨Òå 1 ±íʾ ÉÏÏÞ룬2£ºÏÂÏÞλ 3£º ¿ª¹Ø4£º¹Ø 5£ºÍ£Ö¹ // 485 ÅäÖòÎÊý - {"s4851num", "1"}, // 4851 ½ÓÈë´«¸ÐÆ÷µÄ¸öÊý - {"s4852num", "0"}, // 4852 ½ÓÈë´«¸ÐÆ÷µÄ¸öÊý - {"s4851func", "0100000000000000"}, // 4851 ½ÓÈë´«¸ÐÆ÷µÄÀàÐÍ - {"s4852func", "0000000000000000"}, // 4852 ½ÓÈë´«¸ÐÆ÷µÄÀàÐÍ - {"s4851bute", "9600"}, // 4851 ²¨ÌØÂÊ - {"s4852bute", "19200"}, // 4852 ²¨ÌØÂÊ - {"s4851para", "0"}, // 4851 ½ÓÈë´«¸ÐÆ÷µÄ¸öÊý - {"s4852para", "0"}, // 4851 ½ÓÈë´«¸ÐÆ÷µÄ¸öÊý + {"u485func", "mg1000"}, // ÓÃÓÚÒ»¸ö¹ñ×Ó¿ØÖƶą̀բÃÅ + {"s4851func", "rds600"}, // 4851 ½ÓÈë´«¸ÐÆ÷µÄÀàÐÍ rds600 tds300 + {"s4852func", "modbus"}, // 4852 ½ÓÈë´«¸ÐÆ÷µÄÀàÐÍ + // Ä£ÄâÁ¿ÅäÖà {"ai1", "0"}, // AI1½ÓÈëÉ豸 {"ai2", "0"}, // AI2½ÓÈëÉ豸 @@ -80,18 +82,27 @@ static const ef_env default_env_set[] = { {"pwm4", "0"}, // PWM4¹¦ÄÜ // Õ¢ÃŲÎÊýÉèÖà - {"maxopen", "140"}, // PWM4¹¦ÄÜ - {"maxecode", "0"}, // PWM4¹¦ÄÜ - {"minecode", "0"}, // PWM4¹¦ÄÜ - {"codepre", "0"}, // ±àÂëÆ÷ºÍÕ¢ÃÅ¿ª¶ÈµÄ±È + {"max_open", "1400"}, // ×î´ó¿ª¶È + {"max_ecode", "31241"}, // ±àÂëÆ÷×î´ó±àÂë + {"min_ecode", "32828"}, // ±àÂëÆ÷×îС±àÂë + {"exec_time", "50"}, // Òì³£¼ì²âʱ¼ä µ¥Î»100ms 50 ¾ÍÊÇ 5s // Õ¢ÃŲÎÊýÉèÖà - {"motortype", "140"}, // PWM4¹¦ÄÜ - {"codertype", "0"}, // PWM4¹¦ÄÜ - {"loadrtype", "0"}, // PWM4¹¦ÄÜ - {"flowrtype", "0"}, // ±àÂëÆ÷ºÍÕ¢ÃÅ¿ª¶ÈµÄ±È + {"ctrl_mode", "0"}, // ¿ØÖÆģʽ // 1 Ö±½Ó¿ª¶È¿ØÖÆ£¬0 ·´À¡¿ª¶È¿ØÖÆ + {"motor_type", "mg1000"}, // µç»úÀàÐÍ // mg a3 b5 + {"simu_flow", "0"}, // 0 δÆô¶¯ 1 ˮλÁ÷Á¿¹Øϵ±í 2°ÍЪ¶û²ÛÆô¶¯Á÷Á¿¹Øϵ±í + {"parshall", "7"}, // °ÍЪ¶û²Û¹æ¸ñ + // Á÷Á¿Êý¾Ý´æ´¢ + {"ttflow", "0"}, // ÀÛ¼ÆÁ÷Á¿ + {"chancnt", "1"}, // Á÷Á¿¼ÆͨµÀÊý + {"site_type", "sluice"}, // 0,Õ¢ÃÅÕ¾£¬1£¬Á÷Á¿Õ¾£¬2£¬ÉøÁ÷Éøѹվ£¬3£¬×Ô¶¯»¯²É¼¯Õ¾£¬4£¬´®¿Ú·þÎñÆ÷ + {"level","[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]"}, + {"flow", "[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]"}, + {"wsid","[128,2,3,4,5,6]"}, + // ˮλÁ÷Á¿¹Øϵ±í ÅäÖÃ10 ¸öµã + + - {"speed", "0"}, // ±àÂëÆ÷ºÍÕ¢ÃÅ¿ª¶ÈµÄ±È }; diff --git a/middleware/easylogger/inc/elog.h b/middleware/easylogger/inc/elog.h index 719f4fb..d0512af 100644 --- a/middleware/easylogger/inc/elog.h +++ b/middleware/easylogger/inc/elog.h @@ -124,7 +124,7 @@ extern "C" { #endif /* ELOG_OUTPUT_ENABLE */ /* all formats index */ -typedef enum { +typedef enum { // ELOG_FMT_LVL = 1 << 0, /**< level */ ELOG_FMT_TAG = 1 << 1, /**< tag */ ELOG_FMT_TIME = 1 << 2, /**< current time */ diff --git a/middleware/easylogger/port/elog_port.c b/middleware/easylogger/port/elog_port.c index d7093db..cafb25a 100644 --- a/middleware/easylogger/port/elog_port.c +++ b/middleware/easylogger/port/elog_port.c @@ -28,6 +28,7 @@ #include #include +#include /** * EasyLogger port initialize @@ -61,7 +62,7 @@ void elog_port_deinit(void) { void elog_port_output(const char *log, size_t size) { /* add your code here */ - printf("%.*s", size, log); + rt_kprintf("%.*s", size, log); } /** diff --git a/middleware/modbus/modbus-m.c b/middleware/modbus/modbus-m.c index c01a4de..9d64df0 100644 --- a/middleware/modbus/modbus-m.c +++ b/middleware/modbus/modbus-m.c @@ -2,6 +2,8 @@ #include #include "crc.h" +#include "modbus-m.h" +#include "rtthread.h" // ¶ÁÈ¡±£³Ö¼Ä´æÆ÷µÄÖµ // addr ¼Ä´æÆ÷µØÖ· @@ -22,6 +24,25 @@ int modbus_m_read_regist(uint8_t id,uint16_t addr,uint16_t length,uint8_t * data return index; } +// ¶ÁÈ¡ÊäÈëµÄÖµ +// addr ¼Ä´æÆ÷µØÖ· +// id ´Ô»úµØÖ· +// length ¶ÁÈ¡´Ô»úÊý¾Ý³¤¶È +int modbus_m_read_input(uint8_t id,uint16_t addr,uint16_t length,uint8_t * data) +{ + uint16_t index = 0,crc; + data[index++] = id; + data[index++] = 0x04; + data[index++] = (addr >> 8) & 0x00FF; + data[index++] = addr & 0x00FF; + data[index++] = (length >> 8) & 0x00FF; + data[index++] = length & 0x00FF; + crc = MX_CRC_CALC(data,index); + data[index++] = crc & 0x00FF; + data[index++] = (crc >> 8) & 0x00FF; + return index; +} + // дÈë¼Ä´æÆ÷ // addr ¼Ä´æÆ÷µØÖ· @@ -43,3 +64,72 @@ int modbus_m_write_regist(uint8_t id,uint16_t addr,uint16_t key,uint8_t * data) } +//03 10 00 02 00 02 04 41 00 00 00 +// дÈë¼Ä´æÆ÷ +// addr ¼Ä´æÆ÷µØÖ· +// id ´Ô»úµØÖ· +// length ¶ÁÈ¡´Ô»úÊý¾Ý³¤¶È +int modbus_m_write_mregist(uint8_t id,uint16_t addr,uint8_t *key,uint16_t size ,uint8_t * data) +{ + uint16_t index = 0,crc; + data[index++] = id; + data[index++] = 0x10; + data[index++] = (addr >> 8) & 0x00FF; + data[index++] = addr & 0x00FF; + data[index++] = (size >> 8) & 0x00FF; + data[index++] = size & 0x00FF; + data[index++] = size * 2; + for (int i =0;i < size * 2;i++) + { + data[index++] = key[i]; + } + crc = MX_CRC_CALC(data,index); + data[index++] = crc & 0x00FF; + data[index++] = (crc >> 8) & 0x00FF; + return index; +} + +// дÈë¼Ä´æÆ÷ +// addr ¼Ä´æÆ÷µØÖ· +// id ´Ô»úµØÖ· +// length ¶ÁÈ¡´Ô»úÊý¾Ý³¤¶È +int modbus_m_write_coil(uint8_t id,uint16_t addr,uint16_t key,uint8_t * data) +{ + uint16_t index = 0,crc; + data[index++] = id; + data[index++] = 0x05; + data[index++] = (addr >> 8) & 0x00FF; + data[index++] = addr & 0x00FF; + if (key == 1) + { + data[index++] = (addr >> 8) & 0x00FF; + data[index++] = addr & 0x00FF; + } + else + { + data[index++] = 0x00; + data[index++] = 0x00; + } + crc = MX_CRC_CALC(data,index); + data[index++] = crc & 0x00FF; + data[index++] = (crc >> 8) & 0x00FF; + return index; +} + + +MOD_T modbus_m_crc_check(uint8_t * data,int size ) +{ + uint16_t rcrc = 0,ccrc; + if (size < 4) + { + return MOD_ERR; + } + + ccrc = MX_CRC_CALC(data,size-2); + rcrc = ((uint16_t)data[size-1] << 8 )+ (uint16_t)data[size-2]; + if (ccrc == rcrc ) + return MOD_OK; + return MOD_ERR; +} + + diff --git a/middleware/modbus/modbus-m.h b/middleware/modbus/modbus-m.h index 11d8ec2..3b86be0 100644 --- a/middleware/modbus/modbus-m.h +++ b/middleware/modbus/modbus-m.h @@ -2,9 +2,18 @@ #define MODBUS_M_H #include +typedef enum { + MOD_OK = 0, + MOD_ERR = 1 +}MOD_T; + int modbus_m_read_regist(uint8_t id,uint16_t addr,uint16_t length,uint8_t * data); int modbus_m_write_regist(uint8_t id,uint16_t addr,uint16_t key,uint8_t * data); +int modbus_m_read_input(uint8_t id,uint16_t addr,uint16_t length,uint8_t * data) ; +int modbus_m_write_coil(uint8_t id,uint16_t addr,uint16_t key,uint8_t * data); +MOD_T modbus_m_crc_check(uint8_t * data,int size ); +int modbus_m_write_mregist(uint8_t id,uint16_t addr,uint8_t *key,uint16_t size ,uint8_t * data); #endif diff --git a/middleware/modbus/modbus-s.c b/middleware/modbus/modbus-s.c index 921265d..880576c 100644 --- a/middleware/modbus/modbus-s.c +++ b/middleware/modbus/modbus-s.c @@ -3,9 +3,10 @@ #include #include "crc.h" #include "modbus-s.h" +#include "modbus-m.h" #if !defined(LOG_TAG) - #define LOG_TAG "main" + #define LOG_TAG "modbus-s" #endif #include @@ -22,19 +23,16 @@ void ModbusSlaveInit(ModBusSlave_t * drv,uint8_t ID,uint8_t * data,uint16_t * r //-1 µØÖ·´íÎó int ModbusSlaveHandle(ModBusSlave_t * drv,uint8_t * data,uint16_t length ) { - uint16_t rcrc = 0,ccrc = 0 ; if( (data[0] != drv->ID) && (data[0] != 0x00)) { // µØÖ·´íÎó return -1; } - rcrc = ((uint16_t)data[length- 1] << 8) + (uint16_t)data[length- 2] ; - ccrc = MX_CRC_CALC(data,length-2); - if (rcrc != ccrc ) + if(modbus_m_crc_check(data,length) != MOD_OK) { - log_e("rcrc:%04X,ccrc:%04X\r\n",rcrc,ccrc) ; return -2; } + drv->func = data[1] ; switch (drv->func) diff --git a/middleware/paho.mqtt.embedded-c b/middleware/paho.mqtt.embedded-c new file mode 160000 index 0000000..29ab2aa --- /dev/null +++ b/middleware/paho.mqtt.embedded-c @@ -0,0 +1 @@ +Subproject commit 29ab2aa29c5e47794284376d7f8386cfd54c3eed diff --git a/middleware/sfud/inc/sfud_cfg.h b/middleware/sfud/inc/sfud_cfg.h index bd9dcd8..e9eb806 100644 --- a/middleware/sfud/inc/sfud_cfg.h +++ b/middleware/sfud/inc/sfud_cfg.h @@ -29,6 +29,9 @@ #ifndef _SFUD_CFG_H_ #define _SFUD_CFG_H_ +#ifndef BOOT +#define SFUD_DEBUG_MODE +#endif #define SFUD_DEBUG_MODE #define SFUD_USING_SFDP