/* * 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_EVENT(UART_PACKET_RX_BYTE_READY)(char data, char error){ #ifdef FULLPC_DEBUG printf("UART PACKET: byte arrived: %x, STATE: %d, COUNT: %d\n", data, VAR(state), VAR(count)); #endif if(error){ VAR(state) = 0; return 0; } if(VAR(state) == 0){ VAR(state) = 5; VAR(count) = 1; VAR(rec_ptr)[0] = data; }else if(VAR(state) == 5){ VAR(rec_ptr)[(int)VAR(count)] = data; VAR(count)++; if(VAR(count) == sizeof(TOS_Msg)){ TOS_MsgPtr tmp; VAR(state) = 0; tmp = TOS_SIGNAL_EVENT(UART_PACKET_RX_PACKET_DONE)((TOS_MsgPtr)VAR(rec_ptr)); if(tmp != 0) VAR(rec_ptr) = (char*)tmp; return 0; } } return 1; }
/* Send completion event Determine if this event was ours. If so, process it by freeing output buffer and signalling event. */ char TOS_EVENT(INT_TO_RFM_SUB_MSG_SEND_DONE)(TOS_MsgPtr sentBuffer){ if (VAR(pending) && sentBuffer == &VAR(data)) { VAR(pending) = 0; TOS_SIGNAL_EVENT(INT_TO_RFM_COMPLETE)(1); return 1; } return 0; }
TOS_MsgPtr TOS_MSG_EVENT(INT_READING) (TOS_MsgPtr msg) { coordinates_msg *message = (coordinates_msg *) msg->data; CLR_RED_LED_PIN(); TOS_SIGNAL_EVENT(SEND_DV_FP_INPUT) (&message->x, &message->y, message->hops); SET_RED_LED_PIN(); return msg; }
/* * fired when a query message comes */ TOS_MsgPtr TOS_MSG_EVENT(GOT_QUERY) (TOS_MsgPtr msg) { void *q_message = (void *) msg->data; CLR_RED_LED_PIN(); TOS_SIGNAL_EVENT(SEND_DV_FP_QUERY_INPUT) (q_message); SET_RED_LED_PIN(); return msg; }
char TOS_EVENT(UART_PACKET_TX_BYTE_READY)(char success){ if(success == 0){ printf("TX_packet failed, TX_byte_failed"); TOS_SIGNAL_EVENT(UART_PACKET_TX_PACKET_DONE)((TOS_MsgPtr)VAR(send_ptr)); VAR(state) = 0; VAR(count) = 0; } if(VAR(state) == 1){ if(VAR(count) < sizeof(TOS_Msg)){ TOS_CALL_COMMAND(UART_PACKET_SUB_TX_BYTES)(VAR(send_ptr)[(int)VAR(count)]); VAR(count) ++; }else{ VAR(state) = 0; VAR(count) = 0; TOS_SIGNAL_EVENT(UART_PACKET_TX_PACKET_DONE)((TOS_MsgPtr)VAR(send_ptr)); } } return 1; }
/* * fired when the correction comes in */ TOS_MsgPtr TOS_MSG_EVENT(CORRECTION_READING) (TOS_MsgPtr msg) { correction_msg *message = (correction_msg *) msg->data; CLR_RED_LED_PIN(); TOS_SIGNAL_EVENT(SEND_DV_FP_CORRECTION_INPUT) (&message->fpx, &message->fpy, &message->fpfactor); SET_RED_LED_PIN(); return msg; }
void uart_packet_evt(){ int avilable; ioctl(uart_send, FIONREAD, &avilable); if(avilable > sizeof(TOS_Msg)){ read(uart_send, VAR(rec_ptr), sizeof(TOS_Msg)); TOS_SIGNAL_EVENT(UART_PACKET_RX_PACKET_DONE)((TOS_MsgPtr)VAR(rec_ptr)); printf("got packet\n"); } }
/* * finished sending a packet */ char TOS_EVENT(SEND_DV_FP_SUB_MSG_SEND_DONE) (TOS_MsgPtr sentBuffer) { if (VAR(pending) && sentBuffer == &VAR(data)) { VAR(pending) = 0; TOS_SIGNAL_EVENT(SEND_DV_FP_COMPLETE) (1); SET_GREEN_LED_PIN(); return 1; } return 0; }
char TOS_EVENT(UART_PACKET_TX_BYTE_READY)(char success){ dbg(DBG_UART, ("UART Transmitting!")); if(success == 0){ dbg(DBG_ERROR, ("UART TX_packet failed, TX_byte_failed")); TOS_SIGNAL_EVENT(UART_PACKET_TX_PACKET_DONE)(VAR(send_ptr)); VAR(state) = 0; VAR(tx_count) = 0; } if(VAR(state) == 1){ if(VAR(tx_count) < VAR(msg_length)){ TOS_CALL_COMMAND(UART_PACKET_SUB_TX_BYTES)(VAR(send_ptr)[(int)VAR(tx_count)]); VAR(tx_count) ++; }else{ VAR(state) = 0; VAR(tx_count) = 0; TOS_SIGNAL_EVENT(UART_PACKET_TX_PACKET_DONE)(VAR(send_ptr)); } } return 1; }
void uartRecobj_interrupt(char bitIn) { // printf("state %d, bitIn %d, first: %x\n", VAR(state), bitIn, // VAR(first)); int avail, tmp; char data; if (uart_send != 0) { tmp = ioctl(uart_send, FIONREAD, &avail); if (avail > 0) { read(uart_send, &data, 1); printf("UART_in_data: %x\n", data); VAR(state) = 0; TOS_SIGNAL_EVENT(UART_RX_BYTE_READY) (data, 0); } } }
/* * send a packet up to higher-level TOS component and reset the state to * idle */ char rx_and_reset() { TOS_MsgPtr next_rx_ptr; /* * set the state to not receiving */ VAR(state) &= ~RX_MASK; next_rx_ptr = (TOS_MsgPtr) TOS_SIGNAL_EVENT(SLIP_RX_PACKET_DONE) (VAR(rx_ptr), VAR (decodePos)); if ((next_rx_ptr != (TOS_MsgPtr) NULL)) { int i; /* * don't zero out this buffer unless we actually swapped the * buffers */ if (VAR(rx_ptr) != next_rx_ptr) { VAR(rx_ptr) = next_rx_ptr; /* * zero out the data in the packet */ for (i = 0; i < DATA_LENGTH; i++) { next_rx_ptr->data[i] = 0; } } return EVENT_SUCCESS; } else { /* No rx_pointer? Oh dear, this should not * happen! */ return EVENT_FAILED; } } /* end rx_and_reset */
char TOS_EVENT(AM_TX_PACKET_DONE)(TOS_MsgPtr msg){ VAR(state) = 0; TOS_SIGNAL_EVENT(AM_MSG_SEND_DONE)(msg); return 1; }
char TOS_EVENT(SLIP_TX_BYTE_READY) (char success) { unsigned char c; /* * we had better be in some transmitting state here */ if ((VAR(state) & TX_MASK)) { /* * final ESC sent. and done transmitting the whole packet */ if (VAR(encodePos) > VAR(tx_len)) { int tmp; /* * done TXing the packet. Reset state to not Tx */ VAR(state) &= (~TX_MASK); /* * give up the TX pointer here too */ VAR(tx_len) = 0; /* * signal completion of the event */ tmp = TOS_SIGNAL_EVENT(SLIP_TX_PACKET_DONE) (VAR(tx_ptr)); VAR(tx_ptr) = NULL; return tmp; } else if (VAR(encodePos) == VAR(tx_len)) { VAR(encodePos)++; /* * send the final ESC packet terminator */ return (TOS_CALL_COMMAND(SLIP_SUB_TX_BYTE) (END)); } else { /* send a data char */ c = (unsigned char) VAR(tx_ptr)->data[(int) VAR(encodePos)]; /* * escaped the previous character? */ if (VAR(state) & ESCAPING_TX) { switch (c) { /* TX the right char */ case ESC: c = (unsigned char) ESC_ESC; case END: c = (unsigned char) ESC_END; default: /* * this should not happen */ break; } /* end switch */ /* * return the state to a non-escape mode */ VAR(state) &= (~ESCAPING_TX); /* zero out TX bits */ } else { /* we're in regular TX mode */ /* * is this a funny character? */ if ((c == ESC) || (c == END)) { VAR(state) |= ESCAPING_TX; c = ESC; VAR(encodePos)--; /* hack: "back-up" and advance * later */ } } /* end regular data TX mode */ /* * common TX clean-up code */ /* * advance the position pointer */ VAR(encodePos)++; /* * send the single byte of data */ return (TOS_CALL_COMMAND(SLIP_SUB_TX_BYTE) (c)); } /* end send regular data */ } else { #ifdef FULLPC /* * in simulation state, we never use this function to send packet. * So, should ignore it in order to avoid interference with the * receiving */ return HANDSHAKE_SUCCESS; #endif /* * Not in TX mode? Whoa nally! Try to reset to recover */ VAR(state) = IDLE; VAR(encodePos) = 0; return HANDSHAKE_FAILED; } } /* end SLIP_TX_BYTE_READY */