void c_abc_open(struct pipe *p, struct stackmodule_i *module) {
int start_tm = START_TM;
channel_set_attributes(p->channel->channelno, p->channel->attrlist);
p->channel->hdrsize = chameleon_hdrsize(p->channel->attrlist);
PRINTF("~c_abc_open \n");
PRINTFE("\n %d \n", DURATION_TM(start_tm));
}
/*--------------------API Implementations--------------------------*/
void
mware_bootstrap(uint16_t channel, const struct mware_callbacks *m) {
subscription_init();
broadcast_open(&connection, channel, &connection_cb);
channel_set_attributes(channel, attributes);
callback = m;
}
/*---------------------------------------------------------------------------*/
void
abc_open(struct abc_conn *c, uint16_t channelno,
const struct abc_callbacks *callbacks)
{
channel_open(&c->channel, channelno);
c->u = callbacks;
channel_set_attributes(channelno, attributes);
}
/*---------------------------------------------------------------------------*/
void
multihop_open(struct multihop_conn *c, uint16_t channel,
const struct multihop_callbacks *callbacks)
{
unicast_open(&c->c, channel, &data_callbacks);
channel_set_attributes(channel, attributes);
c->cb = callbacks;
}
/*---------------------------------------------------------------------------*/
void
unicast_open(struct unicast_conn *c, uint16_t channel,
const struct unicast_callbacks *u)
{
broadcast_open(&c->c, channel, &uc);
c->u = u;
channel_set_attributes(channel, attributes);
}
/*---------------------------------------------------------------------------*/
void
broadcast_open(struct broadcast_conn *c, uint16_t channel,
const struct broadcast_callbacks *u)
{
abc_open(&c->c, channel, &broadcast);
c->u = u;
channel_set_attributes(channel, attributes);
}
/*---------------------------------------------------------------------------*/
void
tikirimc_open(struct tikirimc_conn *c, uint16_t channel,
const struct tikirimc_callbacks *u)
{
start_channel = channel;
tikirimc_system_open(&c->c, start_channel, &su);
c->u = u;
channel_set_attributes(start_channel, attributes);
}
/*---------------------------------------------------------------------------*/
void
trickle_open(struct trickle_conn *c, clock_time_t interval,
uint16_t channel, const struct trickle_callbacks *cb) {
broadcast_open(&c->c, channel, &bc);
c->cb = cb;
c->q = NULL;
c->interval = interval;
c->interval_scaling = 0;
channel_set_attributes(channel, attributes);
}
/*---------------------------------------------------------------------------*/
void p_broadcast_open(struct p_broadcast_conn *c, uint16_t channel)
{
if (c == NULL)
{
PRINTF("[pbroadcast.c] Error: Broadcast Connection is NULL\n");
return;
}
abc_open(&(c->abc), channel, &callbacks);
channel_set_attributes(channel, attributes);
}
/*---------------------------------------------------------------------------*/
void
runicast_open(struct runicast_conn *c, uint16_t channel,
const struct runicast_callbacks *u)
{
stunicast_open(&c->c, channel, &runicast);
channel_set_attributes(channel, attributes);
c->u = u;
c->is_tx = 0;
c->rxmit = 0;
c->sndnxt = 0;
}
/*---------------------------------------------------------------------------*/
void
collect_open(struct collect_conn *tc, uint16_t channels,
const struct collect_callbacks *cb)
{
#if !COLLECT_ANNOUNCEMENTS
neighbor_discovery_open(&tc->neighbor_discovery_conn, channels,
CLOCK_SECOND * 2,
CLOCK_SECOND * 10,
CLOCK_SECOND * 60,
&neighbor_discovery_callbacks);
#endif /* !COLLECT_ANNOUNCEMENTS */
runicast_open(&tc->runicast_conn, channels + 1, &runicast_callbacks);
channel_set_attributes(channels + 1, attributes);
tc->rtmetric = RTMETRIC_MAX;
tc->cb = cb;
#if COLLECT_ANNOUNCEMENTS
announcement_register(&tc->announcement, channels, tc->rtmetric,
received_announcement);
announcement_listen(2);
#else
neighbor_discovery_start(&tc->neighbor_discovery_conn, tc->rtmetric);
#endif /* COLLECT_ANNOUNCEMENTS */
neighbor_init();
}
/*---------------------------------------------------------------------------*/
void c_multihop_open(struct pipe *p, struct stackmodule_i *module) {
channel_set_attributes(p->channel_no, p->attrlist);
c_rnd_init();
}
void
c_unicast_open(struct pipe *p, struct stackmodule_i *module)
{
channel_set_attributes(p->channel_no, p->attrlist);
PRINTF("c_unicast_open\n");
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(example_abc_process, ev, data)
{
static struct etimer et;
static struct channel *c;
PROCESS_BEGIN();
char buffer[32];
//button_sensor.activate();
SENSORS_ACTIVATE(button_sensor);
printf("ready to rock\n");
static int i, j, k;
//cc2420_init();
//cc2420_set_pan_addr(panId, 0 /*XXX*/, ds2411_id);
//cc2420_set_channel(26);
//cc2420_set_txpower(31);
cc2420_on();
driver = nullmac_init(&cc2420_driver);
driver->on();
channel_open(c, 128);channel_set_attributes(128, attributes);
packetbuf_clear();
driver->set_receive_function(recv);
packetbuf_clear();
//set_receive_function(driver);
while(1) {
//PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor);
for (j = 0; j < 10000; j++)
k = j/23;
sprintf(buffer, "ping %d, %d\0",i, k);
printf("Attempting to send %s\n", buffer);
// send the message straight to the radio
//cc2420_send ( buffer, (int)strlen(buffer) );
packetbuf_clear();
packetbuf_copyfrom(&buffer, (int)strlen(buffer));
driver->send();
printf("Message sent\n");
leds_toggle(LEDS_RED);
i = i + 1;
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(example_abc_process, ev, data)
{
static struct channel *c;
static struct etimer et;
PROCESS_BEGIN();
char buffer[32];
//button_sensor.activate();
SENSORS_ACTIVATE(button_sensor);
printf("ready to rock\n");
//ds2411_init();
static int i;
//cc2420_init();
//cc2420_set_pan_addr(panId, 0 /*XXX*/, ds2411_id);
//cc2420_set_channel(26);
//abc_open(&abc, 128, &abc_call);
// set_rime_addr();
// cc2420_init();
//cc2420_set_pan_addr(panId, 0 , ds2411_id);
// cc2420_set_channel(RF_CHANNEL);
//cc2420_set_txpower(31);
//nullmac_init(&cc2420_driver);
//rime_init(&nullmac_driver);
//cc2420_set_txpower(31);
//cc2420_on();
channel_init();
packetbuf_clear();
driver = nullmac_init(&cc2420_driver);
//rime_init(driver);
//driver = sicslowmac_init(&cc2420_driver);
cc2420_set_channel(26);
channel_open(c, 34);
/*packetbuf_clear();*/
driver->set_receive_function(recv);
//packetbuf_clear();
channel_set_attributes(34, attributes);
//set_receive_function(driver);
driver->on();
leds_toggle(LEDS_RED);
packetbuf_clear();
etimer_set(&et, CLOCK_SECOND * 2 + random_rand() % (CLOCK_SECOND * 2));
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
leds_toggle(LEDS_RED);
PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor);
while(1)
{
if (i % 20 == 19)
{
PROCESS_WAIT_EVENT_UNTIL(ev == sensors_event && data == &button_sensor);
}
else
{
printf("wait!");
etimer_set(&et, CLOCK_SECOND * 0.5 + random_rand() % (CLOCK_SECOND) * 0.25);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
}
sprintf(buffer, "ping %d\0",i);
printf("Attempting to send %s\n", buffer);
// send the message straight to the radio
//cc2420_send ( buffer, (int)strlen(buffer) );
packetbuf_clear();
packetbuf_copyfrom(&buffer, (int)strlen(buffer));
//driver->on();
//cc2420_driver.send(&buffer, (int)strlen(buffer));
//cc2420_send ( &buffer, (int)strlen(buffer) );
driver->send();
//rime_output();
//abc_send(&abc);
//chameleon_output(c);
//driver->off(1);
printf("Message sent\n");
leds_toggle(LEDS_YELLOW);
i = i + 1;
}
PROCESS_END();
}
