/*
* 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 */
