/*------------------------------------------------------------------------------
* MRFI Rx interrupt service routine
*----------------------------------------------------------------------------*/
void MRFI_RxCompleteISR( void ) {
mrfiPacket_t rx_packet;
/* Grab packet from buffer */
MRFI_Receive(&rx_packet);
/* Send packet off to be processed in another thread */
ProcessPacket(rx_packet);
}
/******************************************************************************
* @fn MRFI_RxCompleteISR
*
* @brief This function is called by the ISR of MRFI at RF receive and MUST
* be included in all applications. It should be as short as possible
* to avoid lengthy processing in the ISR.
*
* @param none
*
* @return void
*/
void MRFI_RxCompleteISR()
{
uint8 pktType;
MRFI_Receive(&pkt);
pktType= MRFI_P_PAYLOAD(&pkt)[1];
if (MRFI_GET_PAYLOAD_LEN(&pkt)==2 && pktType==MRFI_LINK_ACK) {
fAckRdy= TRUE;
} else if (pktType==MRFI_LINK_DATA) {
mrfiPktRdy= TRUE;
}
}
/******************************************************************************
* @fn MRFI_RxCompleteISR
*
* @brief Here on Rx interrupt from radio. Process received frame from the
* radio Rx FIFO.
*
* input parameters
*
* output parameters
*
* @return void
*/
void MRFI_RxCompleteISR()
{
frameInfo_t *fInfoPtr;
/* room for more? */
if (fInfoPtr=nwk_QfindSlot(INQ))
{
MRFI_Receive(&fInfoPtr->mrfiPkt);
dispatchFrame(fInfoPtr);
}
return;
}
void MRFI_RxCompleteISR()
{
mrfiPacket_t packet;
stop_fast_timeout();
stop_slow_timeout();
MRFI_Receive(&packet);
if (packet.frame[9]<4) {
print_counter(packet.frame[9]);
start_slow_timeout();
} else {
MRFI_WakeUp();
MRFI_RxOn();
}
}
void MRFI_RxCompleteISR()
{
BSP_TOGGLE_LED1();
MRFI_Receive(&inBuffer);
uint8_t pkt_type = GET_FROM_FRAME(MRFI_P_PAYLOAD(&inBuffer), F_TYPE);
switch (pkt_type) {
case (F_TYPE_UF):
#ifdef PRINT_UF
print_time();
print_UF(&inBuffer);
#endif
break;
case (F_TYPE_CW):
#ifdef PRINT_CW
print_time();
print_CW(&inBuffer);
#endif
break;
case (F_TYPE_ACK):
#ifdef PRINT_ACK
print_time();
print_ACK(&inBuffer);
#endif
break;
case (F_TYPE_DATA):
#ifdef PRINT_DATA
print_time();
print_DATA(&inBuffer);
#endif
break;
case (F_TYPE_FIN):
#ifdef PRINT_FIN
print_time();
print_FIN(&inBuffer);
#endif
break;
default:
print_time();
print_debug("\r\nError: Unrecognized packet format",35);
}
BSP_TOGGLE_LED1();
}
/**
* MRFI_RxCompleteISR
*
* Callback function called whenever a new wireless packet is received
*/
void MRFI_RxCompleteISR(void)
{
SWPACKET swPacket;
mrfiPacket_t mPacket;
MRFI_Receive(&mPacket);
swPacket.value.length = mPacket.frame[0] - SWAP_DATA_HEAD_LEN;
swPacket.destAddr = mPacket.frame[1];
swPacket.srcAddr = mPacket.frame[2];
swPacket.hop = (mPacket.frame[3] >> 4) & 0x0F;
swPacket.security = mPacket.frame[3] & 0x0F;
swPacket.nonce = mPacket.frame[4];
swPacket.function = mPacket.frame[5];
swPacket.regAddr = mPacket.frame[6];
swPacket.regId = mPacket.frame[7];
swPacket.value.data = mPacket.frame + 8;
dispatchSwapPacket(&swPacket);
return;
}
void MRFI_RxCompleteISR()
{
P1OUT |= 0x02;
P2OUT |= 0x04;
uint8_t erase_me=0;
uint8_t channel;
MRFI_Receive(&packet);
channel = (uint8_t)((packet.frame[9]-'0')*10+(packet.frame[10]-'0'));
erase_me++;
if (channel>=11 && channel<=26) {
/* set timer */
BCSCTL3 |= LFXT1S_2;
TACCR0=1000; //~.1sec
TACTL=TASSEL_1+MC_1;
TACCTL0=CCIE;
/* set frequency */
MRFI_RxIdle();
switch(channel) {
case 11: mrfiSpiWriteReg(CHANNR,0x00); break;
case 12: mrfiSpiWriteReg(CHANNR,0x0D); break;
case 13: mrfiSpiWriteReg(CHANNR,0x19); break;
case 14: mrfiSpiWriteReg(CHANNR,0x26); break;
case 15: mrfiSpiWriteReg(CHANNR,0x32); break;
case 16: mrfiSpiWriteReg(CHANNR,0x3F); break;
case 17: mrfiSpiWriteReg(CHANNR,0x4B); break;
case 18: mrfiSpiWriteReg(CHANNR,0x58); break;
case 19: mrfiSpiWriteReg(CHANNR,0x64); break;
case 20: mrfiSpiWriteReg(CHANNR,0x71); break;
case 21: mrfiSpiWriteReg(CHANNR,0x7D); break;
case 22: mrfiSpiWriteReg(CHANNR,0x8A); break;
case 23: mrfiSpiWriteReg(CHANNR,0x96); break;
case 24: mrfiSpiWriteReg(CHANNR,0xA3); break;
case 25: mrfiSpiWriteReg(CHANNR,0xAF); break;
case 26: mrfiSpiWriteReg(CHANNR,0xBC); break;
}
}
P2OUT &= ~0x04;
P1OUT &= ~0x02;
}
void MRFI_RxCompleteISR()
{
mrfiPacket_t PacketRecieved;
mPacket Packet;
char rssi ;
uint8_t ID_Network_tmp, ID_Beacon_tmp ,src ,i ,data;
uint32_t voisin_voisin; //the voisin of voisin
MRFI_Receive(&PacketRecieved);
RecievemPacket(&PacketRecieved ,&Packet);
if(Packet.flag == FBEACON){
etat.Surveille_Cnt = ( etat.Surveille_Cnt + 1 )%65535;
ID_Network_tmp = Packet.payload.beacon.ID_Network;
ID_Beacon_tmp = Packet.payload.beacon.ID_Slot;
src = Packet.src;
voisin_voisin = Packet.payload.beacon.Voisin;
rssi = PacketRecieved.rxMetrics[0];
if(rssi > -84){ //seuil avec pwr(0) ,distance 70cm
etat.check[src-1] = (etat.check[src-1] + 1)%65535; //make sure if the voisin is there
Add_router(&etat , src, voisin_voisin); //every time it recieve the beacon , update the route table
}
/*
print_8b(ID_Network_tmp);
print_8b(ID_Beacon_tmp);
print(" ");
print_8b(-rssi);
print("\n\r");
*/
if(rssi < -84 && etat.ID_Beacon == ID_Beacon_tmp && etat.ID_Beacon !=0 && etat.HOST == IS_NOT_CREATER){ //if the beacon source go far , choose another
Stop_Timer();
}else{
if(etat.synchrone == 0 && etat.HOST == IS_NOT_CREATER){
Stop_Timer();
etat.ID_Network = ID_Network_tmp;
etat.ID_Beacon = ID_Beacon_tmp;
etat.synchrone = 1;
if(etat.MAC > etat.ID_Beacon ){
etat.state = WAIT_BEACON ; //change the state
timer_send_beacon(&etat);
}else{
etat.state = WAIT_SYNCHRONE ; //change the state
timer_synchrone(&etat);
}
}
if(ID_Network_tmp < etat.ID_Network){ //if there is 2 network collision
if(etat.HOST == IS_CREATER){
etat.HOST = IS_NOT_CREATER;
P1OUT ^= 0x02; //jaune led
}
Stop_Timer();
etat.ID_Network = ID_Network_tmp;
etat.ID_Beacon = ID_Beacon_tmp;
etat.synchrone = 1;
if(etat.MAC > etat.ID_Beacon ){
etat.state = WAIT_BEACON; //change the state
timer_send_beacon(&etat);
}else{
etat.state = WAIT_SYNCHRONE ; //change the state
timer_synchrone(&etat);
}
}
}
}else if(Packet.flag == FDATA){
if(Packet.payload.data.Next_hop == etat.MAC){ //if next hop is him, relay and change the next hop
if(Packet.dst == etat.MAC){ //if it is really for me
etat.Dst = Packet.src;
if(UART_MODE!=2){ //change mode to type if recieve a paquet
UART_MODE = 2;
print("\n\rRecieved message from: ");
print_8b(etat.Dst);
print("\n\r");
}
for (i=0;i<Packet.length-11;i++) {
data = Packet.payload.data.data[i];
EnQueue(&etat.FIFO_Recieve,data);
}
}else{ //if it just nedd relay
P1OUT ^= 0x02;
PacketRecieved.frame[10] = Find_next_hop(&etat , Packet.dst);
MRFI_Transmit(&PacketRecieved, MRFI_TX_TYPE_CCA);
//MRFI_Transmit(&PacketRecieved, MRFI_TX_TYPE_FORCED);
}
}
if(Packet.dst == BROADCAST){ //if it is message broadcast
for (i=0;i<Packet.length-11;i++) {
data = Packet.payload.data.data[i];
EnQueue(&etat.FIFO_Recieve,data);
}
}
}else if(Packet.flag == FRIP){ //recieve the packet of rip then update the router table
Update_rip(&etat ,&Packet);
}
}
//=============================================
void gradient_wakeup_rx()
{
mrfiPacket_t packetReceived;
frameInfo_t * freeSlot;
MRFI_Receive(&packetReceived);
uint8_t pkt_next_hop;
uint8_t pkt_type = packetReceived.frame[F_TYPE];
switch (gradient_state) {
//--------------------------------------- transmitter
case (GRADIENT_RXACK): //rx
pkt_next_hop = packetReceived.frame[F_ACK_NEXT_HOP];
if (pkt_type==F_TYPE_ACK && pkt_next_hop==myAddr) {
gradient_add_neighbor(&packetReceived);
}
break;
case (GRADIENT_RXFIN): //rx
pkt_next_hop = packetReceived.frame[F_FIN_NEXT_HOP];
if (pkt_type==F_TYPE_FIN && pkt_next_hop==myAddr) {
stop_timer();
print_success("\r\nTX successful",15);
QfreeSlot(dataToSend);
gradient_end_txrx();
}
break;
//--------------------------------------- receiver
case (GRADIENT_IDLE): //rx
if (pkt_type==F_TYPE_UF) {
/* stop preamble sampling */
wor_stop(IS_SINK_NODE);
/* stop possible timers (if OUTQ not empty) */
stop_timer();
gradient_set_state(GRADIENT_RXUF);
addr_initiator = packetReceived.frame[F_SRC];
MRFI_RxIdle();
set_timer((packetReceived.frame[F_UF_COUNTER])*UF_PERIOD-GUARD_CW);
}
break;
case (GRADIENT_RXCW): //rx
if (pkt_type==F_TYPE_CW) {
stop_timer();
gradient_set_state(GRADIENT_BACKOFFACK);
MRFI_RxIdle();
/* second timer to send my ACK */
set_second_random_timer((packetReceived.frame[F_CW_CWDURATION])-GUARD_DATA-ACK_DURATION);
/* main timer at the end of CW */
set_timer((packetReceived.frame[F_CW_CWDURATION])-GUARD_DATA);
} else if (pkt_type==F_TYPE_UF) {
set_timer(TIMEOUT_CW);
}
break;
case (GRADIENT_RXDATA): //rx
pkt_next_hop = packetReceived.frame[F_DATA_NEXT_HOP];
if (pkt_type==F_TYPE_DATA && pkt_next_hop==myAddr) {
stop_timer();
gradient_build_DATA_path(&packetReceived); //add myAddr to packet
if (myHeight!=0) { //I'm not a sink
/* add packet to outQ for later relaying if not sink */
print_debug("\r\nQueued for relay",18);
freeSlot = QfindFreeSlot(OUTQ);
if (freeSlot) {
freeSlot->mrfiPkt = packetReceived;
}
} else { //I'm a sink
/* process incoming packet through INQ */
frameInfo_t * freeSlot = QfindFreeSlot(INQ);
if (freeSlot) {
freeSlot->mrfiPkt = packetReceived;
lastData = packetReceived;
QfreeSlot(freeSlot);
}
}
/* delay before sending FIN */
gradient_set_state(GRADIENT_TXFIN);
MRFI_RxIdle();
set_timer(DELAY_FIN);
}
break;
}
}
