/* * Timesynch functionality */ static PT_THREAD(timesynch(struct psock *p)) { PSOCK_BEGIN(p); printf("TIME: %d\n",clock_time()); static TimesynchSRMsg time_pkt; memset(&time_pkt,0,sizeof(time_pkt)); PSOCK_WAIT_UNTIL(p,PSOCK_NEWDATA(p)); if(PSOCK_NEWDATA(p)){ clock_time_t t2 = clock_time(); PSOCK_READBUF(p); memcpy(&time_pkt,buffer,sizeof(time_pkt)); time_pkt.t1 = time_pkt.t1; time_pkt.t2 = t2; time_pkt.t3 = clock_time(); printf("Clock print: %u\n",clock_time()); PSOCK_SEND(p,&time_pkt,sizeof(time_pkt)); printf("Clock print: %u\n",clock_time()); printf("T1: %u\n",time_pkt.t1); printf("T2: %u\n",time_pkt.t2); printf("T3: %u\n",time_pkt.t3); } else { printf("Timed out!\n"); PSOCK_CLOSE_EXIT(p); } state = 4; PSOCK_END(p); }
/*---------------------------------------------------------------------------*/ static PT_THREAD(create_test_session(struct psock *p)) { /* * A protosocket's protothread must start with a PSOCK_BEGIN(), with * the protosocket as argument. */ PSOCK_BEGIN(p); /* * Here we define all the thread local variables that we need to * utilize. */ static RequestSession request; static AcceptSession accept; PSOCK_WAIT_UNTIL(p,PSOCK_NEWDATA(p)); if(PSOCK_NEWDATA(p)){ /* * We read data from the buffer now that it has arrived. * Using memcpy we store it in our local variable. */ PSOCK_READBUF(p); memcpy(&request,buffer,sizeof(request)); TEST_AMOUNT = (int) request.NumOfPackets; UDP_SENDER_PORT = (int) request.SenderPort; UDP_RECEIVER_PORT = (int) request.RecieverPort; /* * Prints for debugging. */ printf("Type: %"PRIu32"\n",request.Type); printf("SenderPort: %"PRIu32"\n",request.SenderPort); printf("ReceiverPort: %"PRIu32"\n",request.RecieverPort); printf("SenderAddress: %08x,%x\n",request.SenderAddress,request.SenderMBZ); printf("ReceiverAddress: %08x,%x\n",request.RecieverAddress,request.RecieverMBZ); printf("StartTime: %u\n",request.StartTime.Second); accept.Accept = 0; accept.Port = request.RecieverPort; PSOCK_SEND(p, &accept, sizeof(accept)); PSOCK_SEND(p, &accept, sizeof(accept)); } else { printf("Timed out!\n"); } state = 3; PSOCK_END(p); }
/*---------------------------------------------------------------------------*/ static PT_THREAD(ajax_call(struct httpd_state *s, char *ptr)) { static struct timer t; static int iter; static char buf[128]; static uint8_t numprinted; PSOCK_BEGIN(&s->sout); /*TODO:pick up time from ? parameter */ timer_set(&t, 2*CLOCK_SECOND); iter = 0; while(1) { iter++; #if CONTIKI_TARGET_SKY SENSORS_ACTIVATE(sht11_sensor); SENSORS_ACTIVATE(light_sensor); numprinted = snprintf(buf, sizeof(buf), "t(%d);h(%d);l1(%d);l2(%d);", sht11_sensor.value(SHT11_SENSOR_TEMP), sht11_sensor.value(SHT11_SENSOR_HUMIDITY), light_sensor.value(LIGHT_SENSOR_PHOTOSYNTHETIC), light_sensor.value(LIGHT_SENSOR_TOTAL_SOLAR)); SENSORS_DEACTIVATE(sht11_sensor); SENSORS_DEACTIVATE(light_sensor); #elif CONTIKI_TARGET_MB851 SENSORS_ACTIVATE(acc_sensor); numprinted = snprintf(buf, sizeof(buf),"t(%d);ax(%d);ay(%d);az(%d);", temperature_sensor.value(0), acc_sensor.value(ACC_X_AXIS), acc_sensor.value(ACC_Y_AXIS), acc_sensor.value(ACC_Z_AXIS)); SENSORS_DEACTIVATE(acc_sensor); #elif CONTIKI_TARGET_REDBEE_ECONOTAG { uint8_t c; adc_reading[8]=0; adc_init(); while (adc_reading[8]==0) adc_service(); adc_disable(); numprinted = snprintf(buf, sizeof(buf),"b(%u);adc(%u,%u,%u,%u,%u,%u,%u,%u);", 1200*0xfff/adc_reading[8],adc_reading[0],adc_reading[1],adc_reading[2],adc_reading[3],adc_reading[4],adc_reading[5],adc_reading[6],adc_reading[7]); } #elif CONTIKI_TARGET_MINIMAL_NET static uint16_t c0=0x3ff,c1=0x3ff,c2=0x3ff,c3=0x3ff,c4=0x3ff,c5=0x3ff,c6=0x3ff,c7=0x3ff; numprinted = snprintf(buf, sizeof(buf), "t(%d);b(%u);v(%u);",273+(rand()&0x3f),3300-iter/10,iter); numprinted += snprintf(buf+numprinted, sizeof(buf)-numprinted,"adc(%u,%u,%u,%u,%u,%u,%u,%u);",c0,c1,c2,c3,c4,c5,c6,c7); c0+=(rand()&0xf)-8; c1+=(rand()&0xf)-8; c2+=(rand()&0xf)-7; c3+=(rand()&0x1f)-15; c4+=(rand()&0x3)-1; c5+=(rand()&0xf)-8; c6+=(rand()&0xf)-8; c7+=(rand()&0xf)-8; if (iter==1) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('Minimal-net "; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } #elif CONTIKI_TARGET_AVR_ATMEGA128RFA1 { uint8_t i;int16_t tmp,bat; BATMON = 16; //give BATMON time to stabilize at highest range and lowest voltage /* Measure internal temperature sensor, see atmega128rfa1 datasheet */ /* This code disabled by default for safety. Selecting an internal reference will short it to anything connected to the AREF pin */ #if 1 ADCSRB|=1<<MUX5; //this bit buffered till ADMUX written to! ADMUX =0xc9; // Select internal 1.6 volt ref, temperature sensor ADC channel ADCSRA=0x85; //Enable ADC, not free running, interrupt disabled, clock divider 32 (250 KHz@ 8 MHz) // while ((ADCSRB&(1<<AVDDOK))==0); //wait for AVDD ok // while ((ADCSRB&(1<<REFOK))==0); //wait for ref ok ADCSRA|=1<<ADSC; //Start throwaway conversion while (ADCSRA&(1<<ADSC)); //Wait till done ADCSRA|=1<<ADSC; //Start another conversion while (ADCSRA&(1<<ADSC)); //Wait till done tmp=ADC; //Read adc tmp=11*tmp-2728+(tmp>>2); //Convert to celcius*10 (should be 11.3*h, approximate with 11.25*h) ADCSRA=0; //disable ADC ADMUX=0; //turn off internal vref #endif /* Bandgap can't be measured against supply voltage in this chip. */ /* Use BATMON register instead */ for ( i=16; i<31; i++) { BATMON = i; if ((BATMON&(1<<BATMON_OK))==0) break; } bat=2550-75*16-75+75*i; //-75 to take the floor of the 75 mv transition window static const char httpd_cgi_ajax10[] HTTPD_STRING_ATTR ="t(%u),b(%u);adc(%d,%d,%u,%u,%u,%u,%u,%lu);"; numprinted = httpd_snprintf(buf, sizeof(buf),httpd_cgi_ajax10,tmp,bat,iter,tmp,bat,sleepcount,OCR2A,0,clock_time(),clock_seconds()); if (iter==1) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('128rfa1 ["; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "]');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } } #elif CONTIKI_TARGET_AVR_RAVEN { int16_t tmp,bat; #if 1 /* Usual way to get AVR supply voltage, measure 1.1v bandgap using Vcc as reference. * This connects the bandgap to the AREF pin, so enable only if there is no external AREF! * A capacitor may be connected to this pin to reduce reference noise. */ ADMUX =0x5E; //Select AVCC as reference, measure 1.1 volt bandgap reference. ADCSRA=0x87; //Enable ADC, not free running, interrupt disabled, clock divider 128 (62 KHz@ 8 MHz) ADCSRA|=1<<ADSC; //Start throwaway conversion while (ADCSRA&(1<<ADSC)); //Wait till done ADCSRA|=1<<ADSC; //Start another conversion while (ADCSRA&(1<<ADSC)); //Wait till done //bat=1126400UL/ADC; //Get supply voltage (factor nominally 1100*1024) bat=1198070UL/ADC; //My Raven ADCSRA=0; //disable ADC ADMUX=0; //turn off internal vref #else bat=3300; #endif tmp=420; static const char httpd_cgi_ajax10[] HTTPD_STRING_ATTR ="t(%u),b(%u);adc(%d,%d,%u,%u,%u,%u,%u,%lu);"; numprinted = httpd_snprintf(buf, sizeof(buf),httpd_cgi_ajax10,tmp,bat,iter,tmp,bat,sleepcount,OCR2A,0,clock_time(),clock_seconds()); if (iter<3) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('Raven ["; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "]');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } } //#elif CONTIKI_TARGET_IS_SOMETHING_ELSE #else { static const char httpd_cgi_ajax10[] HTTPD_STRING_ATTR ="v(%u);"; numprinted = httpd_snprintf(buf, sizeof(buf),httpd_cgi_ajax10,iter); if (iter==1) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('Contiki Ajax "; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } } #endif #if CONTIKIMAC_CONF_COMPOWER #include "sys/compower.h" { //sl=compower_idle_activity.transmit/RTIMER_ARCH_SECOND; //sl=compower_idle_activity.listen/RTIMER_ARCH_SECOND; } #endif #if RIMESTATS_CONF_ON #include "net/rime/rimestats.h" static const char httpd_cgi_ajaxr1[] HTTPD_STRING_ATTR ="rime(%lu,%lu,%lu,%lu);"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajaxr1, rimestats.tx,rimestats.rx,rimestats.lltx-rimestats.tx,rimestats.llrx-rimestats.rx); #endif #if ENERGEST_CONF_ON { #if 1 /* Send on times in percent since last update. Handle 16 bit rtimer wraparound. */ /* Javascript must convert based on platform cpu, tx, rx power, e.g. 20ma*3v3=66mW*(% on time/100) */ static rtimer_clock_t last_send; rtimer_clock_t delta_time; static unsigned long last_cpu, last_lpm, last_listen, last_transmit; energest_flush(); delta_time=RTIMER_NOW()-last_send; if (RTIMER_CLOCK_LT(RTIMER_NOW(),last_send)) delta_time+=RTIMER_ARCH_SECOND; last_send=RTIMER_NOW(); static const char httpd_cgi_ajaxe1[] HTTPD_STRING_ATTR = "p(%lu,%lu,%lu,%lu);"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajaxe1, (100UL*(energest_total_time[ENERGEST_TYPE_CPU].current - last_cpu))/delta_time, (100UL*(energest_total_time[ENERGEST_TYPE_LPM].current - last_lpm))/delta_time, (100UL*(energest_total_time[ENERGEST_TYPE_TRANSMIT].current - last_transmit))/delta_time, (100UL*(energest_total_time[ENERGEST_TYPE_LISTEN].current - last_listen))/delta_time); last_cpu = energest_total_time[ENERGEST_TYPE_CPU].current; last_lpm = energest_total_time[ENERGEST_TYPE_LPM].current; last_transmit = energest_total_time[ENERGEST_TYPE_TRANSMIT].current; last_listen = energest_total_time[ENERGEST_TYPE_LISTEN].current; #endif #if 1 /* Send cumulative on times in percent*100 */ uint16_t cpp,txp,rxp; uint32_t sl,clockseconds=clock_seconds(); // energest_flush(); // sl=((10000UL*energest_total_time[ENERGEST_TYPE_CPU].current)/RTIMER_ARCH_SECOND)/clockseconds; sl=energest_total_time[ENERGEST_TYPE_CPU].current/RTIMER_ARCH_SECOND; cpp=(10000UL*sl)/clockseconds; // txp=((10000UL*energest_total_time[ENERGEST_TYPE_TRANSMIT].current)/RTIMER_ARCH_SECOND)/clockseconds; sl=energest_total_time[ENERGEST_TYPE_TRANSMIT].current/RTIMER_ARCH_SECOND; txp=(10000UL*sl)/clockseconds; // rxp=((10000UL*energest_total_time[ENERGEST_TYPE_LISTEN].current)/RTIMER_ARCH_SECOND)/clockseconds; sl=energest_total_time[ENERGEST_TYPE_LISTEN].current/RTIMER_ARCH_SECOND; rxp=(10000UL*sl)/clockseconds; static const char httpd_cgi_ajaxe2[] HTTPD_STRING_ATTR = "ener(%u,%u,%u);"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajaxe2,cpp,txp,rxp); #endif } #endif /* ENERGEST_CONF_ON */ PSOCK_SEND_STR(&s->sout, buf); timer_restart(&t); PSOCK_WAIT_UNTIL(&s->sout, timer_expired(&t)); } PSOCK_END(&s->sout); }
static PT_THREAD(handle_mqtt_connection(mqtt_state_t* state)) { static struct etimer keepalive_timer; uint8_t msg_type; uint8_t msg_qos; uint16_t msg_id; PSOCK_BEGIN(&state->ps); // Initialise and send CONNECT message mqtt_msg_init(&state->mqtt_connection, state->out_buffer, state->out_buffer_length); state->outbound_message = mqtt_msg_connect(&state->mqtt_connection, state->connect_info); PSOCK_SEND(&state->ps, state->outbound_message->data, state->outbound_message->length); state->outbound_message = NULL; // Wait for CONACK message PSOCK_READBUF_LEN(&state->ps, 2); if(mqtt_get_type(state->in_buffer) != MQTT_MSG_TYPE_CONNACK) PSOCK_CLOSE_EXIT(&state->ps); // Tell the client we're connected mqtt_flags |= MQTT_FLAG_CONNECTED; complete_pending(state, MQTT_EVENT_TYPE_CONNECTED); // Setup the keep alive timer and enter main message processing loop etimer_set(&keepalive_timer, CLOCK_SECOND * state->connect_info->keepalive); while(1) { // Wait for something to happen: // new incoming data, // new outgoing data, // keep alive timer expired PSOCK_WAIT_UNTIL(&state->ps, PSOCK_NEWDATA(&state->ps) || state->outbound_message != NULL || etimer_expired(&keepalive_timer)); // If there's a new message waiting to go out, then send it if(state->outbound_message != NULL) { PSOCK_SEND(&state->ps, state->outbound_message->data, state->outbound_message->length); state->outbound_message = NULL; // If it was a PUBLISH message with QoS-0 then tell the client it's done if(state->pending_msg_type == MQTT_MSG_TYPE_PUBLISH && state->pending_msg_id == 0) complete_pending(state, MQTT_EVENT_TYPE_PUBLISHED); // Reset the keepalive timer as we've just sent some data etimer_restart(&keepalive_timer); continue; } // If the keep-alive timer expired then prepare a ping for sending // and reset the timer if(etimer_expired(&keepalive_timer)) { state->outbound_message = mqtt_msg_pingreq(&state->mqtt_connection); etimer_reset(&keepalive_timer); continue; } // If we get here we must have woken for new incoming data, // read and process it. PSOCK_READBUF_LEN(&state->ps, 2); state->message_length_read = PSOCK_DATALEN(&state->ps); state->message_length = mqtt_get_total_length(state->in_buffer, state->message_length_read); msg_type = mqtt_get_type(state->in_buffer); msg_qos = mqtt_get_qos(state->in_buffer); msg_id = mqtt_get_id(state->in_buffer, state->in_buffer_length); switch(msg_type) { case MQTT_MSG_TYPE_SUBACK: if(state->pending_msg_type == MQTT_MSG_TYPE_SUBSCRIBE && state->pending_msg_id == msg_id) complete_pending(state, MQTT_EVENT_TYPE_SUBSCRIBED); break; case MQTT_MSG_TYPE_UNSUBACK: if(state->pending_msg_type == MQTT_MSG_TYPE_UNSUBSCRIBE && state->pending_msg_id == msg_id) complete_pending(state, MQTT_EVENT_TYPE_UNSUBSCRIBED); break; case MQTT_MSG_TYPE_PUBLISH: if(msg_qos == 1) state->outbound_message = mqtt_msg_puback(&state->mqtt_connection, msg_id); else if(msg_qos == 2) state->outbound_message = mqtt_msg_pubrec(&state->mqtt_connection, msg_id); deliver_publish(state, state->in_buffer, state->message_length_read); break; case MQTT_MSG_TYPE_PUBACK: if(state->pending_msg_type == MQTT_MSG_TYPE_PUBLISH && state->pending_msg_id == msg_id) complete_pending(state, MQTT_EVENT_TYPE_PUBLISHED); break; case MQTT_MSG_TYPE_PUBREC: state->outbound_message = mqtt_msg_pubrel(&state->mqtt_connection, msg_id); break; case MQTT_MSG_TYPE_PUBREL: state->outbound_message = mqtt_msg_pubcomp(&state->mqtt_connection, msg_id); break; case MQTT_MSG_TYPE_PUBCOMP: if(state->pending_msg_type == MQTT_MSG_TYPE_PUBLISH && state->pending_msg_id == msg_id) complete_pending(state, MQTT_EVENT_TYPE_PUBLISHED); break; case MQTT_MSG_TYPE_PINGREQ: state->outbound_message = mqtt_msg_pingresp(&state->mqtt_connection); break; case MQTT_MSG_TYPE_PINGRESP: // Ignore break; } // NOTE: this is done down here and not in the switch case above // because the PSOCK_READBUF_LEN() won't work inside a switch // statement due to the way protothreads resume. if(msg_type == MQTT_MSG_TYPE_PUBLISH) { uint16_t len; // adjust message_length and message_length_read so that // they only account for the publish data and not the rest of the // message, this is done so that the offset passed with the // continuation event is the offset within the publish data and // not the offset within the message as a whole. len = state->message_length_read; mqtt_get_publish_data(state->in_buffer, &len); len = state->message_length_read - len; state->message_length -= len; state->message_length_read -= len; while(state->message_length_read < state->message_length) { PSOCK_READBUF_LEN(&state->ps, state->message_length - state->message_length_read); deliver_publish_continuation(state, state->message_length_read, state->in_buffer, PSOCK_DATALEN(&state->ps)); state->message_length_read += PSOCK_DATALEN(&state->ps); } } } PSOCK_END(&state->ps); }
/* * A protosocket always requires a protothread. The protothread * contains the code that uses the protosocket. We define the * protothread here. */ static PT_THREAD(connection_setup(struct psock *p)) { /* * A protosocket's protothread must start with a PSOCK_BEGIN(), with * the protosocket as argument. */ PSOCK_BEGIN(p); printf("TIME: %d\n",clock_time()); /* * Here we define all the thread local variables that we need to * utilize. */ static ServerGreeting greet; static SetupResponseUAuth setup; static ServerStartMsg start; static int i; static int acceptedMode = 1; /* * We configure the Server-Greeting that we want to send. Setting * the accepted modes to those we accept. The following modes are * meaningful: * 1 - Unauthenticated * 2 - Authenticated * 3 - Encrypted * 0 - Do not wish to communicate. */ memset(&greet, 0, sizeof(greet)); greet.Modes = 1; /* * We generate random sequence of octects for the challenge and * salt. */ for (i = 0; i < 16; i++){ greet.Challenge[i] = rand() % 16; } for (i = 0; i < 16; i++){ greet.Salt[i] = rand() % 16; } /* * Count must be a power of 2 and be at least 1024. */ //greet.Count = (1 << 12); /* * We set the MBZ octets to zero. */ for (i = 0; i < 12; i++){ greet.MBZ[i] = 0; } /* * Using PSOCK_SEND() we send the Server-Greeting to the connected * client. */ PSOCK_SEND(p, &greet, sizeof(greet)); /* * We wait until we receive a server greeting from the server. * PSOCK_NEWDATA(p) returns 1 when new data has arrived in * the protosocket. */ PSOCK_WAIT_UNTIL(p,PSOCK_NEWDATA(p)); if(PSOCK_NEWDATA(p)){ /* * We read data from the buffer now that it has arrived. * Using memcpy we store it in our local variable. */ PSOCK_READBUF(p); memcpy(&setup,buffer,sizeof(setup)); if(setup.Modes != acceptedMode){ printf("Client did not match our modes!\n"); PSOCK_CLOSE_EXIT(p); } else{ /* * We have agreed upon the mode. Now we send the Server-Start * message. */ memset(&start,0,sizeof(start)); /* * We set the MBZ octets to zero. */ for (i = 0; i < 15; i++){ start.MBZ1[i] = 0; } for (i = 0; i < 8; i++){ start.MBZ2[i] = 0; } /* * The accept field is set to zero if the server wishes to continue * communicating. A non-zero value is defined as in RFC 4656. */ start.Accept = 0; /* * Timestamp is set to the time the Server started. */ double temp; start.timestamp.Second = clock_seconds(); temp = (double) clock_time()/CLOCK_SECOND - start.timestamp.Second; start.timestamp.Fraction = temp*1000; /* * Using PSOCK_SEND() we send the Server-Start to the connected * client. */ PSOCK_SEND(p, &start, sizeof(start)); printf("Client agreed to mode: %d\n",setup.Modes); } } else { printf("Timed out!\n"); } state = 2; PSOCK_END(p); }