char TOS_COMMAND(YELLOW_LED_TOGGLE)(){
if(VAR(leds_on) & 0x4){
return TOS_CALL_COMMAND(YELLOW_LED_OFF)();
}else{
return TOS_CALL_COMMAND(YELLOW_LED_ON)();
}
}
char TOS_EVENT(WAVE_PHOTO_EVENT)(int newlight){
int diff = newlight - VAR(light);
VAR(light) = newlight;
diff = (diff > 0) ? diff : -diff;
if (diff > 0x50) TOS_CALL_COMMAND(WAVE_LEDr_off)(); else TOS_CALL_COMMAND(WAVE_LEDr_on)();
return 1;
}
char TOS_COMMAND(GREEN_LED_TOGGLE)(){
if(VAR(leds_on) & 0x2){
return TOS_CALL_COMMAND(GREEN_LED_OFF)();
}else{
return TOS_CALL_COMMAND(GREEN_LED_ON)();
}
}
//This handler responds to routing updates.
TOS_MsgPtr TOS_MSG_EVENT(CONNECT_UPDATE)(TOS_MsgPtr msg){
TOS_MsgPtr tmp;
char* data = msg->data;
//clear LED2 when update is received.
TOS_CALL_COMMAND(CONNECT_LED2_OFF)();
update_connections(data[(int)data[0]], data[28]);
//if route hasn't already been set this period...
if(VAR(set) == 0){
//record route
VAR(route) = data[(int)data[0]];
VAR(set) = 8;
data[0] ++;
//create a update packet to be sent out.
data[(int)data[0]] = TOS_LOCAL_ADDRESS;
//send the update packet.
if(VAR(msg_send_pending) == 0){
VAR(msg_send_pending) = TOS_CALL_COMMAND(CONNECT_SUB_SEND_MSG)(TOS_BCAST_ADDR, AM_MSG(CONNECT_UPDATE),msg);
}else{
return msg;
}
printf("route set to %x\n", VAR(route));
tmp = VAR(msg);
VAR(msg) = msg;
return tmp;
}else{
printf("route already set to %x\n", VAR(route));
return msg;
}
}
/* WAVE_INIT: flash all the LEDs on */
char TOS_COMMAND(WAVE_INIT)(){
VAR(state) = 0;
TOS_CALL_COMMAND(WAVE_LEDy_off)();
TOS_CALL_COMMAND(WAVE_LEDr_off)();
TOS_CALL_COMMAND(WAVE_LEDg_off)();
TOS_COMMAND(WAVE_SUB_DATA_INIT)(); /* initialize lower components */
TOS_COMMAND(WAVE_SUB_INIT)(255, 0x03); /* initialize lower components */
return 1;
}
char TOS_COMMAND(AM_INIT)(){
TOS_CALL_COMMAND(AM_SUB_INIT)();
TOS_CALL_COMMAND(AM_UART_SUB_INIT)();
VAR(state) = 0;
#ifdef FULLPC
printf("AM Module initialized\n");
#endif
return 1;
}
/* Clock Event Handler:
signaled at end of each clock interval.
*/
void TOS_EVENT(MAGS_CLOCK_EVENT)(){
TOS_CALL_COMMAND(MAGS_GET_DATA)(DATA_PORT); /* start data reading */
//count down the LED_on variable. when it hits 0, turn off the led.
if(VAR(led_on == 1)) TOS_CALL_COMMAND(MAGS_LEDg_off)();
if(VAR(led_on) != 0) VAR(led_on) --;
//count done the pot_wait variable
if(VAR(pot_wait) != 0) VAR(pot_wait) --;
}
/*
* ------- commands accepted ---------
*/
char TOS_COMMAND(UART_2_LEDS_INIT) () {
/*
* initialize output component
*/
if (TOS_CALL_COMMAND(UART_2_LEDS_LEDS_INIT) () == 0)
return 0;
return TOS_CALL_COMMAND(UART_2_LEDS_UART_INIT) ();
}
/*
* GENERIC_BASE_INIT: initialize lower components. initialize component
* state, including constant portion of msgs.
*/
char TOS_COMMAND(GENERIC_BASE_INIT) () {
TOS_CALL_COMMAND(GENERIC_BASE_SUB_INIT) (); /* initialize lower
* components */
TOS_CALL_COMMAND(GENERIC_BASE_SUB_UART_INIT) (); /* initialize
* lower
* components */
VAR(msg) = &VAR(data);
VAR(send_pending) = 0;
printf("GENERIC_BASE initialized\n");
return 1;
}
TOS_MsgPtr TOS_MSG_EVENT(DATA_MSG) (TOS_MsgPtr msg) {
char *data = msg->data;
TOS_MsgPtr tmp = msg;
char source;
// this handler forwards packets traveling to the base.
TOS_CALL_COMMAND(CONNECT_LED2_OFF) ();
// if this is the first hop on the route, then use the origin of the
// packet<
// as the name of the person who sent the packet to you instead of the
//
//
// last hop ID (which is null)
source = data[2];
if (source == 0) {
source = data[0];
}
update_connections(source, data[28]);
// if a route is known, forward the packet towards the base.
if (VAR(route) != 0 && data[1] == TOS_LOCAL_ADDRESS) {
#ifdef BASE_STATION
if (VAR(msg_send_pending) == 0) {
VAR(msg_send_pending) =
TOS_CALL_COMMAND(CONNECT_SUB_SEND_MSG) (TOS_UART_ADDR,
AM_MSG(DATA_MSG),
msg);
tmp = VAR(msg);
VAR(msg) = msg;
}
#else
// update the packet.
data[5] = data[4];
data[4] = data[3];
data[3] = data[2];
data[2] = data[1];
data[1] = VAR(route);
// send the packet.
if (VAR(msg_send_pending) == 0) {
VAR(msg_send_pending) =
TOS_CALL_COMMAND(CONNECT_SUB_SEND_MSG) (TOS_BCAST_ADDR,
AM_MSG
(CONNECT_UPDATE),
msg);
tmp = VAR(msg);
VAR(msg) = msg;
}
#endif
printf("routing to home %x\n", VAR(route));
}
return tmp;
}
/* MAGS_INIT:
flash the LEDs
initialize lower components.
initialize component state, including constant portion of msgs.
*/
char TOS_COMMAND(MAGS_INIT)(){
struct adc_packet* pack = (struct adc_packet*)(VAR(msg).data);
SET_MAG_POT_SELECT();
TOS_CALL_COMMAND(MAGS_LEDy_off)();
TOS_CALL_COMMAND(MAGS_LEDr_off)();
TOS_CALL_COMMAND(MAGS_LEDg_off)(); /* light LEDs */
TOS_CALL_COMMAND(MAGS_SUB_INIT)(); /* initialize lower components */
TOS_CALL_COMMAND(MAGS_CLOCK_INIT)(40, 1); /* set clock interval */
VAR(state) = 0;
VAR(send_pending) = 0;
pack->count = 0;
printf("MAGS initialized\n");
return 1;
}
char TOS_COMMAND(CONNECT_INIT) () {
// initialize sub components
TOS_CALL_COMMAND(CONNECT_SUB_INIT) ();
VAR(msg) = &VAR(route_buf);
VAR(data_send_pending) = 0;
VAR(msg_send_pending) = 0;
#ifdef BASE_STATION
// set beacon rate for route updates to be sent
TOS_COMMAND(CONNECT_SUB_CLOCK_INIT) (255, 0x06);
printf("base route set to TOS_UART_ADDR\n");
// route to base station is over UART.
VAR(route) = TOS_UART_ADDR;
VAR(set) = 1;
VAR(place) = 0;
VAR(data_buf).data[0] = 1;
VAR(data_buf).data[1] = TOS_LOCAL_ADDRESS;
#else
// set rate for sampling.
TOS_COMMAND(CONNECT_SUB_CLOCK_INIT) (255, 0x03);
VAR(set) = 0;
VAR(route) = 0;
VAR(count) = 0;
#endif
return 1;
}
char TOS_COMMAND(UART_PACKET_TX_PACKET)(TOS_MsgPtr msg){
#ifndef FULLPC
if(VAR(state) == 0){
VAR(send_ptr) = (char*)msg;
VAR(count) = 1;
VAR(state) = 1;
if(TOS_CALL_COMMAND(UART_PACKET_SUB_TX_BYTES)(VAR(send_ptr)[0])){
return 1;
}else{
VAR(state) = 0;
VAR(count) = 0;
return 0;
}
}else{
return 0;
}
#else
{
int i;
printf("uart_send_packet\n");
VAR(send_ptr) = (char*)msg;
if(uart_send != 0){
printf("sending packet: %d \n", write(uart_send, VAR(send_ptr), sizeof(TOS_Msg)));
}
for(i = 0; i < sizeof(TOS_Msg); i ++)printf("%x,", VAR(send_ptr)[i]);
printf("\n");
}
return 0;
#endif
}
char TOS_EVENT(UART_TO_LEDS_RX_BYTE_READY) (char data,
char error) {
int tmp = data;
TOS_CALL_COMMAND(UART_TO_LEDS_LED_OUTPUT) (tmp);
printf("\n");
return 1;
}
/*
* for some reason, most of the power commands return void. Does this
* violate the TOS command-handshake protocol?
*/
char TOS_COMMAND(SLIP_POWER) (char mode) {
/*
* no power-mode code for now, call UART power mode
*/
return (TOS_CALL_COMMAND(SLIP_SUB_POWER) (mode));
}
char TOS_COMMAND(AGRO_INIT)(){
//initialize sub components
TOS_CALL_COMMAND(AGRO_SUB_INIT)();
VAR(msg) = &VAR(data_buf);
{
VAR(my_parent)[0] = TOS_LOCAL_ADDRESS - 0x10;
VAR(my_parent)[1] = TOS_LOCAL_ADDRESS - 0x1;
VAR(my_parent)[2] = TOS_LOCAL_ADDRESS - 0x11;
VAR(my_parent)[3] = TOS_LOCAL_ADDRESS - 0x20;
VAR(my_parent)[4] = TOS_LOCAL_ADDRESS - 0x2;
if(TOS_LOCAL_ADDRESS == 0x200) VAR(my_parent)[0] = TOS_UART_ADDR;
VAR(parent_ptr) = 0;
}
VAR(dupe_ptr) = 0;
VAR(data_send_pending) = 0;
VAR(msg_send_pending) = 0;
VAR(rel_send_pending) = 0;
VAR(rel_send_req) = 0;
VAR(rel_ptr) = &VAR(rel_buf);
//set rate for sampling.
VAR(set) = 0;
VAR(route) = 0;
VAR(count) = 0;
VAR(max_strength) = 0;
return 1;
}
/*
* PACKET_TX_BYTE_READY: spool bytes to packet component in event-driven
* manner. On each byte event, return the next byte till done.
*/
char TOS_EVENT(PACKET_TX_BYTE_READY) (char success) {
if (success == 0) {
printf("TX_packet failed, TX_byte_failed");
TOS_SIGNAL_EVENT(PACKET_TX_PACKET_DONE) ((TOS_MsgPtr) VAR(msg));
VAR(state) = 0;
VAR(count) = 0;
}
if (VAR(state) == 1) {
if (VAR(count) < sizeof(TOS_Msg)) {
#ifdef FULLPC_DEBUG
printf("PACKET: byte sent: %x, STATE: %d, COUNT: %d\n",
VAR(data)[(int) VAR(count)] & 0xff, VAR(state),
VAR(count));
#endif
TOS_CALL_COMMAND(PACKET_SUB_TX_BYTES) (VAR(data)
[(int) VAR(count)]);
VAR(count)++;
} else if (VAR(count) == sizeof(TOS_Msg)) {
VAR(count)++;
return 0;
} else {
VAR(state) = 0;
VAR(count) = 0;
TOS_SIGNAL_EVENT(PACKET_TX_PACKET_DONE) ((TOS_MsgPtr)
VAR(data));
return 0;
}
}
return 1;
}
char TOS_COMMAND(PACKET_INIT) () {
TOS_CALL_COMMAND(PACKET_SUB_INIT) ();
VAR(msg) = (char *) &VAR(recbuf);
VAR(state) = 0;
#ifdef FULLPC
printf("Packet handler initialized.\n");
#endif
return 1;
}
void TOS_EVENT(CONNECT_SUB_CLOCK)(){
//clear LED3 when the clock ticks.
TOS_CALL_COMMAND(CONNECT_LED3_OFF)();
printf("route clock\n");
#ifdef BASE_STATION
//if is the base, then it should send out the route update.
if(VAR(data_send_pending) == 0){
VAR(data_send_pending) = TOS_CALL_COMMAND(CONNECT_SUB_SEND_MSG)(TOS_BCAST_ADDR, AM_MSG(CONNECT_UPDATE),&VAR(data_buf));
}
#else
//decrement the set var to know when a period is over.
if(VAR(set) != 0) VAR(set) --;
//read the value from the sensor.
TOS_COMMAND(CONNECT_SUB_READ)();
#endif //BASE_STATION
TOS_CALL_COMMAND(CONNECT_LED1_TOGGLE)();
}
int main() {
/* reset the ports, and set the directions */
SET_PIN_DIRECTIONS();
TOS_CALL_COMMAND(MAIN_SUB_POT_INIT)(0);
TOS_sched_init();
TOS_CALL_COMMAND(MAIN_SUB_INIT)();
TOS_CALL_COMMAND(MAIN_SUB_START)();
dbg(DBG_BOOT,("mote initialized.\n"));
while(1){
while(!TOS_schedule_task()) { };
sbi(MCUCR, SE);
asm volatile ("sleep" ::);
asm volatile ("nop" ::);
asm volatile ("nop" ::);
}
}
char TOS_EVENT(MAGS_DATA_EVENT)(int data){
struct adc_packet* pack = (struct adc_packet*)(VAR(msg).data);
printf("data_event\n");
VAR(reading) = data;
TOS_POST_TASK(FILTER_DATA);
if(VAR(send_pending) == 0){
pack->count ++;
pack->data[(int)VAR(state)] = data;
VAR(state) ++;
}
if(VAR(pot_wait) == 0){
TOS_CALL_COMMAND(MAGS_LEDy_off)();
TOS_CALL_COMMAND(MAGS_LEDr_off)();
if(data > 0x200){
decrease_r();
//this is a counter so that we can only reset the POT once
//every 255 samples.
TOS_CALL_COMMAND(MAGS_LEDy_on)();
VAR(pot_wait) = 255;
}
else if(data < 0x100){
increase_r();
//this is a counter so that we can only reset the POT once
//every 255 samples.
VAR(pot_wait) = 255;
TOS_CALL_COMMAND(MAGS_LEDr_on)();
}
}
if(VAR(state) == sizeof(pack->data)/sizeof(int)){
pack->data[(int)VAR(state)] = VAR(diff);
VAR(state) = 0;
if (TOS_CALL_COMMAND(MAGS_SUB_SEND_MSG)(TOS_UART_ADDR,AM_MSG(mags_msg),&VAR(msg))) {
VAR(send_pending) = 1;
return 1;
}else {
return 0;
}
}
return 1;
}
char TOS_EVENT(AGRO_SUB_DATA_READY)(short data){
if(data > VAR(my_strength)) VAR(my_strength) = data;
VAR(count) ++;
if(VAR(count) == 8){
VAR(count) = 0;
if(VAR(id_gen) == 0) VAR(id_gen) = data;
if(VAR(my_strength) > VAR(max_strength) && VAR(my_strength) > MAG_THRESHOLD){
uint8_t i;
TOS_CALL_COMMAND(AGRO_LED1_ON)();
agroDataPacket* pack = (agroDataPacket*)VAR(rel_ptr)->data;
pack->pack_ID = VAR(id_gen);
pack->from = TOS_LOCAL_ADDRESS;
pack->readings[0].nodeID = TOS_LOCAL_ADDRESS;
pack->readings[0].value = VAR(my_strength);
for(i = 1; i < 4; i ++){
pack->readings[i].value = VAR(dataBlock)[i-1].value;
pack->readings[i].nodeID = VAR(dataBlock)[i-1].nodeID;
VAR(dataBlock)[i-1].value = 0;
VAR(dataBlock)[i-1].nodeID = 0xff;
}
bar_foo();
}else{
TOS_CALL_COMMAND(AGRO_LED1_OFF)();
}
VAR(my_strength) = 0;
VAR(max_strength) = 0;
}else {
if(data > MAG_THRESHOLD && VAR(msg_send_pending) == 0){
CLR_YELLOW_LED_PIN();
agroDataPacket* pack = (agroDataPacket*)VAR(msg)->data;
pack->readings[0].nodeID = TOS_LOCAL_ADDRESS;
pack->readings[0].value = data;
//TIME to send out an data messgae.
VAR(msg)->length = 6;
VAR(msg_send_pending) = TOS_CALL_COMMAND(AGRO_SUB_SEND_MSG)(TOS_BCAST_ADDR, AM_MSG(AGRO_DATA_MSG), VAR(msg));
}else{
SET_YELLOW_LED_PIN();
TOS_CALL_COMMAND(AGRO_LED1_OFF)();
}
}
return 1;
}
char TOS_COMMAND(UART_PACKET_INIT)(){
VAR(state) = 0;
VAR(rec_ptr) = (char*)&VAR(buffer);
#ifdef FULLPC
udp_init_socket();
printf("UART Packet handler initialized.\n");
#endif
TOS_CALL_COMMAND(UART_PACKET_SUB_INIT)();
return 1;
}
/* INTERP_INIT:
flash the LEDs
initialize lower components.
initialize component state, including constant portion of msgs.
*/
char TOS_COMMAND(INTERP_INIT)(){
TOS_CALL_COMMAND(INTERP_SUB_INIT)(); /* initialize lower components */
VAR(state) = 0;
VAR(light) = 0;
VAR(codesize) = 0;
VAR(sp) = 0;
VAR(ip) = 0;
printf("INTERP initialized\n");
return 1;
}
/* Command to transmit a packet */
char TOS_COMMAND(PACKET_TX_PACKET)(TOS_MsgPtr msg){
if(VAR(send_state) == IDLE_STATE){
VAR(send_ptr) = msg;
VAR(send_state) = SEND_WAITING;
VAR(tx_count) = 1;
TOS_CALL_COMMAND(PACKET_SUB_MAC_DELAY)();
return 1;
}else{
return 0;
}
}
/* The handles the latest decoded byte propagated by the Byte Level component*/
char TOS_EVENT(PACKET_SUB_START_SYM_DETECT)(){
short tmp;
VAR(ack_count) = 0;
VAR(rec_count) = 0;
VAR(state) = RX_STATE;
//outp(VAR(state), UDR);
tmp = TOS_CALL_COMMAND(PACKET_SUB_GET_TIMING)();
TOS_CALL_COMMAND(PACKET_SUB_FIFO_READ)(tmp);
VAR(msg_length) = MSG_DATA_SIZE - 2;
VAR(calc_crc) = 0;
VAR(rec_ptr)->time = tmp;
//set the sound time to zero now so we can tell if no tone was detected
VAR(rec_ptr)->tone_time = 0;
//outp(tmp >> 8, UDR);
//outp(0xff, UDR);
sbi(EIMSK, INT3);
//outp(tmp, UDR);
VAR(rec_ptr)->strength = 0;
return 1;
}
char TOS_EVENT(CONNECT_SUB_DATA_READY)(int data){
//when the data comes back from the sensor, see if the counter
// has expired or if the value is significantly different
// from the previous value.
if(VAR(route) != 0 &&
((VAR(prev) - data) > 100 ||
(data - VAR(prev)) > 100 ||
VAR(count) > 10)){
char* buf = VAR(data_buf).data;
//if a new data packet needs to be sent, go for it.
if(VAR(data_send_pending) == 0){
buf[6] = data >> 8;
buf[7] = data & 0xff;
buf[0] = TOS_LOCAL_ADDRESS;
buf[1] = VAR(route);
VAR(data_send_pending) = TOS_CALL_COMMAND(CONNECT_SUB_SEND_MSG)(TOS_BCAST_ADDR, AM_MSG(DATA_MSG),&VAR(data_buf));
VAR(count) = 0;
//blink the LED
TOS_CALL_COMMAND(CONNECT_LED3_ON)();
}
char TOS_EVENT(PACKET_SUB_CHANNEL_IDLE)(){
if(VAR(send_state) == SEND_WAITING){
char first = ((char*)VAR(send_ptr))[0];
VAR(buf_end) = VAR(buf_head) = 0;
VAR(enc_count) = 0;
TOS_CALL_COMMAND(PACKET_SUB_RADIO_ENCODE)(first);
VAR(rx_count) = 0;
VAR(msg_length) = (unsigned char)(VAR(send_ptr)->length) + MSG_DATA_SIZE - DATA_LENGTH - 2;
VAR(send_state) = IDLE_STATE;
VAR(state) = TRANSMITTING_START;
TOS_CALL_COMMAND(PACKET_SUB_FIFO_SEND)(start[0]);
VAR(send_ptr)->time = TOS_CALL_COMMAND(RF_COMM_SUB_GET_CURRENT_TIME)();
VAR(calc_crc) = add_crc_byte(first, 0x00);
//turn sounder on
if(VAR(sounder_length)>0){
SET_PW2_PIN();
VAR(sounder_length)=0;
}
}
return 1;
}
char TOS_COMMAND(SEND_DV_FP_INIT) () {
CLR_RED_LED_PIN();
CLR_GREEN_LED_PIN();
CLR_YELLOW_LED_PIN();
TOS_CALL_COMMAND(SEND_DV_FP_SUB_INIT) ();
printf("SEND_DV_FP initialized\n");
SET_RED_LED_PIN();
SET_GREEN_LED_PIN();
SET_YELLOW_LED_PIN();
return 1;
}
void bar_foo(){
if(VAR(rel_send_pending) == 0){
VAR(id_gen) ++;
VAR(rel_cnt) = 0;
VAR(rel_ptr)->length = 16;
((agroDataPacket*)(VAR(rel_ptr)->data))->from = VAR(my_parent)[VAR(parent_ptr)];
VAR(rel_send_pending) = TOS_CALL_COMMAND(AGRO_SUB_SEND_MSG)(VAR(my_parent)[VAR(parent_ptr)], AM_MSG(AGRO_REL_MSG), VAR(rel_ptr));
if(VAR(rel_send_pending) == 0) VAR(id_gen) --;
}
}
