/*---------------------------------------------------------------------------*/
void
route_discovery_close(struct route_discovery_conn *c)
{
unicast_close(&c->rrepconn);
netflood_close(&c->rreqconn);
ctimer_stop(&c->t);
}
PROCESS_THREAD(shell_uc_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(&uc_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 unicast_entry *e = list_head(unicast_list);
while(e != NULL){
if(e->channel == channel){
struct unicast_entry *to_remove = e;
e = e->next;
unicast_close(&to_remove->c);
list_remove(unicast_list, to_remove);
memb_free(&unicast_mem, to_remove);
shell_output_str(&uc_close_command, "closed unicast connection on channel: ", buf);
PROCESS_EXIT();
}
}
shell_output_str(&uc_close_command, "uc_close error: channel not open","");
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(example_unicast_process, ev, data)
{
linkaddr_t node_addr;
node_addr.u8[0] = 140;
node_addr.u8[1] = 165;
linkaddr_set_node_addr(&node_addr);
PROCESS_EXITHANDLER(unicast_close(&uc);)
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();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(rime_unicast_sender, ev, data)
{
PROCESS_EXITHANDLER(unicast_close(&uc));
PROCESS_BEGIN();
unicast_open(&uc, 146, &unicast_callbacks); // channel = 145
while(1){
PROCESS_YIELD();
}
PROCESS_END();
}
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(example_unicast_process, ev, data)
{
static int i = 0;
static struct etimer et;
PROCESS_EXITHANDLER(unicast_close(&uc));
PROCESS_BEGIN();
unicast_open(&uc, 128, &unicast_callbacks);
printf("rimeaddr_node_addr = [%u, %u]\n", rimeaddr_node_addr.u8[0],
rimeaddr_node_addr.u8[1]);
/* Put receiver node in listening mode */
if (rimeaddr_node_addr.u8[0] == receiver_node_rime_addr[0]
&& rimeaddr_node_addr.u8[1] == receiver_node_rime_addr[1]) {
/*
* Exit process
* Received messages handled by 'recv_uc(...)'
*/
printf("Receiver node listening\n");
} else {
/* Sending messages */
printf("Write a character on serial link to send message\n");
PROCESS_WAIT_EVENT_UNTIL(ev == serial_line_event_message);
etimer_set(&et, 1 * CLOCK_SECOND);
while (1) {
char msg[64];
int len;
rimeaddr_t addr;
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
len = 1 + sprintf(msg, "hello world #%u", i);
i++;
packetbuf_copyfrom(msg, len);
addr.u8[0] = receiver_node_rime_addr[0];
addr.u8[1] = receiver_node_rime_addr[1];
unicast_send(&uc, &addr);
printf("unicast message sent [%i bytes]\n", len);
etimer_reset(&et);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(hello_world_process, ev, data)
{
PROCESS_EXITHANDLER(unicast_close(&uc))
PROCESS_BEGIN();
printf("Hello, world\n");
//linkaddr_set_node_addr(&server);
print_rime_address();
unicast_open(&uc, 0x17, &uc_rx);
for(;;)
{
PROCESS_YIELD();
}
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();
}
/*---------------------------------------------------------------------------*/
void
multihop_close(struct multihop_conn *c)
{
unicast_close(&c->c);
}
PROCESS_THREAD(hello_process, ev, data)
{
PROCESS_POLLHANDLER();
PROCESS_EXITHANDLER(broadcast_close(&bc); unicast_close(&uc););
/*---------------------------------------------------------------------------*/
void
stunicast_close(struct stunicast_conn *c)
{
unicast_close(&c->c);
stunicast_cancel(c);
}
void close_unicast()
{
unicast_close(&uc);
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(demo_source, ev, data) {
static struct etimer et;
PROCESS_EXITHANDLER(unicast_close(&unicast);)
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(demo_sink, ev, data) {
static struct etimer et;
rimeaddr_t addr;
PROCESS_EXITHANDLER(unicast_close(&unicast);)
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(unicast_sender_process, ev, data)
{
static uint32_t cnt;
PROCESS_EXITHANDLER(unicast_close(&uc);)
