/*---------------------------------------------------------------*/
static void sample_fun(void)
{
ctimer_reset(&ct);
ctimer_restart(&reset_timer);
MPU_status = mpu_sample_all(&sample_data);
if (MPU_status != 0)
{
PRINTF("%d,%d,%d,%d,%d,%d,%d\n",sample_data.data.accel_x,sample_data.data.accel_y,sample_data.data.accel_z,sample_data.data.tp,sample_data.data.gyro_x,sample_data.data.gyro_y,sample_data.data.gyro_z);
// sending acceleration data
mpu_get_acc(&sample_data,&data_sample);
app_conn_send((uint8_t*)&data_sample,MPU_DATA_ACC_GYRO_SIZE);
// sending gyro data
mpu_get_gyro(&sample_data,&data_sample);
app_conn_send((uint8_t*)&data_sample,MPU_DATA_ACC_GYRO_SIZE);
// sending temperature data
//mpu_get_tp(&sample_data,&tp_data_sample);
//app_conn_send((uint8_t*)&tp_data_sample,MPU_DATA_TP_SIZE);
}
else
{
printf("Cannot sample data\n");
}
}
static void reset_sample_timer(void)
{
//ctimer_set(&ct,SAMPLE_RATE,sample_fun,(void*)NULL);
ctimer_reset(&ct);
ctimer_restart(&reset_timer);
has_reset = has_reset + 1;
printf("reset sample fun ctimer %u\n",has_reset);
}
void global_presence_detected(void) {
#if PRESENCE_DETECTOR_SERVER
if(global_presence != PRESENCE) {
global_presence = PRESENCE;
broadcast_value(EP_PRESENCE_DETECTOR);
}
ctimer_restart(&pd_timeout);
#endif
}
/* Call back for led toggle timer to toggle leds */
static void
ct_callback(void *ptr)
{
static uint8 toggle_status = 0;
if(toggle_status) {
leds_set(LEDS_RED);
} else {
leds_set(LEDS_GREEN);
} ctimer_restart(&ct);
toggle_status ^= 0x01;
}
static void send_packet(struct mqtt_sn_connection *mqc, char* data, size_t len)
{
simple_udp_send(&(mqc->sock), data, len);//these datatypes should all cast fine
if (mqc->keep_alive>0 && mqc->stat == MQTTSN_CONNECTED)
{
//normally we would use this to make sure that we are always sending data to keep the connection alive
//but since the gateway does not support pubacks, we will always be relying on a
//steady stream of pings to ensure that the connection stays alive.
ctimer_restart(&(mqc->send_timer));
}
}
void raw_presence_detected(void) {
#if PRESENCE_DETECTOR_CLIENT
uint8_t tmp = global_presence;
presence = PRESENCE_DETECTOR_CLIENT_GROUP;
global_presence = presence;
broadcast_value(EP_PRESENCE_DETECTOR);
global_presence = tmp;
if(PRESENCE_DETECTOR_CLIENT_KEEP_ALIVE != 0) {
ctimer_restart(&pd_keep_alive);
}
#endif
}
void response_handler(ChannelState *state, DataPayload *dp){
if (state->state != STATE_CONNECTED && state->state != STATE_PING){
PRINTF("Not connected to device!\n");
return;
}
state->ticks = 100;
ResponseMsg *rmsg = (ResponseMsg *)dp->data;
PRINTF("%s %d\n", rmsg->name, uip_ntohs(rmsg->data));
/*RESET PING TIMER*/
ctimer_restart(&(state->timer));
process_post_synch(state->ccb.client_process, KNOT_EVENT_DATA_READY, rmsg);
}
/**
* Handles TCP events from Simple TCP
*/
static void
tcp_event(struct tcp_socket *s, void *ptr, tcp_socket_event_t event)
{
struct mqtt_connection* conn = ptr;
/* Take care of event */
switch(event) {
/* Fall through to manage different disconnect event the same way. */
case TCP_SOCKET_CLOSED:
case TCP_SOCKET_TIMEDOUT:
case TCP_SOCKET_ABORTED: {
ctimer_stop(&conn->keep_alive_timer);
call_event(conn, MQTT_EVENT_DISCONNECTED, &event);
/* If connecting retry */
if(conn->state == MQTT_CONN_STATE_TCP_CONNECTING ||
conn->auto_reconnect == 1) {
DBG("MQTT - Disconnected by tcp event %d, reconnecting...",
event);
connect_tcp(conn);
}
else {
conn->state = MQTT_CONN_STATE_NOT_CONNECTED;
}
break;
}
case TCP_SOCKET_CONNECTED: {
DBG("MQTT - Got TCP_SOCKET_CONNECTED\r\n");
conn->state = MQTT_CONN_STATE_TCP_CONNECTED;
process_post(&mqtt_process, mqtt_do_connect_mqtt_event, conn);
break;
}
case TCP_SOCKET_DATA_SENT: {
DBG("MQTT - Got TCP_DATA_SENT\r\n");
conn->out_buffer_sent = 1;
conn->out_buffer_ptr = conn->out_buffer;
ctimer_restart(&conn->keep_alive_timer);
break;
}
default: {
DBG("MQTT - TCP Event %d is currently not manged by the tcp event callback\r\n",
event);
}
}
}
void ping_callback(void * s){
ChannelState *state = (ChannelState *)s;
if (state->pingOUT < 3){
ping(state);
ctimer_restart(&(state->timer));
state->pingOUT++;
}
else {
close_graceful(state);
remove_channel(state->chan_num);
state->pingOUT =0;
}
}
/*---------------------------------------------------------------*/
static void sample_fun(void)
{
ctimer_reset(&ct);
ctimer_restart(&reset_timer);
ADC_status = adxl_sample(&sample);
if (ADC_status == 1)
app_conn_send((uint8_t*)&sample,ADXL_DATA_SIZE);
PRINTF("%u,%u,%u,%u\n",sample.x.data,sample.y.data,sample.z.data,sample.vref.data);
}
void mqtt_sn_send_pingreq(struct mqtt_sn_connection *mqc)
{
char packet[2];
packet[0] = 2;
packet[1] = MQTT_SN_TYPE_PINGREQ;
if (debug) {
printf("Sending ping...\n");
}
ctimer_restart(&(mqc->send_timer));
return send_packet(mqc, (char*)&packet, 2);
}
static void
put_post_led_toggle_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
{
static int led_state = 0;
const uint8_t *request_content;
int request_content_len;
unsigned int accept = -1;
/* Given the way the LEDs are connected to the DIO ports, the LEDs are controlled via direct DIO access. */
content_len = 0;
switch(led_state) {
case (0):
ctimer_stop(&ct);
leds_set(LEDS_GREEN); /* Only LEDS_GREEN on */
CONTENT_PRINTF("Message from resource: Green LED on");
led_state = 1;
break;
case (1):
leds_set(LEDS_RED); /* Only LEDS_RED on */
CONTENT_PRINTF("Message from resource: Red LED on");
led_state = 2;
break;
case (2):
leds_set(0); /* All LEDS off */
CONTENT_PRINTF("Message from resource: All LEDs off");
led_state = 3;
break;
case 3:
/* Both leds toggle */
CONTENT_PRINTF("Message from resource: LEDs toggle");
ctimer_restart(&ct);
led_state = 0;
default:
break;
}
/* Return message */
REST.get_header_accept(request, &accept);
if(accept == -1 || accept == REST.type.TEXT_PLAIN) {
REST.set_header_content_type(response, REST.type.TEXT_PLAIN);
REST.set_response_payload(response, (uint8_t *)content, content_len);
}
}
static void
mqtt_sn_receiver(struct simple_udp_connection *sock, const uip_ipaddr_t *sender_addr, uint16_t sender_port,
const uip_ipaddr_t *receiver_addr, uint16_t receiver_port, const uint8_t *data, uint16_t datalen)
{
uint8_t msg_type;
struct mqtt_sn_connection *mqc = (struct mqtt_sn_connection *)sock;
if (mqc->keep_alive > 0 && mqc->stat == MQTTSN_CONNECTED){
ctimer_restart((&(mqc->receive_timer)));
printf("recieve timer reset\n");
}
if (datalen >= 2)
{
msg_type = data[1];
switch(msg_type) {
// case MQTT_SN_TYPE_ADVERTISE:
// case MQTT_SN_TYPE_SEARCHGW:
// case MQTT_SN_TYPE_GWINFO:
// case MQTT_SN_TYPE_CONNECT:
case MQTT_SN_TYPE_CONNACK:
{
memcpy(&(mqc->last_connack),data,sizeof(connack_packet_t));
process_post(&mqtt_sn_process, connack_event, mqc);
if(mqc->mc->connack_recv != NULL) {
mqc->mc->connack_recv(mqc, receiver_addr, data, datalen);
}
break;
}
// case MQTT_SN_TYPE_WILLTOPICREQ:
// case MQTT_SN_TYPE_WILLTOPIC:
// case MQTT_SN_TYPE_WILLMSGREQ:
// case MQTT_SN_TYPE_WILLMSG:
// case MQTT_SN_TYPE_REGISTER:
case MQTT_SN_TYPE_REGACK:
{
if(mqc->mc->regack_recv != NULL) {
mqc->mc->regack_recv(mqc, receiver_addr, data, datalen);
}
manage_response(mqc, receiver_addr, data, datalen);
break;
}
case MQTT_SN_TYPE_PUBLISH:
{
if(mqc->mc->pub_recv != NULL) {
mqc->mc->pub_recv(mqc, receiver_addr, data, datalen);
}
break;
}
case MQTT_SN_TYPE_PUBACK:
{
if(mqc->mc->puback_recv != NULL) {
mqc->mc->puback_recv(mqc, receiver_addr, data, datalen);
}
break;
}
// case MQTT_SN_TYPE_PUBCOMP:
// case MQTT_SN_TYPE_PUBREC:
// case MQTT_SN_TYPE_PUBREL:
// case MQTT_SN_TYPE_SUBSCRIBE:
case MQTT_SN_TYPE_SUBACK:
{
if(mqc->mc->suback_recv != NULL) {
mqc->mc->suback_recv(mqc, receiver_addr, data, datalen);
}
manage_response(mqc, receiver_addr, data, datalen);
break;
}
// case MQTT_SN_TYPE_UNSUBSCRIBE:
// case MQTT_SN_TYPE_UNSUBACK:
case MQTT_SN_TYPE_PINGREQ:
{
mqtt_sn_send_pingresp(mqc);
if(mqc->mc->pingreq_recv != NULL) {
mqc->mc->pingreq_recv(mqc, receiver_addr, data, datalen);
}
break;
}
case MQTT_SN_TYPE_PINGRESP:
{
if(mqc->mc->pingresp_recv != NULL) {
mqc->mc->pingresp_recv(mqc, receiver_addr, data, datalen);
}
break;
}
case MQTT_SN_TYPE_DISCONNECT:
{
process_post(&mqtt_sn_process, disconnect_event, mqc);
if(mqc->mc->disconnect_recv != NULL) {
mqc->mc->disconnect_recv(mqc, receiver_addr, data, datalen);
}
break;
}
// case MQTT_SN_TYPE_WILLTOPICUPD:
// case MQTT_SN_TYPE_WILLTOPICRESP:
// case MQTT_SN_TYPE_WILLMSGUPD:
// case MQTT_SN_TYPE_WILLMSGRESP:
default:
{
if (debug) {
printf(" unrecognized received packet...\n");
}
break;
}
}
}
}