static void suspend_monitor_early_suspend(struct early_suspend *h)
{
DUMP_FUN;
sleep_time = LED_FLASH_FAST;
led_ctrl_en = 0;
led_ctrl(1);
}
static void suspend_monitor_late_resume(struct early_suspend *h)
{
DUMP_FUN;
sleep_time = LED_FLASH_SLOW;
led_ctrl(0);
led_ctrl_en = 1;
}
static int suspend_monitor_suspend(struct device *dev)
{
DUMP_FUN_ENTER;
led_ctrl(0);
return 0;
}
static int suspend_monitor_resume(struct device *dev)
{
DUMP_FUN_ENTER;
suspend_times ++;
led_ctrl(1);
return 0;
}
void led_tigger(void)
{
static int status = 0;
status = status % 2;
if(led_ctrl_en)
led_ctrl(status);
if(status == 1)
msleep(sleep_time / 10);
else
msleep(sleep_time);
status++;
}
int thread_led(void *data)
{
#if 1
while(1)
led_tigger();
#else
while(1)
{
if(led_ctrl_en)
led_ctrl(0);
msleep(500);
}
#endif
return 0;
}
void loop(void)
{
// ########### Main task ############
fly_param.length = SubGHz.readData(rx_data,sizeof(rx_data));
fly_param.current_time = millis();
if(fly_param.length > 0)
{
fly_param.last_recv_time = fly_param.current_time;
memcpy(fly_param.motor,&rx_data[7],8);
}
if((fly_param.func_mode>=STATE_ERROR) || (fly_param.func_mode < FLY_STATE_DETECTING_ZERO))
{
while(1){} // error state
}
else
{
fly_param.func_mode = functions[fly_param.func_mode]();
}
#ifdef DEBUG
{
static uint32_t last_print_time = 0;
if(( fly_param.current_time - last_print_time) > 1000)
{
Serial.print(print_mode[fly_param.func_mode]);
Serial.print(",");
Serial.print_long(fly_param.current_time,DEC);
Serial.print("\t");
Serial.print_long(last_print_time,DEC);
Serial.print("\t");
Serial.print_long((long)fly_param.motor[0],DEC);
Serial.print("\t");
Serial.print_long((long)fly_param.motor[1],DEC);
Serial.print("\t");
Serial.print_long((long)fly_param.motor[2],DEC);
Serial.print("\t");
Serial.println_long((long)fly_param.motor[3],DEC);
last_print_time = fly_param.current_time;
}
}
#endif
led_ctrl();
wdt_clear();
}
int secure_main(void)
{
unsigned int csu_reg, i;
for(csu_reg = 0x021C0000; csu_reg < 0x021C00A0; csu_reg = csu_reg + 4)
__REG(csu_reg) = 0x00ff00ff; //0x00330033 for Peripheral access policy
// for CORAM secure policy setting
//csu_reg = 0x021C0000 + 0x**;
//__REG(csu_reg) = 0x00330033;
// for OCRAM secure status setting
csu_reg = 0x020e0028;
__REG(csu_reg) = 0x00003810;
// set for non-secure can access some coprocessor reg
CP15_SET_NSACR(0x00073fff);
CP15_SET_CPACR(0x0fffffff);
// set for SCR
CP15_SET_SCR(0b110000);
//(*((void(*)(void))0x0090b020))();
// copy uboot from iram to sadram
char* dest = (char*)0x27800000;
char* src = (char*)0x0090b000;
for(i=0; i<160096; i++)
*dest++ = *src++;
// Install monitor
monitorInit();
while(1) {
led_ctrl(LED_ON);
asm volatile ("smc #0\n\t");
}
return 0;
}
/*
case 1: server configuration(ip , port) updated
case 2: server offline(No heartbeat)
*/
int client_reconnect(void)
{
static int counter =0;
if (g_sockfd_client > 0){
g_sockfd_client_status = SOCKFD_CLIENT_NULL;
close(g_sockfd_client);
g_sockfd_client = -1;
}
led_ctrl(LED_D3_ALARM_SERVER_STATUS, LED_OFF);
while (FAILURE == client_connect_server()){
if (g_sockfd_client > 0){
g_sockfd_client_status = SOCKFD_CLIENT_NULL;
close(g_sockfd_client);
g_sockfd_client = -1;
}
sys_log(FUNC, LOG_WARN, "Reconnect duration %dS: counter: %d",CLIENT_RECONNECT_DURATION, ++counter);
sleep(CLIENT_RECONNECT_DURATION);
}
return SUCCESS;
}
void connect_uart(void)
{
int i,j;
int ret,len,total_ok=0, total_error=0;
int error_count = 1, error_count2 = 2, error_flag = 0;
int Ten_thousand = 0;
int true_count = 1;
unsigned int count = 0;
char asc[100];
uint8_t buffer[Recieve_Nbyte];
uint8_t count_buffer[4];
unsigned int get_data = 0;
lcd_clrscr();
lcd_disp_string(0, 0, " 直连模式 ");
lcd_disp_hline(0, 13, 128);
lcd_disp_string(30,16, "蓝牙广播中...");
lcd_disp_string(36,36, "等待连接");
serial_write(CONFIG_BT_SERIAL_NUM, "AT+ADV\r\n", sizeof("AT+ADV\r\n"));//开启广播
serial_read(CONFIG_BT_SERIAL_NUM, buffer, 300, 300);
lcd_clrscr();
if (strcmp(buffer, "OK\r\nCONNECTED\r\n") == 0) {
lcd_disp_string(26, 26, "蓝牙连接成功");
led_ctrl(1, 1);
mdelay(1000);
}
else {
lcd_disp_string(26, 26, "蓝牙连接失败");
led_ctrl(1, 0);
mdelay(1000);
return 0;
}
restart:
lcd_clrscr();
lcd_disp_string( 14, 0, "数据发送接收测试" );
lcd_disp_hline(0, 13, 128);
//lcd_disp_string( 0, 16, "接收发送的数据:" );
lcd_disp_string( 0, 16, "数据接收发送的结果:" );
memset( buffer, 0, sizeof(buffer));
len = 0;
while(1) {
if ((ret=serial_read(CONFIG_BT_SERIAL_NUM, buffer, Recieve_Nbyte, 200 )) > 0 ){
printf("ret: %d \n", ret);
for (i=0; i<Recieve_Nbyte; i++) {
printf(" %d ", buffer[i]);
}
printf("\n");
for (i=0; i<Recieve_Nbyte; i++) {
if (buffer[i] == 0x0e) {
true_count++;
}
else {
true_count = 1;
}
if ( true_count == 40) goto out;
}
lcd_disp_string( 30, 40, " " );
for (i=0; i<(Recieve_Nbyte-4); i++) {
if (buffer[i+4] != i) {
error_flag = 1;
dprintf("\n ----error1:%d ----\n", error_count++);
for (j=0; j<Recieve_Nbyte; j++)
dprintf(" %d ", buffer[j]);
dprintf("\n");
}
}
memcpy(count_buffer, buffer, 4);
bcd2asc(count_buffer, 8, asc, 1);
get_data = strtoul(asc,NULL,10);
dprintf("\n -get_data %d ", get_data);
dprintf("\n -count %d ", count);
dprintf("\n ret %d ", ret);
if (get_data != count) {
error_flag = 1;
dprintf("\n error2:%d \n", error_count2++);
}
count ++;
serial_write(CONFIG_BT_SERIAL_NUM, buffer, Recieve_Nbyte);
out:
if (true_count == 40) {
if (error_flag == 0) {
lcd_disp_string( 30, 40, "数据收发成功!!!" );
total_ok++;
}
else {
lcd_disp_string( 30, 40, "数据收发失败!!!" );
total_error++;
}
count = 0;
}
}
if (ret < 0) {
lcd_clrscr();
lcd_disp_string(6, 30, "蓝牙等待断开连接...");
serial_write(CONFIG_BT_SERIAL_NUM, "AT+DISC\r\n" , sizeof("AT+DISC\r\n" ));//断开连接
serial_read(CONFIG_BT_SERIAL_NUM, buffer, 300, 300);
serial_clrbuf(CONFIG_BT_SERIAL_NUM, 1, 1);
lcd_clrscr();
lcd_disp_string(26, 30, "蓝牙已断开连接");
led_ctrl(1, 0);
mdelay(1000);
return;
}
#if 0
if((ret=serial_read(CONFIG_BT_SERIAL_NUM, buffer + len, 1, 200 )) > 0 ){
lcd_disp_string( 0, 30, buffer);
serial_write(CONFIG_BT_SERIAL_NUM, buffer + len, 1);
len ++;
}
if (ret < 0) {
lcd_clrscr();
lcd_disp_string(6, 30, "蓝牙等待断开连接...");
serial_write(CONFIG_BT_SERIAL_NUM, "AT+DISC\r\n" , sizeof("AT+DISC\r\n" ));//断开连接
serial_read(CONFIG_BT_SERIAL_NUM, buffer, 300, 300);
serial_clrbuf(CONFIG_BT_SERIAL_NUM, 1, 1);
lcd_clrscr();
lcd_disp_string(26, 30, "蓝牙已断开连接");
mdelay(1000);
return;
}
if(len >= 16*3){
goto restart;
}
// if ( kb_get_key(1000) == KEY_9) {
// serial_write(CONFIG_BT_SERIAL_NUM, &send_data, 1);
// send_data++;
// }
#endif
}
return 0;
}
void client_process(void)
{
fd_set readfds;
int ret;
int num_read_from_socket;
int num_to_send;
int res = -1;
struct timeval tv;
sys_log(FUNC, LOG_MSG, "start");
while (1)
{
heartbeat_timeout ++;
sys_log(FUNC, LOG_DBG, "heartbeat_timeout = %d heartbeat_s=%d",heartbeat_timeout, heartbeat_s);
if (heartbeat_timeout > heartbeat_s){
sys_log(FUNC, LOG_ERR, "heartbeat timeout --> reconnect");
set_heartbeat(HEARTBEAT_OFFLINE, HEARTBEAT_TIMEOUT);
}
sleep(1);
if (g_reconnect_flag == RECONNECT_ON || g_reconnect_flag == HEARTBEAT_OFFLINE){
if (SUCCESS == client_reconnect()){
g_reconnect_flag = RECONNECT_OFF;
}
}
if (g_sockfd_client <=0){
//sys_log(FUNC, LOG_WARN, "g_sockfd_client");
g_reconnect_flag = RECONNECT_ON;
continue;
}
FD_ZERO(&readfds);
FD_SET(g_sockfd_client, &readfds);
tv.tv_sec = 0;
tv.tv_usec = 1000;
res = select(g_sockfd_client + 1, &readfds, NULL, NULL, &tv);
if (res < 0){
continue;
}else if (res > 0){
if (FD_ISSET(g_sockfd_client, &readfds))
num_read_from_socket = read(g_sockfd_client, buf, 100);
}else{
continue;
}
if(num_read_from_socket <= 0){
continue;
}
sys_log(FUNC, LOG_WARN, "recv %d bytes!\n",num_read_from_socket);
printf_hex(buf,num_read_from_socket);
if (check_head(buf) == -1 ){
continue;
}
g_sockfd_client_status = SOCKFD_CLIENT_OK;
switch (buf[2]){
case PROTOCOL_GET_DEVICE_ATTR:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_DEVICE_ATTR");
if(!check_for_get_device_attr(buf,num_read_from_socket))
{
num_to_send = make_ack_get_device_attr(buf_send);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_SET_DEVICE_ATTR:
sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_DEVICE_ATTR");
if(!check_for_set_device_attr(buf,num_read_from_socket))
{
/*todo set device attr
传感器有好几类，此处只处理报警传感器
*/
set_alarmin_device_attr(buf);
num_to_send = make_ack_set_device_attr(buf_send);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_GET_ALARM_STATUS:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_ALARM_STATUS");
if(!check_for_get_alarm_status(buf,num_read_from_socket))
{
/*alarmin*/
num_to_send = make_ack_get_alarm_status(buf_send, g_alarm_in);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_GET_TIME:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_TIME");
/*TODO ?*/
break;
case PROTOCOL_SET_TIME:
sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_TIME");
if(!check_for_set_time(buf,num_read_from_socket))
{
/* TODO */
/*set time*/
num_to_send = make_ack_set_time(buf_send);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_SET_HEARTBEAT:
sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_HEARTBEAT");
if(!check_for_set_heartbeat(buf,num_read_from_socket))
{
num_to_send = make_ack_set_heartbeat(buf_send,heartbeat_s);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
set_heartbeat(HEARTBEAT_ONLINE, buf[4]);
led_ctrl(LED_D3_ALARM_SERVER_STATUS, LED_ON);
}
break;
case PROTOCOL_GET_UART_QTY:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_UART_QTY");
if(!check_for_get_uart_qty(buf,num_read_from_socket))
{
num_to_send = make_ack_get_uart_qty(buf_send);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_GET_UART_ATTR:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_UART_ATTR");
if (!check_for_get_uart_attr(buf, num_read_from_socket)){
num_to_send = make_ack_get_uart_attr(buf_send, buf);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_SET_UART_ATTR:
sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_UART_ATTR");
if (!check_for_set_uart_attr(buf, num_read_from_socket)){
num_to_send=make_ack_set_uart_attr(buf_send,buf);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_QUERY_UART_SENDBUF:
sys_log(FUNC, LOG_DBG, "PROTOCOL_QUERY_UART_SENDBUF");
if (!check_for_query_uart_sendbuf(buf, num_read_from_socket)){
num_to_send = make_ack_query_uart_sendbuf(buf_send);
/*TODO :buf*/
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_UART_SEND_DATA:
sys_log(FUNC, LOG_DBG, "PROTOCOL_UART_SEND_DATA");
if (!check_for_uart_send_data(buf, num_read_from_socket)){
num_to_send = make_ack_uart_send_data(buf_send);
/*TODO*/
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_SET_UART_RECV_ATTR:
sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_UART_RECV_ATTR");
if (!check_for_set_uart_recv_attr(buf, num_read_from_socket)){
/*TODO*/
}
break;
case PROTOCOL_QUERY_UART_RECV_DATA:
sys_log(FUNC, LOG_DBG, "PROTOCOL_QUERY_UART_RECV_DATA");
if (!check_for_query_uart_recv_data(buf, num_read_from_socket)){
num_to_send = make_ack_query_uart_recv_data(buf_send);
/*TODO*/
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_GET_IO_NUM:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_IO_NUM");
if (!check_for_get_io_num(buf, num_read_from_socket)){
num_to_send = make_ack_get_io_num(buf_send);
/*TODO*/
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_SET_IO:
sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_IO");
if (!check_for_set_io(buf, num_read_from_socket)){
/*TODO*/
set_io_out(buf);
}
break;
case PROTOCOL_GET_IO_STATUS:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_IO_STATUS");
if (!check_for_get_io_status(buf, num_read_from_socket)){
num_to_send = make_ack_get_io_status(buf_send, buf);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_GET_TEMP_NUM:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_TEMP_NUM");
if (!check_for_get_temp_num(buf, num_read_from_socket)){
num_to_send = make_ack_get_temp_num(buf_send);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_SET_TEMP:
sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_TEMP");
set_temp(buf);
break;
case PROTOCOL_GET_TEMP_STATUS:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_TEMP_STATUS");
if (!check_for_get_temp_status(buf, num_read_from_socket)){
num_to_send = make_ack_get_temp_status(buf_send);
ret = write(g_sockfd_client, buf_send, num_to_send);
if(ret != num_to_send)
printf("write socket error!\n");
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
#if 0
case PROTOCOL_GET_SENSOR_TYPE:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_SENSOR_TYPE");
if (!check_for_get_sensor_type(buf, num_read_from_socket)){
num_to_send = make_ack_get_sensor_type(buf_send);
ret = write(g_sockfd_client, buf_send, num_to_send);
if (ret != num_to_send){
printf("write socket error!\n");
}
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
case PROTOCOL_GET_SENSOR_DATA:
sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_SENSOR_DATA");
if (!check_for_get_sensor_data(buf, num_read_from_socket)){
num_to_send = make_ack_get_sensor_data(buf_send);
ret = write(g_sockfd_client, buf_send, num_to_send);
if (ret != num_to_send){
printf("write socket error!\n");
}
sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
printf_hex(buf_send, num_to_send);
}
break;
#endif
default:
sys_log(FUNC, LOG_ERR, "wrong cmd from server ");
break;
}
}
}
