/*---------------------------------------------------------------------------*/
PROCESS_THREAD(border_router_process, ev, data)
{
static struct etimer et;
PROCESS_BEGIN();
/* While waiting for the prefix to be sent through the SLIP connection, the future
* border router can join an existing DAG as a parent or child, or acquire a default
* router that will later take precedence over the SLIP fallback interface.
* Prevent that by turning the radio off until we are initialized as a DAG root.
*/
prefix_set = 0;
PROCESS_PAUSE();
PRINTF("RPL-Border router started\n");
/* Request prefix until it has been received */
while(!prefix_set) {
etimer_set(&et, CLOCK_SECOND);
request_prefix();
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
PRINTF("Waiting for prefix\n");
}
PRINTF("Obtained prefix: ");
uip_debug_ipaddr_print(&prefix);
PRINTF("\n");
rpl_tools_init(&prefix);
etimer_set(&et, CLOCK_SECOND * 60);
while(1) {
print_network_status();
PROCESS_YIELD_UNTIL(etimer_expired(&et));
etimer_reset(&et);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(p_inputs, ev, data)
{
//déclaration des variables
static terraZooData_s* theDataStruct;
static int16_t aTemperature;
static int16_t aLight;
PROCESS_BEGIN();
PRINTF("[p_inputs] Process Begin\r\n");
//Initialisations
theDataStruct=NULL;
aTemperature=0;
aLight=0;
while (1)
{
PROCESS_WAIT_EVENT_UNTIL(ev==P_IN_START);
PRINTF("[p_inputs] Restart\r\n");
theDataStruct=(terraZooData_s*)data;
//Get temp
aTemperature=gettmp();
theDataStruct->theTemp=aTemperature;
PRINTF("[p_inputs] Temp : %d\r\n", theDataStruct->theTemp);
//Get light
aLight=500;//getlight();
theDataStruct->theLight=aLight;
PRINTF("[p_inputs] Light : %d\r\n", aLight);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(shell_senseconv_process, ev, data)
{
struct shell_input *input;
struct sense_msg *msg;
PROCESS_BEGIN();
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == shell_event_input);
input = data;
if(input->len1 + input->len2 == 0) {
PROCESS_EXIT();
}
msg = (struct sense_msg *)input->data1;
if(msg != NULL) {
char buf[40];
snprintf(buf, sizeof(buf),
"%d", 10 * msg->light1 / 7);
shell_output_str(&senseconv_command, "Light 1 ", buf);
snprintf(buf, sizeof(buf),
"%d", 46 * msg->light2 / 10);
shell_output_str(&senseconv_command, "Light 2 ", buf);
snprintf(buf, sizeof(buf),
"%d.%d", (msg->temp / 10 - 396) / 10,
(msg->temp / 10 - 396) % 10);
shell_output_str(&senseconv_command, "Temperature ", buf);
snprintf(buf, sizeof(buf),
"%d", (int)(-4L + 405L * msg->humidity / 10000L));
shell_output_str(&senseconv_command, "Relative humidity ", buf);
snprintf(buf, sizeof(buf),
"%d", msg->rssi);
shell_output_str(&senseconv_command, "RSSI ", buf);
snprintf(buf, sizeof(buf), /* 819 = 4096 / 5 */
"%d.%d", (msg->voltage / 819), (10 * msg->voltage / 819) % 10);
shell_output_str(&senseconv_command, "Voltage ", buf);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(enc_watchdog_process, ev, data)
{
static struct etimer et;
PROCESS_BEGIN();
while(1) {
#define RESET_PERIOD (30*CLOCK_SECOND)
etimer_set(&et, RESET_PERIOD);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
PRINTF("enc28j60: test received_packet %d > sent_packets %d\n", received_packets, sent_packets);
if(received_packets <= sent_packets) {
PRINTF("enc28j60: resetting chip\n");
reset();
}
received_packets = 0;
sent_packets = 0;
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(tcp_server, ev, data)
{
PROCESS_BEGIN();
tcp_listen(UIP_HTONS(8080));
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);
printf("TCP server: receive TCP event\n");
if(uip_closed() || uip_aborted() || uip_timedout()) {
printf("TCP server: connection closed\n");
} else if(uip_connected()) {
printf("TCP server: connected\n");
}
if(uip_newdata()) {
printf("TCP server: receive new data\n");
uint16_t len = uip_datalen();
uint8_t *ptr = uip_appdata;
while(len--){
printf("%c", *ptr++);
}
printf("\n");
printf("TCP server: send echo message\n");
uip_send(uip_appdata, uip_datalen());
}
if(uip_rexmit() ||
uip_newdata() ||
uip_acked() ||
uip_connected() ||
uip_poll()) {
//senddata();
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(sender_process, ev, data)
{
PROCESS_BEGIN();
static uip_ipaddr_t ipaddr, unicastaddr;
int i;
uint8_t state;
static struct etimer timer;
static struct simple_udp_connection connection;
static char *packet = "Supertest";
uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0);
uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr);
uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF);
uip_ip6addr(&unicastaddr, 0xfe80, 0, 0, 0, 0xc30c, 0, 0, 2);
simple_udp_register(&connection, UDP_PORT, NULL, UDP_PORT, NULL);
printf("IPv6 addresses: ");
for(i = 0; i < UIP_DS6_ADDR_NB; i++) {
state = uip_ds6_if.addr_list[i].state;
if(uip_ds6_if.addr_list[i].isused &&
(state == ADDR_TENTATIVE
|| state == ADDR_PREFERRED)) {
uip_debug_ipaddr_print(
&uip_ds6_if.addr_list[i].ipaddr);
printf("\n");
}
}
etimer_set(&timer, CLOCK_SECOND);
while(1) {
printf("STO MANDANDO UNICAST\n");
simple_udp_sendto(&connection, packet, strlen(packet)+1, &unicastaddr);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&timer));
etimer_restart(&timer);
}
PROCESS_END();
}
PROCESS_THREAD(led_on, ev, data)
{
static struct etimer etmr;
WDTE=0xac;
PROCESS_BEGIN();
etimer_set(&etmr, CLOCK_CONF_SECOND);
event_led_on = process_alloc_event();
while(1)
{
PROCESS_WAIT_EVENT_UNTIL(ev==PROCESS_EVENT_TIMER);
// offled = (~offled);
// BELL = 0;
process_post(&led_off, event_led_on, NULL);
etimer_reset(&etmr);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(data_process, ev, data)
{
static struct etimer et;
//uint32_t transmit, listen, all_transmit, all_listen;
//static uint32_t last_transmit, last_listen;
PROCESS_BEGIN();
PRINTF("Energy process started\n");
while(1) {
/*
all_transmit = energest_type_time(ENERGEST_TYPE_TRANSMIT);
all_listen = energest_type_time(ENERGEST_TYPE_LISTEN);
transmit = all_transmit - last_transmit;
listen = all_listen - last_listen;
last_transmit = all_transmit;
last_listen = all_listen;
*/
printf("%d %d %d %d \n", uip_stat.ip.sent, uip_stat.ip.forwarded, uip_stat.ip.recv, uip_stat.ip.drop);
/* Delay 2-4 seconds */
etimer_set(&et, CLOCK_SECOND * 30);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
// printf(" %d %d %d\n",uip_stat.ip.sent, uip_stat.ip.forwarded, uip_stat.ip.recv);
// rpl_print_neighbor_list();
// print_local_addresses();
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(http_example_process, ev, data)
{
static struct etimer et;
uip_ip4addr_t ip4addr;
uip_ip6addr_t ip6addr;
PROCESS_BEGIN();
uip_ipaddr(&ip4addr, 8, 8, 8, 8);
ip64_addr_4to6(&ip4addr, &ip6addr);
uip_nameserver_update(&ip6addr, UIP_NAMESERVER_INFINITE_LIFETIME);
etimer_set(&et, CLOCK_SECOND * 20);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
memset(url_buffer, 0, HTTP_CLIENT_BUFFER_LEN);
snprintf(url_buffer, HTTP_CLIENT_BUFFER_LEN,
"http://maker.ifttt.com/trigger/%s/with/key/%s",
IFTTT_EVENT, IFTTT_KEY);
http_socket_init(&s);
restarts = 0;
while(1) {
PROCESS_YIELD();
if((ev == sensors_event) && (data == &button_sensor)) {
if(button_sensor.value(BUTTON_SENSOR_VALUE_TYPE_LEVEL) ==
BUTTON_SENSOR_PRESSED_LEVEL) {
leds_on(LEDS_GREEN);
printf("Button pressed! sending a POST to IFTTT\n");
http_socket_post(&s, url_buffer, NULL, 0, NULL, callback, NULL);
}
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(sample_mag_process, ev, data)
{
static struct etimer et;
PROCESS_BEGIN();
SENSORS_ACTIVATE(hmc5883l_sensor);
/* Sample every 2 seconds */
etimer_set(&et, 2*CLOCK_SECOND);
while(1) {
struct mag_msg msg;
/* Wait for timer */
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
/* Reset timer:
* It will expire exactly 2 seconds after last expiration */
etimer_reset(&et);
msg.type = TYPE_MAG;
/* Our position */
msg.pos_x = 0; /* TODO Estimate X coordinate [1-100] */
msg.pos_y = 0; /* TODO Estimate Y coordinate [1-100] */
// Must latch the data first before getting mag_x, y, z
hmc5883l_sensor.value(HMC5883L_LATCH_DATA);
msg.mag_x = hmc5883l_sensor.value(HMC5883L_MAG_X_RAW);
msg.mag_y = hmc5883l_sensor.value(HMC5883L_MAG_Y_RAW);
msg.mag_z = hmc5883l_sensor.value(HMC5883L_MAG_Z_RAW);
/* Print position and mag */
printf("pos=(%u,%u) mag=[%4d, %4d, %4d]\n", msg.pos_x, msg.pos_y, msg.mag_x, msg.mag_y, msg.mag_z);
FLASH_LED(LEDS_GREEN);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(shell_size_process, ev, data)
{
static unsigned long size;
struct shell_input *input;
char buf[10];
PROCESS_BEGIN();
size = 0;
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == shell_event_input);
input = data;
size += input->len1 + input->len2;
if(input->len1 + input->len2 == 0) {
snprintf(buf, sizeof(buf), "%lu", size);
shell_output_str(&size_command, buf, "");
PROCESS_EXIT();
}
}
PROCESS_END();
}
PROCESS_THREAD(UDP_echo_process, ev, data)
{
static uip_ipaddr_t localaddr;
static struct uip_udp_conn *localconn;
PROCESS_BEGIN();
/* Create the local listener */
localconn = udp_new(&uip_all_zeroes_addr, 0, NULL);
udp_bind(localconn,uip_htons(local_port));
while (1)
{
PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);
/* If there is new uIP data, display it */
if(uip_newdata()) {
/* Add the end of string. */
((char *)uip_appdata)[uip_datalen()] = 0;
printf("New uIP data: '%s'\n", uip_appdata);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(shell_timestamp_process, ev, data)
{
struct shell_input *input;
struct msg {
uint16_t len;
uint16_t time[2];
uint16_t timesynch;
uint8_t data[MAX_COMMANDLENGTH];
} msg;
PROCESS_BEGIN();
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == shell_event_input);
input = data;
if(input->len1 + input->len2 == 0) {
PROCESS_EXIT();
}
msg.len = 3 + *(uint16_t *)input->data1;
msg.time[0] = (uint16_t)(shell_time() >> 16);
msg.time[1] = (uint16_t)(shell_time());
#if TIMESYNCH_CONF_ENABLED
msg.timesynch = timesynch_time();
#else /* TIMESYNCH_CONF_ENABLED */
msg.timesynch = 0;
#endif /* TIMESYNCH_CONF_ENABLED */
memcpy(msg.data, input->data1 + 2,
input->len1 - 2 > MAX_COMMANDLENGTH?
MAX_COMMANDLENGTH: input->len1 - 2);
shell_output(×tamp_command, &msg, 6 + input->len1,
input->data2, input->len2);
}
PROCESS_END();
}
PROCESS_THREAD(gatewaytest_process, ev, data)
{
static struct etimer et;
PROCESS_BEGIN();
char tempstr[32];
uint16_t tmp;
broadcast_open(&broadcast, 129, &broadcast_call);
printf("Initiating em4325\r\n");
em_init();
stcn75_init();
while(1) {
etimer_set(&et, CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
//leds_toggle(LEDS_ALL);
//read em mem
//printf("read em status: %x\r\n",em_get_status());
//printf("mem: %x ", em_read_word(0x2c));
//write em mem
//printf("write status: %x\r\n",em_write_word(0x2C,0xacab));
//read gateway temp
//stcn75_read(&tmp);
//printf("onboard temp: %dC \r\n",tmp);
//Send hello
/* packetbuf_copyfrom("Hello", 6);
broadcast_send(&broadcast);
printf("broadcast message sent\n\r");
*/
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(ds18b20_poll_process, ev, data)
{
static struct etimer et;
static uint8_t scratchpad[DS18B20_SCRATCHPAD_SIZE];
static ow_rom_code_t id;
PROCESS_BEGIN();
printf("\nDS18B20 test\n");
printf("VSEC ON\n");
power_control_vsec_set(1);
/* initialize the DS18B20 hardware */
printf("Initialize 1-wire\n");
ow_init();
printf("1-wire READ ROM\n");
id = ow_read_rom();
printf("Initialize DS18B20\n");
ds18b20_init();
printf("DS18B20 init done\n");
/* Poll at 1Hz */
etimer_set(&et, CLOCK_SECOND);
while(1) {
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
/* Reset the etimer to trig again */
etimer_reset(&et);
ds18b20_read_scratchpad(id, scratchpad);
ds18b20_convert_temperature(id);
}
PROCESS_END();
}
PROCESS_THREAD(schedule_task, ev, data)
{
static int i;
static int min;
static int min_slot;
static int flag;
static struct application_struct new_task;
PROCESS_BEGIN();
new_task.load=((struct application_struct *)data)->load;
new_task.lower_slot=((struct application_struct *)data)->lower_slot;
new_task.upper_slot=((struct application_struct *)data)->upper_slot;
flag=0;
do{
min=hourly_load[new_task.lower_slot];
min_slot=new_task.lower_slot;
for(i=(new_task.lower_slot+1);i<=new_task.upper_slot;i++){
if (hourly_load[i]<min){
min_slot=i;
min=hourly_load[i];
}
}
Shared_Comp_and_Swap(min_slot,min,min+new_task.load);
PROCESS_WAIT_EVENT_UNTIL(ev == event_2pc_to_comm );
if(!(strcmp(data,"BCAST_S"))){
printf("Comp and Swap was succ\n");
flag=1;
}
else{
printf("Comp and Swap was not succ\n");
}
}
while(flag==0);
PROCESS_END();
}
PROCESS_THREAD(test, ev, data)
{
static struct etimer et;
PROCESS_BEGIN();
myaddr = init_l2addr_154_char("45:67");
l2 = startL2_154( myaddr, CHANNEL, PANID);
ca = initCasan(l2, MTU, slaveid);
r1 = initResource (R1_name, R1_title, R1_rt) ;
setHandlerResource(r1, COAP_CODE_GET, process_temp );
register_resource(ca, r1);
r2 = initResource (R2_name, R2_title, R2_rt) ;
setHandlerResource(r2, COAP_CODE_GET, process_temp );
register_resource(ca, r2);
while(1) {
if (n % NTAB (resname) == 0)
print_resources (ca) ;
test_resource (ca, l2, resname [n++ % NTAB (resname)]) ;
printf("\n");
printf("*************************************************************************");
printf("\n");
etimer_set(&et,5*CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
}
PROCESS_END();
}
/* Process to get ht sensor value.
ht sensor is sampled. Sampling stopped when sensor is de-activated.
Event is generated if temp and/or hum value changed at least the value DELTA_TEMP_SENSOR_VALUE
or DELTA_HUM_SENSOR_VALUE since last event. */
PROCESS_THREAD(HTSensorSampling, ev, data)
{
PROCESS_BEGIN();
static struct etimer et;
etimer_set(&et, CLOCK_SECOND);
while(1) {
PROCESS_WAIT_EVENT_UNTIL((ev == PROCESS_EVENT_TIMER) || (ev == PROCESS_EVENT_MSG));
if(ev == PROCESS_EVENT_TIMER) {
/* Handle sensor reading. */
vHTSstartReadTemp();
temp_sensor_value = u16HTSreadTempResult();
PRINTF("Temperature sample: %d\n", temp_sensor_value);
vHTSstartReadHumidity();
hum_sensor_value = u16HTSreadHumidityResult();
PRINTF("Humidity sample: %d\n", hum_sensor_value);
if((abs(temp_sensor_value - prev_temp_event_val) > DELTA_TEMP_SENSOR_VALUE) ||
(abs(hum_sensor_value - prev_hum_event_val) > DELTA_HUM_SENSOR_VALUE)) {
prev_temp_event_val = temp_sensor_value;
prev_hum_event_val = hum_sensor_value;
sensors_changed(&ht_sensor);
}
etimer_reset(&et);
} else {
/* ev == PROCESS_EVENT_MSG */
if(*(int *)data == HT_SENSOR_STATUS_NOT_ACTIVE) {
/* Stop sampling */
etimer_stop(&et);
} else if((*(int *)data == HT_SENSOR_STATUS_ACTIVE)) {
/* restart sampling */
etimer_restart(&et);
}
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(sensors_process, ev, data)
{
static int i;
static int events;
PROCESS_BEGIN();
sensors_event = process_alloc_event();
for(i = 0; sensors[i] != NULL; ++i) {
sensors_flags[i] = 0;
sensors[i]->configure(SENSORS_HW_INIT, 0);
}
num_sensors = i;
while(1) {
PROCESS_WAIT_EVENT();
do {
events = 0;
for(i = 0; i < num_sensors; ++i) {
if(sensors_flags[i] & FLAG_CHANGED) {
if(process_post(PROCESS_BROADCAST, sensors_event, (void *)sensors[i]) == PROCESS_ERR_OK) {
PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event);
}
sensors_flags[i] &= ~FLAG_CHANGED;
events++;
}
}
} while(events);
}
PROCESS_END();
}
PROCESS_THREAD(accel_process, ev, data) {
PROCESS_BEGIN();
{
int16_t x, y, z;
serial_shell_init();
shell_ps_init();
shell_file_init(); // for printing out files
shell_text_init(); // for binprint
/* Register the event used for lighting up an LED when interrupt strikes. */
ledOff_event = process_alloc_event();
/* Start and setup the accelerometer with default values, eg no interrupts enabled. */
accm_init();
/* Register the callback functions for each interrupt */
ACCM_REGISTER_INT1_CB(accm_ff_cb);
ACCM_REGISTER_INT2_CB(accm_tap_cb);
/* Set what strikes the corresponding interrupts. Several interrupts per pin is
possible. For the eight possible interrupts, see adxl345.h and adxl345 datasheet. */
accm_set_irq(ADXL345_INT_FREEFALL, ADXL345_INT_TAP + ADXL345_INT_DOUBLETAP);
while (1) {
x = accm_read_axis(X_AXIS);
y = accm_read_axis(Y_AXIS);
z = accm_read_axis(Z_AXIS);
printf("x: %d y: %d z: %d\n", x, y, z);
etimer_set(&et, ACCM_READ_INTERVAL);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(sensor_output_process, ev, data)
{
struct sensors_sensor *s;
PROCESS_BEGIN();
/* Activate some sensors to get sensor events */
button_sensor.configure(SENSORS_ACTIVE, 1);
pir_sensor.configure(SENSORS_ACTIVE, 1);
vib_sensor.configure(SENSORS_ACTIVE, 1);
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event);
s = (struct sensors_sensor *)data;
printf("%s %d\n", s->type, s->value(0));
if (data == &button_sensor) leds_invert(LEDS_YELLOW);
if (data == &pir_sensor) leds_invert(LEDS_GREEN);
if (data == &vib_sensor) leds_invert(LEDS_RED);
}
PROCESS_END();
}
/* periodic broadcast light sensor data */
PROCESS_THREAD(spam_process, ev, data) {
PROCESS_BEGIN();
SENSORS_ACTIVATE(light_sensor);
// init
leds_off(LEDS_ALL);
int light_val = 0;
while(1) {
// wait a bit
static struct etimer et;
etimer_set(&et, 1 * CLOCK_SECOND / 2);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
// send packet
light_val = light_sensor.value(LIGHT_SENSOR_PHOTOSYNTHETIC);
packetbuf_copyfrom(&light_val, sizeof(int));
broadcast_send(&broadcast_connection);
}
SENSORS_DEACTIVATE(light_sensor);
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(shell_send_process, ev, data)
{
struct shell_input *input;
int len;
struct collect_msg *msg;
PROCESS_BEGIN();
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == shell_event_input);
input = data;
len = input->len1 + input->len2;
if(len == 0) {
PROCESS_EXIT();
}
if(len < PACKETBUF_SIZE) {
packetbuf_clear();
packetbuf_set_datalen(len + COLLECT_MSG_HDRSIZE);
msg = packetbuf_dataptr();
memcpy(msg->data, input->data1, input->len1);
memcpy(msg->data + input->len1, input->data2, input->len2);
#if TIMESYNCH_CONF_ENABLED
msg->timestamp = timesynch_time();
#else
msg->timestamp = 0;
#endif
msg->crc = crc16_data(msg->data, len, 0);
/* printf("Sending %d bytes\n", len);*/
collect_send(&collect, COLLECT_REXMITS);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(temp_filter_process, ev, data)
{
static struct etimer et;
#define NUMBER_TO_AVERAGE 20
static uint8_t avg = 0;
static uint8_t n = 0;
static uint8_t fake_temp = 17;
PROCESS_BEGIN();
while (1) {
//pretend measurement
if (n == 0) {
avg = fake_temp;
} else {
avg = (avg * n + fake_temp) / (n + 1);
}
n++;
if (n == NUMBER_TO_AVERAGE) {
// send here, then reset this crap
avg = 0;
n = 0;
}
etimer_set(&et, (CLOCK_SECOND * 0.1));
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
}
PROCESS_END();
}
PROCESS_THREAD(rime_unicast_sender, ev, data)
{
PROCESS_EXITHANDLER(unicast_close(&uc));
PROCESS_BEGIN();
leds_init();
leds_off(LEDS_ALL);
SENSORS_ACTIVATE(button_sensor);//activate button
unicast_open(&uc, 290, &unicast_callbacks); // channel = 122
while(1)
{
static struct etimer et;
rimeaddr_t addr;
PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor);
//etimer_set(&et, CLOCK_SECOND);
//PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
packetbuf_copyfrom(SECRET, 15); // String + Length to be send
//packetbuf_copyfrom("ekhais8ca6Aej0", 15); // String + Length to be send
addr.u8[0] = 0x28; // Address of receiving Node
addr.u8[1] = 0x1;
if(!rimeaddr_cmp(&addr, &rimeaddr_node_addr))
{
printf("Message sent\n"); // debug message
unicast_send(&uc, &addr);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(web_sense_process, ev, data)
{
static struct etimer timer;
PROCESS_BEGIN();
cc2420_set_txpower(31);
sensors_pos = 0;
process_start(&webserver_nogui_process, NULL);
etimer_set(&timer, CLOCK_SECOND * 2);
SENSORS_ACTIVATE(battery_sensor);
SENSORS_ACTIVATE(temperature_sensor);
while(1) {
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&timer));
etimer_reset(&timer);
battery1[sensors_pos] = get_mybatt()*1000;
temperature[sensors_pos] = get_mytemp();
sensors_pos = (sensors_pos + 1) % HISTORY;
}
PROCESS_END();
}
PROCESS_THREAD(reading_level_process, ev, data)
{
PROCESS_BEGIN();
active = 0;
SENSORS_ACTIVATE(button_sensor);
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event &&
data == &button_sensor);
leds_toggle(LEDS_ALL);
if(!active) {
/* activate light sensor */
SENSORS_ACTIVATE(level_sensor);
printf("Level: %d\n", level_sensor.value(2));
} else {
/* deactivate light sensor */
printf("Level: %d\n", level_sensor.value(2));
SENSORS_DEACTIVATE(level_sensor);
}
active ^= 1;
leds_toggle(LEDS_ALL);
}
PROCESS_END();
}
PROCESS_THREAD(doorAutoOpeningProcess, ev, data)
{
static struct etimer initialDelay;
static struct etimer blinkingTimer;
static int blinkings;
static clock_time_t remainingDelay;
PROCESS_BEGIN();
printf("Door auto opening: started\n");
remainingDelay = DOOR_AUTO_OPENING_DELAY * CLOCK_SECOND;
while(1)
{
printf("Door auto opening: waiting initial delay\n");
etimer_set(&initialDelay, remainingDelay);
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_TIMER && etimer_expired(&initialDelay))
break;
else if( ev == alarm_toggled_event)
{
printf("Door auto opening: delay interrupted by alarm\n");
remainingDelay = etimer_expiration_time(&initialDelay) - clock_time();
etimer_stop(&initialDelay);
PROCESS_WAIT_EVENT_UNTIL(ev == alarm_toggled_event);
printf("Door auto opening: alarm stopped, resuming delay\n");
}
}
printf("Door auto opening: door opened\n");
setLock(UNLOCKED);
printf("Door auto opening: blinking started\n");
blinkings = 0;
leds_on(LEDS_BLUE);
while(blinkings < AUTO_OPENING_BLINKINGS - 1)
{
etimer_set(&blinkingTimer, (AUTO_OPENING_LED_PERIOD / 2) * CLOCK_SECOND);
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_TIMER && etimer_expired(&blinkingTimer))
{
printf("Door auto opening: blinking\n");
leds_toggle(LEDS_BLUE);
etimer_reset(&blinkingTimer);
blinkings++;
}
else if(ev == alarm_toggled_event)
{
printf("Door auto opening: blinking interrupted by alarm\n");
etimer_stop(&blinkingTimer);
PROCESS_WAIT_EVENT_UNTIL(ev == alarm_toggled_event);
printf("Door auto opening: alarm stopped, resuming blinking\n");
}
}
printf("Door auto opening: blinking stopped\n");
printf("Gate auto opening: door locked\n");
setLock(LOCKED);
PROCESS_END();
}
PROCESS_THREAD(scanning, ev, data)
{
PROCESS_BEGIN();
// Initial operations
leds_off(LEDS_ALL);
watchdog_stop();
// Avoiding wrong RSSI readings
unsigned temp;
CC2420_READ_REG(CC2420_AGCTST1, temp);
CC2420_WRITE_REG(CC2420_AGCTST1, (temp + (1 << 8) + (1 << 13)));
// Selecting the channel
SPI_SETCHANNEL_SUPERFAST(357+((CHANNEL-11)*5));
// Avoiding the initial wrong readings by discarding the wrong readings
CC2420_SPI_ENABLE();
unsigned long k=0;
for (k=0; k<=15; k++) {MY_FASTSPI_GETRSSI(temp);}
CC2420_SPI_DISABLE();
static struct etimer et;
while(1){
#if VERBOSE
printf("#START (dBm: occurrencies)\n");
#endif
// Resetting everything
for(k=0;k<BUFFER_SIZE;k++){
buffer0[k] = 0;
}
dint(); // Disable interrupts
boost_cpu(); // Temporarily boost CPU speed
CC2420_SPI_ENABLE(); // Enable SPI
// Actual scanning
static signed char rssi;
for(k=0; k<MAX_VALUE; k++){
MY_FASTSPI_GETRSSI(rssi);
buffer0[rssi+55]++;
}
CC2420_SPI_DISABLE(); // Disable SPI
restore_cpu(); // Restore CPU speed
eint(); // Re-enable interrupts
// Printing the stored values in compressed form
unsigned long sum_cca = 0;
unsigned long max = 0, max_value = 0;
for(temp=0; temp<BUFFER_SIZE; temp++) {
sum_cca += (temp * buffer0[temp]);
if(buffer0[temp] > max){
max = buffer0[temp];
max_value = temp;
}
}
// Printing the results of the CCA
float f_cca = (((float) sum_cca*1.0000) / MAX_VALUE)-100.0000;
#if VERBOSE
printf("Average noise: %ld.%04u\nStatistic Mode noise: %ld\n", (long) f_cca, (unsigned)((f_cca-floor(f_cca))*10000), max_value-100);
#else
printf("%ld.%04u\n", (long) f_cca, (unsigned)((f_cca-floor(f_cca))*10000));
#endif
#if VERBOSE
printf("#END\n");
#endif
// Waiting for timer
etimer_set(&et, PERIOD_TIME);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
}
PROCESS_WAIT_EVENT();
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(shell_randwait_process, ev, data)
{
static int maxwait;
static char command[MAX_COMMANDLENGTH];
static struct etimer etimer;
static struct process *started_process;
const char *args, *next;
int ret;
/* if(ev == shell_event_input) {
struct shell_input *input;
input = data;
printf("shell randwait input %d %d\n", input->len1, input->len2);
if(input->len1 + input->len2 != 0) {
shell_output(&randwait_command, input->data1, input->len1,
input->data2, input->len2);
}
}*/
PROCESS_BEGIN();
args = data;
if(args == NULL) {
shell_output_str(&randwait_command, "usage 0", "");
PROCESS_EXIT();
}
maxwait = shell_strtolong(args, &next);
if(next == args) {
shell_output_str(&randwait_command, "usage 1", "");
PROCESS_EXIT();
}
args = next;
while(*args == ' ') {
args++;
}
strncpy(command, args, MAX_COMMANDLENGTH);
if(strlen(command) == 0) {
shell_output_str(&repeat_command, "usage 3", "");
PROCESS_EXIT();
}
/* printf("randwait %d command '%s'\n",
maxwait, command);*/
etimer_set(&etimer, random_rand() % (CLOCK_SECOND * maxwait));
PROCESS_WAIT_UNTIL(etimer_expired(&etimer));
/* printf("Starting '%s' child %p (%s)\n", command, randwait_command.child, */
/* randwait_command.child == NULL? "null": randwait_command.child->command); */
ret = shell_start_command(command, (int)strlen(command),
randwait_command.child, &started_process);
if(started_process != NULL &&
process_is_running(started_process)) {
PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_EXITED &&
data == started_process);
}
PROCESS_END();
}
