/*---------------------------------------------------------------------------*/
void
trickle_close(struct trickle_conn *c)
{
broadcast_close(&c->c);
ctimer_stop(&c->t);
ctimer_stop(&c->interval_timer);
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(broadcast_process, ev, data)
{
static struct etimer et;
static uint8_t seqno;
struct broadcast_message msg;
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
/* server broadcast process
// The “server_broadcast” process , periodically (every 1.5 seconds ) sends the number of available files which is represented by the binary vector Vs
// A flag variable is used to start/stop the broadcast of available files.
*/
PROCESS_THREAD(server_broadcast, ev, data)
{
// create timer
static struct etimer et;
// exit handler
PROCESS_EXITHANDLER(broadcast_close(&serv_broadcast);)
PROCESS_THREAD(sniffer_process, ev, data)
{
static struct etimer et;
leds_off(LEDS_ALL); /* turn off LEDs */
SENSORS_ACTIVATE(button_sensor); /* turn on button sensor */
PROCESS_EXITHANDLER(broadcast_close(&bc));
PROCESS_BEGIN();
broadcast_open(&bc, SNIFFER_CHANNEL, &broadcast_call);
process_start(&wait_process, NULL); /* Start wait process. This will end the main process when a button sensor event is posted */
while(1) /* Infinite loop */
{
etimer_set(&et, CLOCK_SECOND * 2 * PERIOD); /* Wait 4 seconds per loop for a receive event */
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
#if DEBUG
printf("Loop\n");
#endif
}
SENSORS_DEACTIVATE(button_sensor); /* Deactivate sensor when we're done */
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(timesynch_process, ev, data)
{
static struct etimer sendtimer, intervaltimer;
static clock_time_t interval;
struct timesynch_msg msg;
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
/* This function is called whenever a broadcast message is received. */
static void
broadcast_recv(struct broadcast_conn *c, const rimeaddr_t *from)
{
struct broadcast_message *m;
struct unicast_message sMsg;
struct RTC_time t, t_now;
rimeaddr_t *add;
struct sensor_data tk;
m = (struct broadcast_message *)packetbuf_dataptr();
t = m->time;
if(id==0&&status==0)
{
rimeaddr_copy(&nmaddr, from);
sMsg.type = INIT_REQ;
sMsg.time = t;
sMsg.numSampl = 20;
strcpy(sMsg.name, "Dust sensor\0");
packetbuf_copyfrom(&sMsg, sizeof(struct unicast_message));
RTC_getTime(&t_now);
unicast_send(&unicast, &nmaddr);
broadcast_close(&broadcast);
status = 1;
return;
}
if(m->type == 1)
{
t = m->time;
}
}
/*---------------------------------------------------------------------------*/
void
neighbor_discovery_close(struct neighbor_discovery_conn *c)
{
broadcast_close(&c->c);
ctimer_stop(&c->send_timer);
ctimer_stop(&c->interval_timer);
}
/*---------------------------------------------------------------------------*/
void
broadcast_announcement_stop(void)
{
ctimer_stop(&c.interval_timer);
ctimer_stop(&c.send_timer);
broadcast_close(&c.c);
}
PROCESS_THREAD(shell_bc_close_process, ev, data)
{
uint16_t channel;
long channel_long;
const char *next;
char buf[6];
PROCESS_BEGIN();
channel_long = shell_strtolong((char *)data, &next);
if(channel_long <= 0 || channel_long > 65535){
shell_output_str(&bc_close_command, "channel has to be in range of [1-65535]", "");
PROCESS_EXIT();
}
channel = (uint16_t) channel_long;
snprintf(buf, sizeof(buf), "%d", channel);
struct broadcast_entry *e = list_head(broadcast_list);
while(e != NULL){
if(e->channel == channel){
struct broadcast_entry *to_remove = e;
e = e->next;
broadcast_close(&to_remove->c);
list_remove(broadcast_list, to_remove);
memb_free(&broadcast_mem, to_remove);
shell_output_str(&bc_close_command, "closed broadcast connection on channel: ", buf);
PROCESS_EXIT();
}
}
shell_output_str(&bc_close_command, "bc_close error: channel not open","");
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(blindnode_bcast_rec, ev, data)
{
static struct etimer et;
static uint8_t n;
int i;
PROCESS_EXITHANDLER(broadcast_close(&broadcast));
PROCESS_BEGIN();
printf("Reading Chip ID: 0x%02x\n", CHIPID);
/* Read our chip ID. If we are not cc2431, bail out */
if(CHIPID != CC2431_CHIP_ID) {
printf("Hardware does not have a location engine. Exiting.\n");
PROCESS_EXIT();
}
/* OK, we are cc2431. Do stuff */
n = 0;
/* Initalise our structs and parameters */
memset(ref_coords, 0, sizeof(struct refcoords) * MAX_REF_NODES);
memset(¶meters, 0, sizeof(struct meas_params));
/*
* Just hard-coding measurement parameters here.
* Ideally, this should be part of a calibration mechanism
*/
parameters.alpha=SAMPLE_ALPHA;
parameters.x_min=0;
parameters.x_delta=255;
parameters.y_min=0;
parameters.y_delta=255;
set_imaginary_ref_nodes();
broadcast_open(&broadcast, 129, &broadcast_call);
while(1) {
etimer_set(&et, CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
/*
* With the hard-coded parameters and locations, we will calculate
* for all possible values of n [0 , 31]
*/
parameters.n=n;
calculate();
n++;
if(n==32) { n=0; }
/* Send our calculated location to some monitoring node */
packetbuf_copyfrom(&coords, 2*sizeof(uint8_t));
broadcast_send(&broadcast);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(example_broadcast_process, ev, data)
{
static struct etimer et;
static clock_time_t start_time;
static uint32_t interval;
//static int i = 0;
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
PROCESS_THREAD(deluge_process, ev, data)
{
static struct etimer et;
static unsigned time_counter;
static unsigned r_rand;
PROCESS_EXITHANDLER(goto exit);
PROCESS_BEGIN();
deluge_event = process_alloc_event();
broadcast_open(&deluge_broadcast, DELUGE_BROADCAST_CHANNEL, &broadcast_call);
unicast_open(&deluge_uc, DELUGE_UNICAST_CHANNEL, &unicast_call);
r_interval = T_LOW;
PRINTF("Maintaining state for object %s of %d pages\n",
current_object.filename, OBJECT_PAGE_COUNT(current_object));
deluge_state = DELUGE_STATE_MAINTAIN;
for(r_interval = T_LOW;;) {
if(neighbor_inconsistency) {
/* Deluge M.2 */
r_interval = T_LOW;
neighbor_inconsistency = 0;
} else {
/* Deluge M.3 */
r_interval = (2 * r_interval >= T_HIGH) ? T_HIGH : 2 * r_interval;
}
r_rand = r_interval / 2 + ((unsigned)random_rand() % (r_interval / 2));
recv_adv = 0;
old_summary = 0;
/* Deluge M.1 */
ctimer_set(&summary_timer, r_rand * CLOCK_SECOND,
(void *)(void *)advertise_summary, ¤t_object);
/* Deluge M.4 */
ctimer_set(&profile_timer, r_rand * CLOCK_SECOND,
(void *)(void *)send_profile, ¤t_object);
LONG_TIMER(et, time_counter, r_interval);
}
exit:
unicast_close(&deluge_uc);
broadcast_close(&deluge_broadcast);
if(current_object.cfs_fd >= 0) {
cfs_close(current_object.cfs_fd);
}
if(current_object.pages != NULL) {
free(current_object.pages);
}
PROCESS_END();
}
/*MAIN THREAD------------------------------------------------------------------------------*/
PROCESS_THREAD(b_thread, ev, data)
{
static struct etimer send_timer, redelca_timer;
static uint32_t start_energy_cpu, start_energy_rx, start_energy_tx;
static uint32_t end_energy_cpu, end_energy_rx, end_energy_tx;
static char * msg, * my_x, * my_y, * position;
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
/*---------------------------------------------------------------------------*/
void
ipolite_close(struct ipolite_conn *c)
{
broadcast_close(&c->c);
ctimer_stop(&c->t);
if(c->q != NULL) {
queuebuf_free(c->q);
c->q = NULL;
}
}
PROCESS_THREAD(cmac_16hz, ev, data) {
static struct etimer et;
unsigned long last_cpu, last_lpm, last_tra, last_lis, curr_cpu, curr_lpm,
curr_tra, curr_lis;
last_cpu = 0;
last_lpm = 0;
last_tra = 0;
last_lis = 0;
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
PROCESS_THREAD(broadcast_process, ev, data)
{
static struct etimer et; /*timer to wait*/
if(!ifinit){
list_init(broadcast_list);
memb_init(&broadcast_list_memb);
list_init(routing_table);
memb_init(&routing_table_memb);
init_my_node(NODE_INIT);
ifinit = 1;
}
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(example_broadcast_process, ev, data) {
static struct etimer et;
pkg_hdr to_send;
int q,fd;
unsigned int new_seed;
unsigned short op;
//Adjacency matrix to be sent
uchar adj[TOT_NUM_NODES * TOT_NUM_NODES];
//Filling it
uchar i, j;
//Setting handlers and begin
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
static void
unicast_recv(struct unicast_conn *c, const rimeaddr_t *from)
{
printf("unicast message received from server with rime-address %d.%d: '%s'\n",
from->u8[0], from->u8[1], (char *)packetbuf_dataptr());
// Todo: Adresse korrekt uebergeben
//memcpy(&uip_lladdr.addr, &from->u8, sizeof(uip_lladdr)); //example: uip_lladdr = {{0x00,0x06,0x98,0x00,0x02,0x32}};
//memcpy(&uip_lladdr.addr, &from.u8, sizeof(rimeaddr_t));
unicast_close(&unicast);
broadcast_close(&broadcast);
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(sensors_test_process, ev, data)
{
static struct etimer et;
#if SEND_BATTERY_INFO
/* Node Time */
static struct sensor_data sd;
#endif
/* Sensor Values */
static int rv;
static struct sensors_sensor * sensor;
static float sane = 0;
static int dec;
static float frac;
#if SEND_BATTERY_INFO
PROCESS_EXITHANDLER(broadcast_close(&bc_con);)
static void
recv_broadcast(struct broadcast_conn *c, const linkaddr_t *from)
{
linkaddr_t daddy_addr;
// if this is a network setup packet, sent from an actuator
leds_toggle(LEDS_ALL); // toggle all leds
linkaddr_copy(&daddy_addr, from);
// Start data sending process.
process_start(&data_sender_process, NULL);
// remove the broadcast listener.
broadcast_close(&broadcast);
// endif
}
static void
recv_broadcast(struct broadcast_conn *c, const linkaddr_t *from)
{
struct broadcast *received_msg;
received_msg = packetbuf_dataptr();
struct broadcast br_msg;
if(received_msg->type == BROADCAST_TYPE_DISCOVERY)
{
if(received_msg->data != address_base)
{
address_base = received_msg->data;
printf("base station addr: %d\n",address_base);
printf("actuator: broadcast to neighbors\n");
br_msg.type = BROADCAST_TYPE_DISCOVERY;
br_msg.data = address_base;
packetbuf_copyfrom(&br_msg, sizeof(br_msg));
broadcast_send(&broadcast);
broadcast_close(&broadcast);
}
}
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(cc1200_demo_process, ev, data)
{
PROCESS_EXITHANDLER(broadcast_close(&bc))
PROCESS_BEGIN();
broadcast_open(&bc, BROADCAST_CHANNEL, &bc_rx);
etimer_set(&et, LOOP_INTERVAL);
while(1) {
PROCESS_YIELD();
if(ev == PROCESS_EVENT_TIMER) {
printf("Broadcast --> %u\n", counter);
leds_toggle(LEDS_RED);
packetbuf_copyfrom(&counter, sizeof(counter));
broadcast_send(&bc);
counter++;
etimer_set(&et, LOOP_INTERVAL);
}
}
PROCESS_END();
}
PROCESS_THREAD(cc26xx_demo_process, ev, data)
{
PROCESS_EXITHANDLER(broadcast_close(&bc))
PROCESS_BEGIN();
gpio_relay_init();
relay_all_clear();
counter = 0;
broadcast_open(&bc, BROADCAST_CHANNEL, &bc_rx);
etimer_set(&et, CLOCK_SECOND);
while(1) {
PROCESS_YIELD();
if(ev == PROCESS_EVENT_TIMER) {
leds_on(LEDS_PERIODIC);
etimer_set(&et, CLOCK_SECOND*5);
rtimer_set(&rt, RTIMER_NOW() + LEDS_OFF_HYSTERISIS, 1,
rt_callback, NULL);
counter = Get_ADC_reading();
packetbuf_copyfrom(&counter, sizeof(counter));
broadcast_send(&bc);
// printf("adc data value : %d \r\n",counter);
}
watchdog_periodic();
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(broadcast_receiver_process, ev, data)
{
static struct etimer et;
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(example_collect_process, ev, data)
{
static struct etimer periodic;
static struct etimer et;
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
/*---------------------------------------------------------------------------*/
void
unicast_close(struct unicast_conn *c)
{
broadcast_close(&c->c);
}
PROCESS_THREAD(hello_process, ev, data)
{
PROCESS_POLLHANDLER();
PROCESS_EXITHANDLER(broadcast_close(&bc); unicast_close(&uc););
/*---------------------------------------------------------------------------*/
void
stbroadcast_close(struct stbroadcast_conn *c)
{
broadcast_close(&c->c);
ctimer_stop(&c->t);
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(cc2538_demo_process, ev, data)
{
PROCESS_EXITHANDLER(broadcast_close(&bc))
PROCESS_BEGIN();
counter = 0;
broadcast_open(&bc, BROADCAST_CHANNEL, &bc_rx);
printf("temp:%u.%u\nhumidity:%u.%u\n",(int)tc,((int)(tc*10))%10 , (int)hc,((int)(hc*10))%10);
while(1) {
etimer_set(&et, CLOCK_SECOND*10);
//ivanm
// Configure ADC, Internal reference, 512 decimation rate (12bit)
//
SOCADCSingleConfigure(SOCADC_12_BIT, SOCADC_REF_INTERNAL);
//
// Trigger single conversion on AIN6 (connected to LV_ALS_OUT).
//
SOCADCSingleStart(SOCADC_VDD);
//
// Wait until conversion is completed
//
while(!SOCADCEndOfCOnversionGet())
{
}
//
// Get data and shift down based on decimation rate
//
ui1Dummy = SOCADCDataGet() >> SOCADC_12_BIT_RSHIFT;
printf("konverzija(ADC) = 0x%08x\n",ui1Dummy);
PROCESS_YIELD();
if(ev == PROCESS_EVENT_TIMER) {
leds_on(LEDS_PERIODIC);
printf("Counter = 0x%08x\n", counter);
err = s_measure(&temperature, checksum, TEMP);
if (err == 0)
{
//printf("Temperature (ADC value) = 0x%4x\n", temperature);
err = s_measure(&humidity, checksum, HUMI);
if (err == 0)
{
//printf("Humidity (ADC value) = 0x%4x\n", humidity);
//tc=sht11_TemperatureC(temperature);
//hc=sht11_Humidity(temperature,humidity);
tc=0;
hc=0;
printf("temp:%u.%u\nhumidity:%u.%u\n",(int)tc,((int)(tc*10))%10 , (int)hc,((int)(hc*10))%10);
}
else
printf("SHT11 error - could not read humidity!\n");
}
else
printf("SHT11 error - could not read temperature!\n");
etimer_set(&et, CLOCK_SECOND);
rtimer_set(&rt, RTIMER_NOW() + LEDS_OFF_HYSTERISIS, 1,
rt_callback, NULL);
} else if(ev == sensors_event) {
if(data == &button_select_sensor) {
if (swt==0)
{
packetbuf_copyfrom(&temperature, sizeof(temperature));
broadcast_send(&bc);
swt=1;
}
else
{
packetbuf_copyfrom(&humidity, sizeof(humidity));
broadcast_send(&bc);
swt=0;
}
} else if(data == &button_left_sensor || data == &button_right_sensor) {
leds_toggle(LEDS_BUTTON);
} else if(data == &button_down_sensor) {
cpu_cpsid();
leds_on(LEDS_REBOOT);
watchdog_reboot();
} else if(data == &button_up_sensor) {
sys_ctrl_reset();
}
} else if(ev == serial_line_event_message) {
leds_toggle(LEDS_SERIAL_IN);
}
counter++;
/* put measaruement sht11 here*/
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(leader_mote_2, ev, data)
{
static struct etimer et;
PROCESS_EXITHANDLER(broadcast_close(&broadcast);)
