bool unabto_buffer_test(void) {
char * raw_test_string = "asjdhc#21?(!?(92814skzjbcasa";
uint8_t data[7 + 2 + strlen(raw_test_string)];
unabto_buffer buf, raw_string_buf;
buffer_write_t w_buf;
buffer_read_t r_buf;
uint32_t t32;
uint16_t t16;
uint8_t t8;
uint8_t raw_string_data[strlen(raw_test_string) + 1];
buffer_init(&raw_string_buf, (uint8_t*)raw_test_string, strlen(raw_test_string));
buffer_init(&buf, data, sizeof(data));
buffer_write_init(&w_buf, &buf);
if (! (buffer_write_uint32(&w_buf, 0x12345678) &&
buffer_write_uint16(&w_buf, 0x1234) &&
buffer_write_uint8(&w_buf, 0x12) &&
buffer_write_raw(&w_buf, &raw_string_buf) ) ) {
NABTO_LOG_ERROR(("Buffer write test failed"));
return false;
}
buffer_read_init(&r_buf, &buf);
memset(raw_string_data, 0, sizeof(raw_string_data) + 1);
buffer_init(&raw_string_buf, raw_string_data, sizeof(raw_string_data));
bool t = false;
if (! ( buffer_read_uint32(&r_buf, &t32) && t32 == 0x12345678 &&
buffer_read_uint16(&r_buf, &t16) && t16 == 0x1234 &&
buffer_read_uint8(&r_buf, &t8) && t8 == 0x12 &&
(t = buffer_read_raw(&r_buf, &raw_string_buf)) && buffer_get_size(&raw_string_buf) == strlen(raw_test_string) &&
0 == strncmp((char*)buffer_get_data(&raw_string_buf), raw_test_string, strlen(raw_test_string)) )) {
NABTO_LOG_ERROR(("Failed read test failed"));
return false;
}
if (buffer_read_uint32(&r_buf, &t32) ||
buffer_read_uint16(&r_buf, &t16) ||
buffer_read_uint8(&r_buf, &t8) ||
buffer_read_raw(&w_buf, &raw_string_buf) ||
buffer_write_uint32(&w_buf, 0x12345678) ||
buffer_write_uint16(&w_buf, 0x1234) ||
buffer_write_uint8(&w_buf, 0x12) ||
buffer_write_raw(&w_buf, &raw_string_buf) ) {
NABTO_LOG_ERROR(("Some function should have returned false but returned true"));
return false;
}
return true;
}
void arp_gratuitous(struct buffer* b) {
buffer_flush(b);
eth_write_header(b, mac_addr, mac_bcast, ETH_ARP);
buffer_write_uint16(b, 1);
buffer_write_uint16(b, ETH_IPV4);
buffer_write_uint8(b, 6);
buffer_write_uint8(b, 4);
buffer_write_uint16(b, 2);
buffer_write(b, 6, mac_addr);
buffer_write(b, 4, ip_addr);
buffer_write(b, 6, mac_addr);
buffer_write(b, 4, ip_addr);
}
void arp_reply(struct buffer* b, char* mac, uint32_t to) {
buffer_flush(b);
eth_write_header(b, mac_addr, mac, ETH_ARP);
buffer_write_uint16(b, 1);
buffer_write_uint16(b, ETH_IPV4);
buffer_write_uint8(b, 6);
buffer_write_uint8(b, 4);
buffer_write_uint16(b, 2);
buffer_write(b, 6, mac_addr);
buffer_write(b, 4, ip_addr);
buffer_write(b, 6, mac);
buffer_write_uint32(b, to);
}
application_event_result application_event(application_request* request, buffer_read_t* read_buffer, buffer_write_t* write_buffer) {
switch(request->queryId) {
case 1: {
// <query name="light_write.json" description="Turn light on and off" id="1">
// <request>
// <parameter name="light_id" type="uint8"/>
// <parameter name="light_on" type="uint8"/>
// </request>
// <response>
// <parameter name="light_state" type="uint8"/>
// </response>
// </query>
uint8_t light_id;
uint8_t light_on;
uint8_t light_state;
// Read parameters in request
if (!buffer_read_uint8(read_buffer, &light_id)) {
NABTO_LOG_ERROR(("Can't read light_id, the buffer is too small"));
return AER_REQ_TOO_SMALL;
}
if (!buffer_read_uint8(read_buffer, &light_on)) {
NABTO_LOG_ERROR(("Can't read light_state, the buffer is too small"));
return AER_REQ_TOO_SMALL;
}
// Set light according to request
light_state = setLight(light_id, light_on);
// Write back led state
if (!buffer_write_uint8(write_buffer, light_state)) {
return AER_REQ_RSP_TOO_LARGE;
}
return AER_REQ_RESPONSE_READY;
}
case 2: {
// <query name="light_read.json" description="Read light status" id="2">
// <request>
// <parameter name="light_id" type="uint8"/>
// </request>
// <response>
// <parameter name="light_state" type="uint8"/>
// </response>
// </query>
uint8_t light_id;
uint8_t light_state;
// Read parameters in request
if (!buffer_read_uint8(read_buffer, &light_id)) return AER_REQ_TOO_SMALL;
// Read light state
light_state = readLight(light_id);
// Write back led state
if (!buffer_write_uint8(write_buffer, light_state)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
}
return AER_REQ_INV_QUERY_ID;
}
/***************** The uNabto application logic *****************
* This is where the user implements his/her own functionality
* to the device. When a Nabto message is received, this function
* gets called with the message's request id and parameters.
* Afterwards a user defined message can be sent back to the
* requesting browser.
****************************************************************/
application_event_result application_event(application_request* request, buffer_read_t* read_buffer, buffer_write_t* write_buffer) {
switch(request->queryId) {
case 1: {
/** Get acceleration data */
extern int16_t gAccData[3];
uint16_t acc_x;
uint16_t acc_y;
uint16_t acc_z;
// Get accelerometer data and calculate yaw, pitch and roll with offset
Accelerometer_Get();
acc_x = gAccData[0] + 0xFF;
acc_y = gAccData[1] + 0xFF;
acc_z = gAccData[2] + 0xFF;
// Write back data
if (!buffer_write_uint16(write_buffer, acc_x)) return AER_REQ_RSP_TOO_LARGE;
if (!buffer_write_uint16(write_buffer, acc_y)) return AER_REQ_RSP_TOO_LARGE;
if (!buffer_write_uint16(write_buffer, acc_z)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 2: {
/** Get temperature data */
uint16_t temp;
temp = Temperature_Get();
// Write back data
if (!buffer_write_uint16(write_buffer, temp)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 3: {
/** Get light level */
uint16_t light;
light = LightSensor_Get();
// Write back data
if (!buffer_write_uint16(write_buffer, light)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 4: {
/** Get potentiometer data */
uint32_t pot;
pot = Potentiometer_Get();
// Write back data
if (!buffer_write_uint32(write_buffer, pot)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 5: {
/** Get button status */
uint8_t button1;
uint8_t button2;
uint8_t button3;
button1 = Switch1IsPressed();
button2 = Switch2IsPressed();
button3 = Switch3IsPressed();
// Write back data
if (!buffer_write_uint8(write_buffer, button1)) return AER_REQ_RSP_TOO_LARGE;
if (!buffer_write_uint8(write_buffer, button2)) return AER_REQ_RSP_TOO_LARGE;
if (!buffer_write_uint8(write_buffer, button3)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 6: {
/** Get sound level */
uint32_t sound;
sound = Microphone_Get();
// Write back data
if (!buffer_write_uint32(write_buffer, sound)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 7: {
/** Set LED */
uint16_t led;
// Read parameters in request
if (!buffer_read_uint16(read_buffer, &led)) return AER_REQ_TOO_SMALL;
if (led == 1) {
led_all_on();
} else {
led_all_off();
}
// Write back data
if (!buffer_write_uint16(write_buffer, led)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
}
return AER_REQ_INV_QUERY_ID;
}
