char TOS_COMMAND(I2C_write)(char data){
if(VAR(state) != 0) return 0;
VAR(state) = WRITE_DATA;
VAR(data) = data;
TOS_POST_TASK(I2C_task);
return 1;
}
char TOS_COMMAND(AM_SEND_MSG)(char addr,char type, TOS_MsgPtr data){
#ifdef FULLPC_DEBUG
int i;
printf("Sending message: %x, %x\n\t", addr, type);
for(i = 0; i < sizeof(TOS_MsgPtr); i ++) printf("%x,", ((char*)data)[i]);
printf("\n");
#endif
if(VAR(state) == 0){
TOS_POST_TASK(AM_send_task);
VAR(state) = 1;
VAR(msg) = data;
data->addr = addr;
data->type = type;
VAR(msg)->group = LOCAL_GROUP & 0xff;
return 1;
}
return 0;
}
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_COMMAND(PACKET_TX_PACKET) (TOS_MsgPtr data) {
if (VAR(state) == 0) { /* receiving */
VAR(data) = (char *) data;
#ifdef FULLPC_DEBUG
printf("PACKET: byte sent: %x, STATE: %d, COUNT: %d\n",
VAR(data)[0] & 0xff, VAR(state), 0);
#endif
if (TOS_CALL_COMMAND(PACKET_SUB_TX_BYTES) (VAR(data)[0])) { /* start
* tx
*/
TOS_POST_TASK(CRC_calc);
VAR(state) = 1; /* transmitting */
VAR(count) = 1;
return 1;
} else {
return 0;
}
} else {
return 0;
}
}
char TOS_EVENT(PACKET_RX_BYTE_READY) (char data, char error) {
printf("PACKET: byte arrived: %x, STATE: %d, COUNT: %d\n", data,
VAR(state), VAR(count));
if (error) {
VAR(state) = 0;
return 0;
}
if (VAR(state) == 0) {
VAR(state) = 5;
VAR(count) = 1;
VAR(msg)[0] = data;
} else if (VAR(state) == 5) {
VAR(msg)[(int) VAR(count)] = data;
VAR(count)++;
if (VAR(count) == sizeof(TOS_Msg)) {
TOS_POST_TASK(check_crc);
return 0;
}
}
return 1;
}
char TOS_EVENT(PACKET_SUB_DATA_SEND_READY)(char data){
//lower level needs another byte....
if(VAR(state) == TRANSMITTING_START){
TOS_CALL_COMMAND(PACKET_SUB_FIFO_SEND)(start[(int)VAR(tx_count)]);
VAR(tx_count) ++;
if(VAR(tx_count) == sizeof(start)){
//turn sounder on
// TOS_CALL_COMMAND(RF_COMM_LEDr_TOGGLE)();
// if(VAR(sounder_length)>0){
// SET_PW2_PIN();
// }
VAR(state) = TRANSMITTING;
VAR(tx_count) = 1;
}
}else if(VAR(state) == TRANSMITTING){
TOS_CALL_COMMAND(PACKET_SUB_FIFO_SEND)(VAR(encoded_buffer)[(int)VAR(buf_head)]);
ADVANCE(VAR(buf_head));
VAR(enc_count) --;
//now check if that was the last byte.
if(VAR(enc_count) >= 2){
;
}else if(VAR(tx_count) < MSG_DATA_SIZE){
char next_data = ((char*)VAR(send_ptr))[(int)VAR(tx_count)];
TOS_CALL_COMMAND(PACKET_SUB_RADIO_ENCODE)(next_data);
VAR(tx_count) ++;
if(VAR(tx_count)==VAR(sounder_length)){
//if(VAR(tx_count) == 5){
//turn the sounder off
CLR_PW2_PIN();
//Enable interrupt.
}
if(VAR(tx_count) <= VAR(msg_length)){
VAR(calc_crc) = add_crc_byte(next_data, VAR(calc_crc));
}
if(VAR(tx_count) == VAR(msg_length)){
//turn the sounder off again just in case
CLR_PW2_PIN();
//the last 2 bytes must be the CRC and are
//transmitted regardless of the length.
//disable tone detect interrupt
VAR(tx_count) = MSG_DATA_SIZE - 2;
VAR(send_ptr)->crc = VAR(calc_crc);
}
}else if(VAR(buf_head) != VAR(buf_end)){
TOS_CALL_COMMAND(PACKET_SUB_RADIO_ENCODE_FLUSH)();
}else{
VAR(state) = SENDING_STRENGTH_PULSE;
///////////////DEBUG>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//outp(0x7e, UDR);
VAR(tx_count) = 0;
///////////////DEBUG>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
}
}else if(VAR(state) == SENDING_STRENGTH_PULSE){
VAR(tx_count) ++;
if(VAR(tx_count) == 3){
VAR(state) = WAITING_FOR_ACK;
//outp(VAR(state), UDR);
TOS_CALL_COMMAND(PHASE_SHIFT)();
VAR(tx_count) = 1;
TOS_CALL_COMMAND(PACKET_SUB_FIFO_SEND)(0x00);
}else{
TOS_CALL_COMMAND(PACKET_SUB_FIFO_SEND)(0xff);
}
}else if(VAR(state) == WAITING_FOR_ACK){
data &= 0x7f;
TOS_CALL_COMMAND(PACKET_SUB_FIFO_SEND)(0x00);
if(VAR(tx_count) == 1) TOS_CALL_COMMAND(SPI_RX_MODE)();
VAR(tx_count) ++;
///////////////DEBUG>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
if(VAR(tx_count) == ACK_CNT + 2) {
//outp(data, UDR);
///////////////DEBUG>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
VAR(send_ptr)->ack = (data == 0x55);
VAR(state) = IDLE_STATE;
//outp(VAR(state), UDR);
TOS_CALL_COMMAND(SPI_IDLE)();
TOS_CALL_COMMAND(START_SYMBOL_SEARCH)();
TOS_POST_TASK(packet_sent);
}
}else if(VAR(state) == RX_STATE){
TOS_CALL_COMMAND(PACKET_SUB_RADIO_DECODE)(data);
}else if(VAR(state) == ACK_SEND_STATE){
VAR(ack_count) ++;
if(VAR(ack_count) > ACK_CNT + 1){
VAR(state) = RX_DONE_STATE;
//outp(VAR(state), UDR);
TOS_CALL_COMMAND(SPI_IDLE)();
TOS_POST_TASK(packet_received);
}else{
TOS_CALL_COMMAND(SPI_TX_MODE)();
}
}
return 1;
}
char TOS_COMMAND(I2C_send_end)(){
if(VAR(state) != 0) return 0;
VAR(state) = SEND_END;
TOS_POST_TASK(I2C_task);
return 1;
}
char TOS_COMMAND(I2C_send_start)(){
if(VAR(state) != 0) return 0;
VAR(state) = SEND_START;
TOS_POST_TASK(I2C_task);
return 1;
}
char TOS_COMMAND(I2C_read)(){
if(VAR(state) != 0) return 0;
VAR(state) = READ_DATA;
TOS_POST_TASK(I2C_task);
return 1;
}
