/**@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;
}
