/**@brief Function for sending the data. */ uint32_t ble_agsensor_data_send(ble_agsensor_t * p_agsensor, ble_agsensor_data_t * p_data) { uint32_t err_code = NRF_SUCCESS; if (p_agsensor->conn_handle != BLE_CONN_HANDLE_INVALID) { ble_gatts_hvx_params_t hvx_params; uint8_t encoded_value[MAX_DATA_LEN]; uint16_t hvx_len; // Initialize value struct. memset(&hvx_params, 0, sizeof(hvx_params)); hvx_len = data_encode(p_data, encoded_value); hvx_params.handle = p_agsensor->data_handles.value_handle; hvx_params.type = BLE_GATT_HVX_INDICATION; hvx_params.p_len = &hvx_len; hvx_params.offset = 0; hvx_params.p_data = encoded_value; err_code = sd_ble_gatts_hvx(p_agsensor->conn_handle, &hvx_params); } else { err_code = NRF_ERROR_INVALID_STATE; } return err_code; }
static void *server_to_planebone(void *connection){ /*-------------------------START OF SECOND THREAD: SERVER TO PLANEBONE------------------------*/ Connection *conn=(Connection *)connection; static UDP udp_client; //1. read data from i don't now where uint8_t encoded_data[MAX_OUTPUT_STREAM_SIZE]; UDP_err_handler(openUDPClientSocket(&udp_client,conn->planebone_ip,conn->port_number_server_to_planebone,UDP_SOCKET_TIMEOUT),write_error_ptr); int i=0; while(1) { Output output; //create test data output.message.servo_1=-i; output.message.servo_2=i; output.message.servo_3=i; output.message.servo_4=i; output.message.servo_5=i; output.message.servo_6=i; output.message.servo_7=0; i=i+900; if(i>12800){ i=0; } //2. encode the data DEC_err_handler(data_encode(output.raw,sizeof(output.raw),encoded_data,SERVER,SERVO_COMMANDS),write_error_ptr); /*printf("OUTPUT RAW:"); int j; for(j=0;j<encoded_data[1];j++){ printf("%d ",encoded_data[j]); } printf("\n");*/ //3. send data to eth port using UDP UDP_err_handler(sendUDPClientData(&udp_client,&encoded_data,sizeof(encoded_data)),write_error_ptr); //usleep(20000); //60 hz sleep(1); } UDP_err_handler(closeUDPClientSocket(&udp_client),write_error_ptr); return NULL; /*------------------------END OF SECOND THREAD------------------------*/ }
DEC_errCode NMEA_asci_encode(uint8_t buffer[],uint8_t encoded_data[]){ #if DEBUG > 1 printf("Entering NMEA_asci_encode\n"); #endif if(strncmp(&buffer[1],"IIMWV",5)==0){ NMEA_IIMWV wind; sscanf(&buffer[7],"%lf",&wind.wind_angle); sscanf(&buffer[13],"%c",&wind.relative); sscanf(&buffer[15],"%lf",&wind.wind_speed); sscanf(&buffer[22],"%c",&wind.wind_speed_unit); sscanf(&buffer[24],"%c",&wind.status); data_encode((uint8_t *)&wind,sizeof(NMEA_IIMWV)-16-1,encoded_data,BONE_WIND,NMEA_IIMWV_ID); //- timestamp and - new data flag /*printf("wind angle %lf\n",wind.wind_angle); printf("relative %c\n",wind.relative); printf("wind speed %lf\n",wind.wind_speed); printf("wind speed unit %c\n",wind.wind_speed_unit); printf("status %c\n",wind.status); printf("\n");*/ }else if(strncmp(&buffer[1],"WIXDR",5)==0){ if(buffer[7]=='C'){ NMEA_WIXDR temp; sscanf(&buffer[9],"%lf",&temp.temperature); sscanf(&buffer[15],"%c",&temp.unit); data_encode((uint8_t *)&temp,sizeof(NMEA_WIXDR)-16-1,encoded_data,BONE_WIND,NMEA_WIXDR_ID); //- timestamp and - new data flag /*printf("Temperature %lf\n",temp.temperature); printf("unit %c\n",temp.unit); printf("\n");*/ } }else{ return DEC_ERR_UNKNOWN_WIND_PACKAGE; } return DEC_ERR_NONE; }
static void sendError(DEC_errCode err,library lib){ static UDP udp_client; int message_length; uint8_t encoded_data[MAX_STREAM_SIZE]; Data data; Beagle_error error_message; //encode an error package error_message.library=lib; error_message.error_code=err; data_encode((uint8_t *)&error_message,sizeof(error_message),encoded_data,2,2); message_length=sizeof(encoded_data); //send errorcode to server, no error handling here otherwise we get infinite loop try to send error openUDPClientSocket(&udp_client,connection.server_ip,connection.port_number_lisa_to_pc,UDP_SOCKET_TIMEOUT); sendUDPClientData(&udp_client,&encoded_data,message_length); closeUDPClientSocket(&udp_client); }
/**@brief Function for initializing the AgSensor. */ uint32_t ble_agsensor_init(ble_agsensor_t * p_agsensor, const ble_agsensor_init_t * p_agsensor_init) { uint32_t err_code; ble_uuid_t ble_uuid; // Initialize service structure p_agsensor->evt_handler = p_agsensor_init->evt_handler; p_agsensor->conn_handle = BLE_CONN_HANDLE_INVALID; // Add a custom base UUID. ble_uuid128_t bds_base_uuid = {0x8D, 0x69, 0xDE, 0x3D, 0x57, 0x37, 0x4F, 0xBD, 0x54, 0x41, 0xE8, 0x73, 0x00, 0x00, 0xFE, 0x94}; uint8_t uuid_type; err_code = sd_ble_uuid_vs_add(&bds_base_uuid, &uuid_type); if (err_code != NRF_SUCCESS) { return err_code; } ble_uuid.type = uuid_type; ble_uuid.uuid = 0x9B64; // Add service err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_agsensor->service_handle); if (err_code != NRF_SUCCESS) { return err_code; } // Add configuration characteristic ble_agsensor_configuration_t configuration_initial_value = p_agsensor_init->ble_agsensor_configuration_initial_value; // Initialize value struct. memset(&configuration_initial_value, 0, sizeof(configuration_initial_value)); // Dhaval test configuration_initial_value = p_agsensor_init->ble_agsensor_configuration_initial_value; configuration_initial_value.ble_agsensor_code = 0x0001; configuration_initial_value.data.ble_agsensor_date_time_Sec = getTimeInSec(); // configuration_initial_value.ble_agsensor_data = "test"; uint8_t configuration_encoded_value[MAX_CONFIGURATION_LEN]; ble_add_char_params_t add_configuration_params; memset(&add_configuration_params, 0, sizeof(add_configuration_params)); add_configuration_params.uuid = 0x866D; add_configuration_params.uuid_type = ble_uuid.type; add_configuration_params.max_len = MAX_CONFIGURATION_LEN; add_configuration_params.init_len = configuration_encode(&configuration_initial_value, configuration_encoded_value); add_configuration_params.p_init_value = configuration_encoded_value; //// add_configuration_params.char_props.indicate = 1; // add_configuration_params.char_props.write = 1; //// add_configuration_params.read_access = SEC_OPEN; // add_configuration_params.write_access = SEC_OPEN; //// add_configuration_params.cccd_write_access = SEC_OPEN; // // 1 for variable length and 0 for fixed length. // add_configuration_params.is_var_len = 1; // // add_configuration_params.char_props.read = 1; // add_configuration_params.read_access = SEC_OPEN; add_configuration_params.char_props.notify = 1; add_configuration_params.char_props.indicate = 1; add_configuration_params.char_props.read = 1; add_configuration_params.read_access = SEC_OPEN; add_configuration_params.char_props.write = 1; add_configuration_params.write_access = SEC_OPEN; add_configuration_params.cccd_write_access = SEC_OPEN; // 1 for variable length and 0 for fixed length. add_configuration_params.is_var_len = 1; err_code = characteristic_add(p_agsensor->service_handle, &add_configuration_params, &(p_agsensor->configuration_handles)); if (err_code != NRF_SUCCESS) { return err_code; } // Add data characteristic //data_initial_value = p_agsensor_init->ble_agsensor_data_initial_value; ble_agsensor_data_t data_initial_value = p_agsensor_init->ble_agsensor_data_initial_value; uint8_t data_encoded_value[MAX_DATA_LEN]; ble_add_char_params_t add_data_params; memset(&add_data_params, 0, sizeof(add_data_params)); add_data_params.uuid = 0x20D7; add_data_params.uuid_type = ble_uuid.type; add_data_params.max_len = MAX_DATA_LEN; add_data_params.init_len = data_encode(&data_initial_value, data_encoded_value); add_data_params.p_init_value = data_encoded_value; add_data_params.char_props.indicate = 1; add_data_params.char_props.write = 1; add_data_params.write_access = SEC_OPEN; add_data_params.cccd_write_access = SEC_OPEN; // 1 for variable length and 0 for fixed length. add_data_params.is_var_len = 1; err_code = characteristic_add(p_agsensor->service_handle, &add_data_params, &(p_agsensor->data_handles)); if (err_code != NRF_SUCCESS) { return err_code; } return NRF_SUCCESS; }