code-image-backup-public/fastbee
1
0
Fork 0
mirror of https://gitee.com/beecue/fastbee.git synced 2025-12-21 10:25:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

更新硬件SDK

Browse Source
This commit is contained in:
kerwincui
2023-03-04 03:44:56 +08:00
parent dcdf6e1b7c
commit e39d3d2f03
1900 changed files with 663153 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

354
sdk/合宙/air780e/csdk/luatos-soc-2022/project/example_gnss/inc/RTE_Device.h Normal file
View File

@@ -0,0 +1,354 @@
#ifndef __RTE_DEVICE_H
#define __RTE_DEVICE_H
#include "ec618.h"
/* Peripheral IO Mode Select, Must Configure First !!!
Note, when receiver works in DMA_MODE, interrupt is also enabled to transfer tailing bytes.
*/
#define POLLING_MODE 0x1
#define DMA_MODE 0x2
#define IRQ_MODE 0x3
#define UNILOG_MODE 0x4
#define RTE_UART0_TX_IO_MODE UNILOG_MODE
#define RTE_UART0_RX_IO_MODE IRQ_MODE
#define USART0_RX_TRIG_LVL (30)
#define RTE_UART1_TX_IO_MODE DMA_MODE
#define RTE_UART1_RX_IO_MODE DMA_MODE
#define RTE_UART2_TX_IO_MODE POLLING_MODE
#define RTE_UART2_RX_IO_MODE DMA_MODE
#define RTE_SPI0_IO_MODE POLLING_MODE
#define RTE_SPI1_IO_MODE POLLING_MODE
#define RTE_I2C0_IO_MODE POLLING_MODE
#define RTE_I2C1_IO_MODE POLLING_MODE
// I2C0 (Inter-integrated Circuit Interface) [Driver_I2C0]
// Configuration settings for Driver_I2C0 in component ::Drivers:I2C
#define RTE_I2C0 1
// { PAD_PIN28}, // 0 : gpio13 / 2 : I2C0 SCL
// { PAD_PIN27}, // 0 : gpio12 / 2 : I2C0 SDA
#define RTE_I2C0_SCL_BIT 28 // AUDIO use 28
#define RTE_I2C0_SCL_FUNC PAD_MUX_ALT2
#define RTE_I2C0_SDA_BIT 27 // AUDIO use 27
#define RTE_I2C0_SDA_FUNC PAD_MUX_ALT2
// DMA
// Tx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_I2C0_DMA_TX_EN 0
#define RTE_I2C0_DMA_TX_REQID DMA_REQUEST_I2C0_TX
// Rx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_I2C0_DMA_RX_EN 0
#define RTE_I2C0_DMA_RX_REQID DMA_REQUEST_I2C0_RX
// I2C1 (Inter-integrated Circuit Interface) [Driver_I2C1]
// Configuration settings for Driver_I2C1 in component ::Drivers:I2C
#define RTE_I2C1 1
// { PAD_PIN20}, // 0 : gpio5 / 2 : I2C1 SCL
// { PAD_PIN19}, // 0 : gpio4 / 2 : I2C1 SDA
#define RTE_I2C1_SCL_BIT 20
#define RTE_I2C1_SCL_FUNC PAD_MUX_ALT2
#define RTE_I2C1_SDA_BIT 19
#define RTE_I2C1_SDA_FUNC PAD_MUX_ALT2
// DMA
// Tx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_I2C1_DMA_TX_EN 1
#define RTE_I2C1_DMA_TX_REQID DMA_REQUEST_I2C1_TX
// Rx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_I2C1_DMA_RX_EN 1
#define RTE_I2C1_DMA_RX_REQID DMA_REQUEST_I2C1_RX
// UART0 (Universal asynchronous receiver transmitter) [Driver_USART0]
// Configuration settings for Driver_USART0 in component ::Drivers:USART
#define RTE_UART0_CTS_PIN_EN 0
#define RTE_UART0_RTS_PIN_EN 0
// { PAD_PIN27}, // 0 : gpio12 / 3 : UART0 RTSn
// { PAD_PIN28}, // 0 : gpio13 / 3 : UART0 CTSn
// { PAD_PIN29}, // 0 : gpio14 / 3 : UART0 RXD
// { PAD_PIN30}, // 0 : gpio15 / 3 : UART0 TXD
#define RTE_UART0_RTS_BIT 27
#define RTE_UART0_RTS_FUNC PAD_MUX_ALT3
#define RTE_UART0_CTS_BIT 28
#define RTE_UART0_CTS_FUNC PAD_MUX_ALT3
#define RTE_UART0_RX_BIT 29
#define RTE_UART0_RX_FUNC PAD_MUX_ALT3
#define RTE_UART0_TX_BIT 30
#define RTE_UART0_TX_FUNC PAD_MUX_ALT3
// DMA
// Tx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_UART0_DMA_TX_REQID DMA_REQUEST_USART0_TX
// Rx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_UART0_DMA_RX_REQID DMA_REQUEST_USART0_RX
// UART1 (Universal asynchronous receiver transmitter) [Driver_USART1]
// Configuration settings for Driver_USART1 in component ::Drivers:USART
#define RTE_UART1_CTS_PIN_EN 0
#define RTE_UART1_RTS_PIN_EN 0
// { PAD_PIN31}, // 0 : gpio16 / 1 : UART1 RTS
// { PAD_PIN32}, // 0 : gpio17 / 1 : UART1 CTS
// { PAD_PIN33}, // 0 : gpio18 / 1 : UART1 RXD
// { PAD_PIN34}, // 0 : gpio19 / 1 : UART1 TXD
#define RTE_UART1_RTS_BIT 31
#define RTE_UART1_RTS_FUNC PAD_MUX_ALT1
#define RTE_UART1_CTS_BIT 32
#define RTE_UART1_CTS_FUNC PAD_MUX_ALT1
#define RTE_UART1_RX_BIT 33
#define RTE_UART1_RX_FUNC PAD_MUX_ALT1
#define RTE_UART1_TX_BIT 34
#define RTE_UART1_TX_FUNC PAD_MUX_ALT1
// DMA
// Tx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_UART1_DMA_TX_REQID DMA_REQUEST_USART1_TX
// Rx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_UART1_DMA_RX_REQID DMA_REQUEST_USART1_RX
// UART2 (Universal asynchronous receiver transmitter) [Driver_USART2]
// Configuration settings for Driver_USART2 in component ::Drivers:USART
#define RTE_UART2_CTS_PIN_EN 0
#define RTE_UART2_RTS_PIN_EN 0
// { PAD_PIN25}, // 0 : gpio10 / 3 : UART2 RXD
// { PAD_PIN26}, // 0 : gpio11 / 3 : UART2 TXD
#define RTE_UART2_RX_BIT 27
#define RTE_UART2_RX_FUNC PAD_MUX_ALT5
#define RTE_UART2_TX_BIT 28
#define RTE_UART2_TX_FUNC PAD_MUX_ALT5
// DMA
// Tx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_UART2_DMA_TX_REQID DMA_REQUEST_USART2_TX
// Rx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_UART2_DMA_RX_REQID DMA_REQUEST_USART2_RX
// SPI0 (Serial Peripheral Interface) [Driver_SPI0]
// Configuration settings for Driver_SPI0 in component ::Drivers:SPI
#define RTE_SPI0 1
// { PAD_PIN23}, // 0 : gpio8 / 1 : SPI0 SSn
// { PAD_PIN24}, // 0 : gpio9 / 1 : SPI0 MOSI
// { PAD_PIN25}, // 0 : gpio10 / 1 : SPI0 MISO
// { PAD_PIN26}, // 0 : gpio11 / 1 : SPI0 SCLK
#define RTE_SPI0_SSN_BIT 23
#define RTE_SPI0_SSN_FUNC PAD_MUX_ALT1
#define RTE_SPI0_MOSI_BIT 24
#define RTE_SPI0_MOSI_FUNC PAD_MUX_ALT1
#define RTE_SPI0_MISO_BIT 25
#define RTE_SPI0_MISO_FUNC PAD_MUX_ALT1
#define RTE_SPI0_SCLK_BIT 26
#define RTE_SPI0_SCLK_FUNC PAD_MUX_ALT1
#define RTE_SPI0_SSN_GPIO_INSTANCE 0
#define RTE_SPI0_SSN_GPIO_INDEX 8
// DMA
// Tx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_SPI0_DMA_TX_REQID DMA_REQUEST_SPI0_TX
// Rx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_SPI0_DMA_RX_REQID DMA_REQUEST_SPI0_RX
// SPI1 (Serial Peripheral Interface) [Driver_SPI1]
// Configuration settings for Driver_SPI1 in component ::Drivers:SPI
#define RTE_SPI1 0
// { PAD_PIN27}, // 0 : gpio12 / 1 : SPI1 SSn
// { PAD_PIN28}, // 0 : gpio13 / 1 : SPI1 MOSI
// { PAD_PIN29}, // 0 : gpio14 / 1 : SPI1 MISO
// { PAD_PIN30}, // 0 : gpio15 / 1 : SPI1 SCLK
// { PAD_PIN31}, // 0 : gpio16 / 4 : SPI1 SSn1
#define RTE_SPI1_SSN_BIT 27
#define RTE_SPI1_SSN_FUNC PAD_MUX_ALT1
#define RTE_SPI1_MOSI_BIT 28
#define RTE_SPI1_MOSI_FUNC PAD_MUX_ALT1
#define RTE_SPI1_MISO_BIT 29
#define RTE_SPI1_MISO_FUNC PAD_MUX_ALT1
#define RTE_SPI1_SCLK_BIT 30
#define RTE_SPI1_SCLK_FUNC PAD_MUX_ALT1
#define RTE_SPI1_SSN_GPIO_INSTANCE 0
#define RTE_SPI1_SSN_GPIO_INDEX 12
#define RTE_SPI1_SSN1_BIT 31
#define RTE_SPI1_SSN1_FUNC PAD_MUX_ALT4
// DMA
// Tx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_SPI1_DMA_TX_REQID DMA_REQUEST_SPI1_TX
// Rx
// Channel <0=>0 <1=>1 <2=>2 <3=>3 <4=>4 <5=>5 <6=>6 <7=>7
#define RTE_SPI1_DMA_RX_REQID DMA_REQUEST_SPI1_RX
// PWM0 Controller [Driver_PWM0]
// Configuration settings for Driver_PWM0 in component ::Drivers:PWM
#define RTE_PWM 1
#define EFUSE_INIT_MODE POLLING_MODE
#define L2CTLS_INIT_MODE POLLING_MODE
#define FLASH_BARE_RW_MODE 1
#define RTE_UART0 1
#define RTE_UART1 1
#define RTE_UART2 1
/* to enable external thermal */
#define EXTERNAL_NTC_EXIST 0
#if (RTE_UART1 == 1)
#define UART1_DTR_PAD_INDEX 26 // GPIO11
#define UART1_DTR_GPIO_INSTANCE 0
#define UART1_DTR_GPIO_PIN 11
#define UART1_RI_PAD_INDEX 44 // AONIO 4 = GPIO24
#define UART1_RI_GPIO_INSTANCE 1
#define UART1_RI_GPIO_PIN 8
#define UART1_RI_PWM_INSTANCE 1
#define UART1_RI_PWM_CLK_ID FCLK_TIMER1
#define UART1_RI_PWM_CLK_SEL FCLK_TIMER1_SEL_26M
#define UART1_DCD_PAD_INDEX 45 // AONIO 5 = GPIO25
#define UART1_DCD_GPIO_INSTANCE 1
#define UART1_DCD_GPIO_PIN 9
#endif
#if (RTE_UART2 == 1)
#define UART2_DTR_PAD_INDEX 25 // GPIO10
#define UART2_DTR_GPIO_INSTANCE 0
#define UART2_DTR_GPIO_PIN 10
#define UART2_RI_PAD_INDEX 43 // AONIO 3 = GPIO23
#define UART2_RI_GPIO_INSTANCE 1
#define UART2_RI_GPIO_PIN 7
#define UART2_RI_PWM_INSTANCE 0
#define UART2_RI_PWM_CLK_ID FCLK_TIMER0
#define UART2_RI_PWM_CLK_SEL FCLK_TIMER0_SEL_26M
#define UART2_DCD_PAD_INDEX 47 // AONIO 7 = GPIO27
#define UART2_DCD_GPIO_INSTANCE 1
#define UART2_DCD_GPIO_PIN 11
#endif
#define NETLIGHT_PAD_INDEX 46 // AONIO 6 = GPIO26
#define NETLIGHT_PAD_ALT_FUNC PAD_MUX_ALT5
#define NETLIGHT_PWM_INSTANCE 3
//USIM1 OPTION1
#define USIM1_URST_OP1_PAD_INDEX 19 // GPIO4
#define USIM1_URST_OP1_GPIO_INSTANCE 0
#define USIM1_URST_OP1_GPIO_PIN 4
#define USIM1_UCLK_OP1_PAD_INDEX 20 // GPIO5
#define USIM1_UCLK_OP1_GPIO_INSTANCE 0
#define USIM1_UCLK_OP1_GPIO_PIN 5
#define USIM1_UIO_OP1_PAD_INDEX 21 // GPIO6
#define USIM1_UIO_OP1_GPIO_INSTANCE 0
#define USIM1_UIO_OP1_GPIO_PIN 6
//USIM1 OPTION2
#define USIM1_UIO_OP2_PAD_INDEX 27 // GPIO12
#define USIM1_UIO_OP2_GPIO_INSTANCE 0
#define USIM1_UIO_OP2_GPIO_PIN 12
#define USIM1_URST_OP2_PAD_INDEX 28 // GPIO13
#define USIM1_URST_OP2_GPIO_INSTANCE 0
#define USIM1_URST_OP2_GPIO_PIN 13
#define USIM1_UCLK_OP2_PAD_INDEX 29 // GPIO14
#define USIM1_UCLK_OP2_GPIO_INSTANCE 0
#define USIM1_UCLK_OP2_GPIO_PIN 14
//USIM1 clock latched by AONIO, for example, use AONIO-6 test on EVB
#define AONIO_6_PAD_INDEX 46 // AONIO 6 = GPIO26
#define AONIO_6_GPIO_INSTANCE 1
#define AONIO_6_GPIO_PIN 10
#define RTE_CSPI0 0
#define RTE_CSPI0_MCLK_PAD_ADDR 39
#define RTE_CSPI0_MCLK_FUNC PAD_MUX_ALT1
#define RTE_CSPI0_PCLK_PAD_ADDR 35
#define RTE_CSPI0_PCLK_FUNC PAD_MUX_ALT1
#define RTE_CSPI0_CS_PAD_ADDR 36
#define RTE_CSPI0_CS_FUNC PAD_MUX_ALT1
#define RTE_CSPI0_SDO0_PAD_ADDR 37
#define RTE_CSPI0_SDO0_FUNC PAD_MUX_ALT1
#define RTE_CSPI0_SDO1_PAD_ADDR 38
#define RTE_CSPI0_SDO1_FUNC PAD_MUX_ALT1
// DMA CSPI0 Request ID
#define RTE_CSPI0_DMA_RX_REQID DMA_REQUEST_I2S0_RX
// CSPI1 Configuration
#define RTE_CSPI1 1
#define RTE_CSPI1_MCLK_PAD_ADDR 18
#define RTE_CSPI1_MCLK_FUNC PAD_MUX_ALT1
#define RTE_CSPI1_PCLK_PAD_ADDR 19
#define RTE_CSPI1_PCLK_FUNC PAD_MUX_ALT1
#define RTE_CSPI1_CS_PAD_ADDR 20
#define RTE_CSPI1_CS_FUNC PAD_MUX_ALT1
#define RTE_CSPI1_SDO0_PAD_ADDR 21
#define RTE_CSPI1_SDO0_FUNC PAD_MUX_ALT1
#define RTE_CSPI1_SDO1_PAD_ADDR 22
#define RTE_CSPI1_SDO1_FUNC PAD_MUX_ALT1
// DMA CSPI1 Request ID
#define RTE_CSPI1_DMA_RX_REQID DMA_REQUEST_I2S1_RX
#endif /* __RTE_DEVICE_H */

40
sdk/合宙/air780e/csdk/luatos-soc-2022/project/example_gnss/inc/lbsLoc.h Normal file
View File

@@ -0,0 +1,40 @@
#ifndef _EXAMPLE_SOCKET_H
#define _EXAMPLE_SOCKET_H
#include "commontypedef.h"
#define AM_LOCATION_SERVICE_LOCATION_BCD_LEN 5
#define AM_LOCATION_SERVICE_RCV_TIMEOUT 15
#ifdef PACK_STRUCT_USE_INCLUDES
#include "arch/bpstruct.h"
#endif
PACK_STRUCT_BEGIN
struct am_location_service_rsp_data_t
{
PACK_STRUCT_FLD_8(u8_t result);
PACK_STRUCT_FIELD(u8_t latitude[AM_LOCATION_SERVICE_LOCATION_BCD_LEN]);
PACK_STRUCT_FIELD(u8_t longitude[AM_LOCATION_SERVICE_LOCATION_BCD_LEN]);
PACK_STRUCT_FLD_8(u8_t year);
PACK_STRUCT_FLD_8(u8_t month);
PACK_STRUCT_FLD_8(u8_t day);
PACK_STRUCT_FLD_8(u8_t hour);
PACK_STRUCT_FLD_8(u8_t minute);
PACK_STRUCT_FLD_8(u8_t second);
} PACK_STRUCT_STRUCT;
PACK_STRUCT_END
#ifdef PACK_STRUCT_USE_INCLUDES
#include "arch/epstruct.h"
#endif
#endif

332
sdk/合宙/air780e/csdk/luatos-soc-2022/project/example_gnss/src/example_main.c Normal file
View File

@@ -0,0 +1,332 @@
/*
* Copyright © 2014 Kosma Moczek <kosma@cloudyourcar.com>
* This program is free software. It comes without any warranty, to the extent
* permitted by applicable law. You can redistribute it and/or modify it under
* the terms of the Do What The Fuck You Want To Public License, Version 2, as
* published by Sam Hocevar. See the COPYING file for more details.
*/
#include "minmea.h"
#include "common_api.h"
#include "luat_rtos.h"
#include "luat_debug.h"
#include "luat_uart.h"
#include "luat_gpio.h"
#include "HTTPClient.h"
#include "luat_mobile.h"
// 注意：780EG内部gps与串口2相连
#define UART_ID 2
#define HTTP_RECV_BUF_SIZE (6000)
#define HTTP_HEAD_BUF_SIZE (800)
#define TEST_HOST "http://download.openluat.com/9501-xingli/HXXT_GPS_BDS_AGNSS_DATA.dat"
static HttpClientContext gHttpClient = {0};
static luat_rtos_task_handle gps_task_handle;
static luat_rtos_semaphore_t net_semaphore_handle;
static luat_rtos_task_handle https_task_handle;
void mobile_event_callback(LUAT_MOBILE_EVENT_E event, uint8_t index, uint8_t status){
if (event == LUAT_MOBILE_EVENT_NETIF && status == LUAT_MOBILE_NETIF_LINK_ON){
LUAT_DEBUG_PRINT("network ready");
luat_rtos_semaphore_release(net_semaphore_handle);
}
}
static int libminmea_parse_data(const char* data, size_t len) {
size_t prev = 0;
static char nmea_tmp_buff[86] = {0}; // nmea 最大长度82,含换行符
for (size_t offset = 0; offset < len; offset++)
{
// \r == 0x0D \n == 0x0A
if (data[offset] == 0x0A) {
// 最短也需要是 OK\r\n
// 应该\r\n的
// 太长了
if (offset - prev < 3 || data[offset - 1] != 0x0D || offset - prev > 82) {
prev = offset + 1;
continue;
}
memcpy(nmea_tmp_buff, data + prev, offset - prev - 1);
nmea_tmp_buff[offset - prev - 1] = 0x00;
if(strstr(nmea_tmp_buff, "GNRMC"))
{
parse_nmea((const char*)nmea_tmp_buff);
}
prev = offset + 1;
}
}
return 0;
}
void luat_uart_recv_cb(int uart_id, uint32_t data_len){
char* data_buff = malloc(data_len+1);
memset(data_buff,0,data_len+1);
luat_uart_read(uart_id, data_buff, data_len);
LUAT_DEBUG_PRINT("uart_id:%d gnssdata:\n %s",uart_id,data_buff);
libminmea_parse_data(data_buff, data_len);
free(data_buff);
}
static INT32 httpGetData(CHAR *getUrl, CHAR *buf, UINT32 len, UINT32 *dataLen)
{
HTTPResult result = HTTP_INTERNAL;
HttpClientData clientData = {0};
UINT32 count = 0;
uint16_t headerLen = 0;
LUAT_DEBUG_ASSERT(buf != NULL,0,0,0);
clientData.headerBuf = malloc(HTTP_HEAD_BUF_SIZE);
clientData.headerBufLen = HTTP_HEAD_BUF_SIZE;
clientData.respBuf = buf;
clientData.respBufLen = len;
result = httpSendRequest(&gHttpClient, getUrl, HTTP_GET, &clientData);
LUAT_DEBUG_PRINT("send request result=%d", result);
if (result != HTTP_OK)
goto exit;
do {
LUAT_DEBUG_PRINT("recvResponse loop.");
memset(clientData.headerBuf, 0, clientData.headerBufLen);
memset(clientData.respBuf, 0, clientData.respBufLen);
result = httpRecvResponse(&gHttpClient, &clientData);
if(result == HTTP_OK || result == HTTP_MOREDATA){
headerLen = strlen(clientData.headerBuf);
if(headerLen > 0)
{
LUAT_DEBUG_PRINT("total content length=%d", clientData.recvContentLength);
}
if(clientData.blockContentLen > 0)
{
LUAT_DEBUG_PRINT("response content:{%s}", (uint8_t*)clientData.respBuf);
}
count += clientData.blockContentLen;
*dataLen = *dataLen + count;
LUAT_DEBUG_PRINT("has recv=%d", count);
}
} while (result == HTTP_MOREDATA || result == HTTP_CONN);
LUAT_DEBUG_PRINT("result=%d", result);
if (gHttpClient.httpResponseCode < 200 || gHttpClient.httpResponseCode > 404)
{
LUAT_DEBUG_PRINT("invalid http response code=%d",gHttpClient.httpResponseCode);
} else if (count == 0 || count != clientData.recvContentLength) {
LUAT_DEBUG_PRINT("data not receive complete");
} else {
LUAT_DEBUG_PRINT("receive success");
}
exit:
free(clientData.headerBuf);
return result;
}
static void task_test_https(void *param)
{
luat_rtos_semaphore_create(&net_semaphore_handle, 1);
char *recvBuf = malloc(HTTP_RECV_BUF_SIZE);
HTTPResult result = HTTP_INTERNAL;
uint32_t dataLen = 0;
luat_mobile_event_register_handler(mobile_event_callback);
gHttpClient.timeout_s = 2;
gHttpClient.timeout_r = 20;
luat_rtos_semaphore_take(net_semaphore_handle, LUAT_WAIT_FOREVER);
result = httpConnect(&gHttpClient, TEST_HOST);
if (result == HTTP_OK)
{
result = httpGetData(TEST_HOST, recvBuf, HTTP_RECV_BUF_SIZE, &dataLen);
httpClose(&gHttpClient);
if (result == HTTP_OK)
{
LUAT_DEBUG_PRINT("http client get data success %d", dataLen);
for (size_t i = 0; i < dataLen; i = i + 512)
{
if (i + 512 < dataLen)
luat_uart_write(UART_ID, &recvBuf[i], 512);
else
luat_uart_write(UART_ID, &recvBuf[i], dataLen - i);
luat_rtos_task_sleep(100);
}
}
demo_udp_init();
}
else
{
LUAT_DEBUG_PRINT("http client connect error");
}
memset(recvBuf, 0x00, HTTP_RECV_BUF_SIZE);
free(recvBuf);
luat_rtos_task_delete(https_task_handle);
}
static void task_demo_https(void)
{
// https所需的栈空间会大很多
luat_rtos_task_create(&https_task_handle, 32*1024, 20, "https", task_test_https, NULL, NULL);
}
//启动task_demoF_init，启动位置任务2级
static void task_test_gps(void *param)
{
luat_uart_t uart = {
.id = UART_ID,
.baud_rate = 115200,
.data_bits = 8,
.stop_bits = 1,
.parity = 0
};
luat_uart_pre_setup(UART_ID, 1);
luat_uart_setup(&uart);
luat_uart_ctrl(UART_ID, LUAT_UART_SET_RECV_CALLBACK, luat_uart_recv_cb);
// gps电源
luat_gpio_cfg_t cfg = {0};
cfg.pin = HAL_GPIO_13;
cfg.mode = LUAT_GPIO_OUTPUT;
cfg.output_level = 1;
cfg.alt_fun = 4;
luat_gpio_open(&cfg);
luat_rtos_task_sleep(200);
while (1)
{
char cmd2[] = "$AIDINFO";
luat_uart_write(UART_ID, cmd2, strlen(cmd2));
luat_rtos_task_sleep(5000);
}
luat_rtos_task_delete(gps_task_handle);
}
#define INDENT_SPACES " "
int parse_nmea(const char *gpsdata)
{
switch (minmea_sentence_id(gpsdata, false)) {
case MINMEA_SENTENCE_RMC: {
struct minmea_sentence_rmc frame;
if (minmea_parse_rmc(&frame, gpsdata)) {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxRMC: raw coordinates and speed: (%d/%d,%d/%d) %d/%d\n",
frame.latitude.value, frame.latitude.scale,
frame.longitude.value, frame.longitude.scale,
frame.speed.value, frame.speed.scale);
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxRMC fixed-point coordinates and speed scaled to three decimal places: (%d,%d) %d\n",
minmea_rescale(&frame.latitude, 1000),
minmea_rescale(&frame.longitude, 1000),
minmea_rescale(&frame.speed, 1000));
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxRMC floating point degree coordinates and speed: (%f,%f) %f\n",
minmea_tocoord(&frame.latitude),
minmea_tocoord(&frame.longitude),
minmea_tofloat(&frame.speed));
}
else {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxRMC sentence is not parsed\n");
}
} break;
case MINMEA_SENTENCE_GGA: {
struct minmea_sentence_gga frame;
if (minmea_parse_gga(&frame, gpsdata)) {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGGA: fix quality: %d\n", frame.fix_quality);
}
else {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGGA sentence is not parsed\n");
}
} break;
case MINMEA_SENTENCE_GST: {
struct minmea_sentence_gst frame;
if (minmea_parse_gst(&frame, gpsdata)) {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGST: raw latitude,longitude and altitude error deviation: (%d/%d,%d/%d,%d/%d)\n",
frame.latitude_error_deviation.value, frame.latitude_error_deviation.scale,
frame.longitude_error_deviation.value, frame.longitude_error_deviation.scale,
frame.altitude_error_deviation.value, frame.altitude_error_deviation.scale);
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGST fixed point latitude,longitude and altitude error deviation"
" scaled to one decimal place: (%d,%d,%d)\n",
minmea_rescale(&frame.latitude_error_deviation, 10),
minmea_rescale(&frame.longitude_error_deviation, 10),
minmea_rescale(&frame.altitude_error_deviation, 10));
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGST floating point degree latitude, longitude and altitude error deviation: (%f,%f,%f)",
minmea_tofloat(&frame.latitude_error_deviation),
minmea_tofloat(&frame.longitude_error_deviation),
minmea_tofloat(&frame.altitude_error_deviation));
}
else {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGST sentence is not parsed\n");
}
} break;
case MINMEA_SENTENCE_GSV: {
struct minmea_sentence_gsv frame;
if (minmea_parse_gsv(&frame, gpsdata)) {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGSV: message %d of %d\n", frame.msg_nr, frame.total_msgs);
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGSV: satellites in view: %d\n", frame.total_sats);
for (int i = 0; i < 4; i++)
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGSV: sat nr %d, elevation: %d, azimuth: %d, snr: %d dbm\n",
frame.sats[i].nr,
frame.sats[i].elevation,
frame.sats[i].azimuth,
frame.sats[i].snr);
}
else {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxGSV sentence is not parsed\n");
}
} break;
case MINMEA_SENTENCE_VTG: {
struct minmea_sentence_vtg frame;
if (minmea_parse_vtg(&frame, gpsdata)) {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxVTG: true track degrees = %f\n",
minmea_tofloat(&frame.true_track_degrees));
LUAT_DEBUG_PRINT(INDENT_SPACES " magnetic track degrees = %f\n",
minmea_tofloat(&frame.magnetic_track_degrees));
LUAT_DEBUG_PRINT(INDENT_SPACES " speed knots = %f\n",
minmea_tofloat(&frame.speed_knots));
LUAT_DEBUG_PRINT(INDENT_SPACES " speed kph = %f\n",
minmea_tofloat(&frame.speed_kph));
}
else {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxVTG sentence is not parsed\n");
}
} break;
case MINMEA_SENTENCE_ZDA: {
struct minmea_sentence_zda frame;
if (minmea_parse_zda(&frame, gpsdata)) {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxZDA: %d:%d:%d %02d.%02d.%d UTC%+03d:%02d\n",
frame.time.hours,
frame.time.minutes,
frame.time.seconds,
frame.date.day,
frame.date.month,
frame.date.year,
frame.hour_offset,
frame.minute_offset);
}
else {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxZDA sentence is not parsed\n");
}
} break;
case MINMEA_INVALID: {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxxxx sentence is not valid\n");
} break;
default: {
LUAT_DEBUG_PRINT(INDENT_SPACES "$xxxxx sentence is not parsed\n");
} break;
}
return 0;
}
static void task_demo_gps(void)
{
luat_rtos_task_create(&gps_task_handle, 1024 * 20, 20, "gps", task_test_gps, NULL, NULL);
}
INIT_TASK_EXPORT(task_demo_gps,"1");
INIT_TASK_EXPORT(task_demo_https, "2");
/* vim: set ts=4 sw=4 et: */

325
sdk/合宙/air780e/csdk/luatos-soc-2022/project/example_gnss/src/lbsLoc.c Normal file
View File

@@ -0,0 +1,325 @@
#include "common_api.h"
#include "sockets.h"
#include "dns.h"
#include "lwip/ip4_addr.h"
#include "netdb.h"
#include "luat_debug.h"
#include "luat_rtos.h"
#include "luat_mobile.h"
#include "string.h"
#include "lbsLoc.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#define DEMO_SERVER_UDP_IP "bs.openluat.com" // 基站定位网址
#define DEMO_SERVER_UDP_PORT 12411 // 端口
/// @brief 合宙IOT 项目productkey ，必须加上，否则定位失败
static char *productKey = "vQfJesoQdXDK8X1sXkYg0KTU42UBhdjh";
static luat_rtos_task_handle lbsloc_task_handle = NULL;
static uint8_t lbsloc_task_tatus = 0;
static bool ddddtoddmm(char *location, char *test)
{
char *integer = NULL;
char *fraction = NULL;
char tmpstr[15] = {0};
float tmp = 0;
integer = strtok(location, ".");
if(integer)
{
fraction = strtok(NULL, ".");
sprintf(tmpstr, "0.%d", atoi(fraction));
tmp = atof(tmpstr) * 60;
tmp = atoi(integer) * 100 + tmp;
memset(tmpstr, 0x00, 15);
sprintf(tmpstr, "%f", tmp);
memcpy(test, tmpstr, strlen(tmpstr) + 1);
return true;
}
return false;
}
/// @brief 把string 转换为BCD 编码
/// @param arr 字符串输入
/// @param len 长度
/// @param outPut 输出
/// @return
static uint8_t imeiToBcd(uint8_t *arr, uint8_t len, uint8_t *outPut)
{
if (len % 2 != 0)
{
arr[len] = 0x0f;
}
uint8_t tmp = 0;
for (uint8_t j = 0; j < len; j = j + 2)
{
outPut[tmp] = (arr[j] & 0x0f) << 4 | (arr[j + 1] & 0x0f);
tmp++;
}
for (uint8_t i = 0; i < 8; i++)
{
outPut[i] = (outPut[i] % 0x10) * 0x10 + (outPut[i] - (outPut[i] % 0x10)) / 0x10;
}
return 0;
}
/// @brief BCD ->> str
/// @param pOutBuffer
/// @param pInBuffer
/// @param nInLen 长度
/// @return
static uint32_t location_service_bcd_to_str(uint8_t *pOutBuffer, uint8_t *pInBuffer, uint32_t nInLen)
{
uint32_t len = 0;
uint8_t ch;
uint8_t *p = pOutBuffer;
uint32_t i = 0;
if (pOutBuffer == NULL || pInBuffer == NULL || nInLen == 0)
{
return 0;
}
for (i = 0; i < nInLen; i++)
{
ch = pInBuffer[i] & 0x0F;
if (ch == 0x0F)
{
break;
}
*pOutBuffer++ = ch + '0';
ch = (pInBuffer[i] >> 4) & 0x0F;
if (ch == 0x0F)
{
break;
}
*pOutBuffer++ = ch + '0';
}
len = pOutBuffer - p;
return len;
}
static bool location_service_parse_response(struct am_location_service_rsp_data_t *response, uint8_t *latitude, uint8_t *longitude,
uint16_t *year, uint8_t *month, uint8_t *day, uint8_t *hour, uint8_t *minute, uint8_t *second)
{
uint8_t loc[20] = {0};
uint32_t len = 0;
if (response == NULL || latitude == NULL || longitude == NULL || year == NULL || month == NULL || day == NULL || hour == NULL || minute == NULL || second == NULL)
{
LUAT_DEBUG_PRINT("location_service_parse_response: invalid parameter");
return FALSE;
}
if (!(response->result == 0 || response->result == 0xFF))
{
LUAT_DEBUG_PRINT("location_service_parse_response: result fail %d", response->result);
return FALSE;
}
// latitude
len = location_service_bcd_to_str(loc, response->latitude, AM_LOCATION_SERVICE_LOCATION_BCD_LEN);
if (len <= 0)
{
LUAT_DEBUG_PRINT("location_service_parse_response: latitude fail");
return FALSE;
}
strncat((char *)latitude, (char *)loc, 3);
strncat((char *)latitude, ".", 2);
strncat((char *)latitude, (char *)(loc + 3), len - 3);
len = location_service_bcd_to_str(loc, response->longitude, AM_LOCATION_SERVICE_LOCATION_BCD_LEN);
if (len <= 0)
{
LUAT_DEBUG_PRINT("location_service_parse_response: longitude fail");
return FALSE;
}
strncat((char *)longitude, (char *)loc, 3);
strncat((char *)longitude, (char *)".", 2);
strncat((char *)longitude, (char *)(loc + 3), len - 3);
*year = response->year + 2000;
*month = response->month;
*day = response->day;
*hour = response->hour;
*minute = response->minute;
*second = response->second;
return TRUE;
}
static void lbsloc_task(void *arg)
{
lbsloc_task_tatus = 1;
ip_addr_t remote_ip;
struct sockaddr_in name;
socklen_t sockaddr_t_size = sizeof(name);
int ret;
struct timeval to;
int socket_id = -1;
struct hostent dns_result;
struct hostent *p_result;
int h_errnop, read_len;
struct am_location_service_rsp_data_t locationServiceResponse;
uint8_t latitude[20] = {0}; // 经度
uint8_t longitude[20] = {0}; // 维度
uint16_t year = 0; // 年
uint8_t month = 0; // 月
uint8_t day = 0; // 日
uint8_t hour = 0; // 小时
uint8_t minute = 0; // 分钟
uint8_t second = 0; // 秒
uint8_t lbsLocReqBuf[176] = {0};
memset(lbsLocReqBuf, 0, 176);
uint8_t sendLen = 0;
lbsLocReqBuf[sendLen++] = strlen(productKey);
memcpy(&lbsLocReqBuf[sendLen], (UINT8 *)productKey, strlen(productKey));
sendLen = sendLen + strlen(productKey);
lbsLocReqBuf[sendLen++] = 0x28;
CHAR imeiBuf[16];
memset(imeiBuf, 0, sizeof(imeiBuf));
luat_mobile_get_imei(0, imeiBuf, 16);
uint8_t imeiBcdBuf[8] = {0};
imeiToBcd((uint8_t *)imeiBuf, 15, imeiBcdBuf);
memcpy(&lbsLocReqBuf[sendLen], imeiBcdBuf, 8);
sendLen = sendLen + 8;
CHAR muidBuf[64];
memset(muidBuf, 0, sizeof(muidBuf));
luat_mobile_get_muid(muidBuf, sizeof(muidBuf));
lbsLocReqBuf[sendLen++] = strlen(muidBuf);
memcpy(&lbsLocReqBuf[sendLen], (UINT8 *)muidBuf, strlen(muidBuf));
sendLen = sendLen + strlen(muidBuf);
luat_mobile_cell_info_t cell_info;
memset(&cell_info, 0, sizeof(cell_info));
luat_mobile_get_cell_info(&cell_info);
lbsLocReqBuf[sendLen++] = 0x01;
lbsLocReqBuf[sendLen++] = (cell_info.lte_service_info.tac >> 8) & 0xFF;
lbsLocReqBuf[sendLen++] = cell_info.lte_service_info.tac & 0xFF;
lbsLocReqBuf[sendLen++] = (cell_info.lte_service_info.mcc >> 8) & 0xFF;
lbsLocReqBuf[sendLen++] = cell_info.lte_service_info.mcc & 0XFF;
uint8_t mnc = cell_info.lte_service_info.mnc;
if (mnc > 10)
{
CHAR buf[3] = {0};
snprintf(buf, 3, "%02x", mnc);
int ret1 = atoi(buf);
lbsLocReqBuf[sendLen++] = ret1;
}
else
{
lbsLocReqBuf[sendLen++] = mnc;
}
int16_t sRssi;
uint8_t retRssi;
sRssi = cell_info.lte_service_info.rssi;
if (sRssi <= -113)
{
retRssi = 0;
}
else if (sRssi < -52)
{
retRssi = (sRssi + 113) >> 1;
}
else
{
retRssi = 31;
}
lbsLocReqBuf[sendLen++] = retRssi;
lbsLocReqBuf[sendLen++] = (cell_info.lte_service_info.cid >> 24) & 0xFF;
lbsLocReqBuf[sendLen++] = (cell_info.lte_service_info.cid >> 16) & 0xFF;
lbsLocReqBuf[sendLen++] = (cell_info.lte_service_info.cid >> 8) & 0xFF;
lbsLocReqBuf[sendLen++] = cell_info.lte_service_info.cid & 0xFF;
char hostname[128] = {0};
ret = lwip_gethostbyname_r(DEMO_SERVER_UDP_IP, &dns_result, hostname, 128, &p_result, &h_errnop);
if (!ret)
{
remote_ip = *((ip_addr_t *)dns_result.h_addr_list[0]);
}
else
{
luat_rtos_task_sleep(1000);
LUAT_DEBUG_PRINT("dns fail");
lbsloc_task_tatus = 0;
luat_rtos_task_delete(lbsloc_task_handle);
return;
}
socket_id = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
struct timeval timeout;
timeout.tv_sec = AM_LOCATION_SERVICE_RCV_TIMEOUT;
timeout.tv_usec = 0;
setsockopt(socket_id, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
memset(&name, 0, sizeof(name));
name.sin_family = AF_INET;
name.sin_addr.s_addr = remote_ip.u_addr.ip4.addr;
name.sin_port = htons(DEMO_SERVER_UDP_PORT);
ret = sendto(socket_id, lbsLocReqBuf, sendLen, 0, (const struct sockaddr *)&name, sockaddr_t_size);
if (ret == sendLen)
{
LUAT_DEBUG_PRINT("lbsLocSendRequest send lbsLoc request success");
ret = recv(socket_id, &locationServiceResponse, sizeof(struct am_location_service_rsp_data_t), 0);
if (sizeof(struct am_location_service_rsp_data_t) == ret)
{
if (location_service_parse_response(&locationServiceResponse, latitude, longitude, &year, &month, &day, &hour, &minute, &second) == TRUE)
{
LUAT_DEBUG_PRINT("latitude:%s,longitude:%s,year:%d,month:%d,day:%d,hour:%d,minute:%d,second:%d\r\n", latitude, longitude, year, month, day, hour, minute, second);
char data_buf[60] = {0};
snprintf(data_buf, 60, "$AIDTIME,%d,%d,%d,%d,%d,%d,000\r\n", year, month, day, hour, minute, second);
luat_uart_write(2, data_buf, strlen(data_buf));
LUAT_DEBUG_PRINT("this is test1 %s", data_buf);
luat_rtos_task_sleep(200);
memset(data_buf, 0x00, 60);
char lat[20] = {0};
char lng[20] = {0};
ddddtoddmm(latitude, lat);
LUAT_DEBUG_PRINT("this is test2 %s", lat);
ddddtoddmm(longitude, lng);
LUAT_DEBUG_PRINT("this is test3 %s", lng);
snprintf(data_buf, 60, "$AIDPOS,%s,N,%s,E,1.0\r\n", lat, lng);
LUAT_DEBUG_PRINT("this is test4 %s", data_buf);
luat_uart_write(2, data_buf, strlen(data_buf));
}
else
{
LUAT_DEBUG_PRINT("location_service_task: rcv response, but process fail");
}
}
}
else
{
LUAT_DEBUG_PRINT("lbsLocSendRequest send lbsLoc request fail");
}
memset(latitude, 0, 20);
memset(longitude, 0, 20);
year = 0;
month = 0;
day = 0;
hour = 0;
minute = 0;
second = 0;
LUAT_DEBUG_PRINT("socket quit");
close(socket_id);
socket_id = -1;
lbsloc_task_tatus = 0;
luat_rtos_task_delete(lbsloc_task_handle);
}
void demo_udp_init(void)
{
if (lbsloc_task_handle == NULL || lbsloc_task_tatus == 0)
luat_rtos_task_create(&lbsloc_task_handle, 4 * 2048, 80, "udp", lbsloc_task, NULL, NULL);
else
LUAT_DEBUG_PRINT("lbsloc task create fail");
}

24
sdk/合宙/air780e/csdk/luatos-soc-2022/project/example_gnss/xmake.lua Normal file
View File

@@ -0,0 +1,24 @@
local TARGET_NAME = "example_gnss"
local LIB_DIR = "$(buildir)/".. TARGET_NAME .. "/"
local LIB_NAME = "lib" .. TARGET_NAME .. ".a "
target(TARGET_NAME)
set_kind("static")
set_targetdir(LIB_DIR)
includes(SDK_TOP .. "/thirdparty/minmea")
add_deps("minmea")
includes(SDK_TOP .. "/thirdparty/httpclient")
add_deps("httpclient")
--加入代码和头文件
add_includedirs("./inc",{public = true})
add_files("./src/*.c",{public = true})
--路径可以随便写,可以加任意路径的代码,下面代码等效上方代码
-- add_includedirs(SDK_TOP .. "project/" .. TARGET_NAME .. "/inc",{public = true})
-- add_files(SDK_TOP .. "project/" .. TARGET_NAME .. "/src/*.c",{public = true})
--可以继续增加add_includedirs和add_files
--自动链接
LIB_USER = LIB_USER .. SDK_TOP .. LIB_DIR .. LIB_NAME .. " "
--甚至可以加入自己的库
target_end()