int main(void) { uint32_t err_code; bool erase_bonds; /* Initialise debugging port */ debug_init(); debug_printf("Debug port opened... Initialising...\r\n"); /* Initialise GPIO subsystem */ err_code = nrf_drv_gpiote_init(); if (err_code == NRF_SUCCESS) debug_printf("GPIOTE initialised!\r\n"); else { debug_printf("Ooops.. Something is wrong with initialising GPIOTE..\r\n"); APP_ERROR_CHECK(err_code); } led_init(); adc_init(); debug_printf("Visual feedback should be active!\r\n"); timers_init(); ble_stack_init(); beacon_adv_init(); device_manager_init(erase_bonds); gap_params_init(); advertising_init(); services_init(); conn_params_init(); application_timers_start(); advertising_start(); led_rgb_set(LED_RED, true); led_rgb_set(LED_GREEN, false); led_rgb_set(LED_BLUE, false); debug_printf("Readyyy.. \r\n"); while (true) { power_manage(); } }
int main(int argc, char** argv) { uint32_t led_colors = 0; uint8_t at_parm_test[10]; unsigned once; uint32_t i = 0; uint8_t canPrescaler = 0; uint8_t* uart_tx_packet = 0; uint8_t* uart_rx_packet; uint32_t old_loadcell_data; uint16_t timeStep = 1; clock_init(); pin_init(); led_init(); timers_init(); state_init(); uart_init(); // Set up UART2 for 115200 baud. There's no round() on the dsPICs, so we implement our own. double brg = (double) 140000000 / 2.0 / 16.0 / 115200.0 - 1.0; if (brg - floor(brg) >= 0.5) { brg = ceil(brg); } else { brg = floor(brg); } // Uart2Init (brg); // Init UART 2 as 115200 baud/s loadcell_init(); loadcell_start(); led_rgb_off(); led_rgb_set(50, 0, 100); can_state.init_return = RET_UNKNOWN; if (can_init()) { while (1); } timer_state.prev_systime = 0; timer_state.systime = 0; #ifdef CONF71 // Start Reading the int pin on IMU mpuData.startData = 0; if (IMU_Init(400000, 70000000) == 0) { // imu_state.init_return = RET_OK; mpuData.startData = 1; } else { //imu_state.init_return = RET_ERROR; } #endif for (;;) { if (timer_state.systime != timer_state.prev_systime) { timer_state.prev_systime = timer_state.systime; //everything in here will be executed once every ms //make sure that everything in here takes less than 1ms //useful for checking state consistency, synchronization, watchdog... if(timer_state.systime % 1000 == 1) { LED_4 = 1; } led_update(); if (timer_state.systime % 10 == 1) { IMU_GetQuaternion(quaterion); QuaternionToYawPitchRoll(quaterion, ypr); } if (timer_state.systime % 5 == 1) { IMU_normalizeData(&mpuData, &magData, &imuData); // Run AHRS algorithm IMU_UpdateAHRS (&imuData); // Run IMU algorithm (does not use MAG data) // IMU_UpdateIMU(&imuData); //copy state to CAN dictionary IMU_CopyOutput(&imuData, &mpuData, &magData); } /** * CANFestival Loop */ if (can_state.init_return == RET_OK) { can_process(); /** * Sets CANFestival shared variables * specific to Sensor Board */ can_push_state(); } /** * Blinking LED Loop */ if (timer_state.systime % 25 == 0) { LED_1 = !LED_1; } } else { //untimed processes in main loop: //executed as fast as possible //these processes should NOT block the main loop // LED_4 = mpuData.accelX > 0; // LED_3 = mpuData.accelY > 0; // LED_1 = mpuData.accelZ > 0; // IMU_GetData(); IMU_CopyI2CData(&mpuData, &magData); if (!T1CONbits.TON) { RGB_RED = 0; RGB_GREEN = RGB_BLUE = 1; while (1); } if(can_flag){ TimeDispatch(); can_flag = 0; } uart_rx_packet = uart_rx_cur_packet(); if (uart_rx_packet != 0) { uart_rx_packet_consumed(); } /** * Handles CAN transmission buffers */ if ((txreq_bitarray & 0b00000001) && !C1TR01CONbits.TXREQ0) { C1TR01CONbits.TXREQ0 = 1; txreq_bitarray = txreq_bitarray & 0b11111110; } if ((txreq_bitarray & 0b00000010) && !C1TR01CONbits.TXREQ1) { C1TR01CONbits.TXREQ1 = 1; txreq_bitarray = txreq_bitarray & 0b11111101; } if ((txreq_bitarray & 0b00000100) && !C1TR23CONbits.TXREQ2) { C1TR23CONbits.TXREQ2 = 1; txreq_bitarray = txreq_bitarray & 0b11111011; } if ((txreq_bitarray & 0b00001000) && !C1TR23CONbits.TXREQ3) { C1TR23CONbits.TXREQ3 = 1; txreq_bitarray = txreq_bitarray & 0b11110111; } if ((txreq_bitarray & 0b00010000) && !C1TR45CONbits.TXREQ4) { C1TR45CONbits.TXREQ4 = 1; txreq_bitarray = txreq_bitarray & 0b11101111; } if ((txreq_bitarray & 0b00100000) && !C1TR45CONbits.TXREQ5) { C1TR45CONbits.TXREQ5 = 1; txreq_bitarray = txreq_bitarray & 0b11011111; } if ((txreq_bitarray & 0b01000000) && !C1TR67CONbits.TXREQ6) { C1TR67CONbits.TXREQ6 = 1; txreq_bitarray = txreq_bitarray & 0b10111111; } } } return (EXIT_SUCCESS); }
void http_process() { xbee_rx_ip_packet_t rx_pkt; uint8_t* rf_data_p; uint16_t rf_data_len; if(http_state.init_return!=RET_OK){ return;//not running } //check if top packet in circular buffer is a TCP packet on port 80 if(CB_ReadMany(&http_state.rx_buffer,&rx_pkt,sizeof(xbee_rx_ip_packet_t))!=SUCCESS){ return;//empty buffer } //we have a packet to handle, handle it now! rf_data_p = xbee_ip_rx_rf_data(rx_pkt.raw_packet.raw_data); //actual packet data rf_data_len = xbee_ip_rx_rf_data_len(&rx_pkt.raw_packet); //parse the packet http_parser_init(parser,HTTP_REQUEST); http_state.last_url_length = 0; http_state.last_url = 0; settings->on_url = http_handle_url; settings->on_body = http_handle_body; http_parser_execute(parser,settings,rf_data_p,(size_t)rf_data_len); //check if we found a url if(http_state.last_url!=0 && http_state.last_url_length>0){// && rf_data_len>3 && rf_data_p[0]=='G' && rf_data_p[1]=='E'&&rf_data_p[2]=='T'){ http_state.num_requests++; led_rgb_set(50,0,255); http_state.last_url[http_state.last_url_length]=0; //prepare response char* resp = "{\"result\": {\"message\":\"req. %lu\",\"url\":\"%s\",\"acc\":[%d,%d,%d]}, \"error\": null, \"id\": 1}\r\n" "\r\n"; sprintf(http_resp_buffer,resp,http_state.num_requests,http_state.last_url,(imu_state.acc_read_data[0]<<8)|imu_state.acc_read_data[1],(imu_state.acc_read_data[2]<<8)|imu_state.acc_read_data[3],(imu_state.acc_read_data[4]<<8)|imu_state.acc_read_data[5]); char* header = "HTTP/1.1 200 OK\r\n" "Content-Type: text/html\r\n" "Content-Length: %u\r\n" "\r\n";//application/json-rpc\r\n" sprintf(http_header_buffer,header,strlen(http_resp_buffer)); xbee_tx_ip_packet_t resp_pkt; //allocate memory for response if(allocate_ip_packet(strlen(http_resp_buffer)+strlen(http_header_buffer),&resp_pkt)==RET_OK){ memcpy(resp_pkt.user_data_location,http_header_buffer,strlen(http_header_buffer)); memcpy(resp_pkt.user_data_location+strlen(http_header_buffer),http_resp_buffer,strlen(http_resp_buffer)); //set options resp_pkt.options.dest_address[0] = rx_pkt.options.source_addr[0]; resp_pkt.options.dest_address[1] = rx_pkt.options.source_addr[1]; resp_pkt.options.dest_address[2] = rx_pkt.options.source_addr[2]; resp_pkt.options.dest_address[3] = rx_pkt.options.source_addr[3]; resp_pkt.options.dest_port = rx_pkt.options.source_port; resp_pkt.options.source_port = rx_pkt.options.dest_port; resp_pkt.options.leave_open = 0; resp_pkt.options.protocol = XBEE_NET_IPPROTO_TCP; //xbee_free_packet(&resp_pkt.raw_packet); if(transmit_ip_packet(&resp_pkt)!=RET_OK){ //packet could not be transmitted, we need to free the memory xbee_free_packet(&resp_pkt.raw_packet); } } else { //could not allocate response packet. } } //free the packet data xbee_free_packet(&rx_pkt.raw_packet); }