cc2420receivep.nc

tinyos2.0版本驱动

								case SHORT_ADDRESS:
												//read the short address + destination PAN identifier
												////printfUART("s ad",""); 
												call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 4, 6); 
													break;
								
								case LONG_ADDRESS:
												//read the long address + destination PAN identifier
												call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 4, 12);
												break;
							}
						}
						else
						{
							//destination address fields not present
							m_state = S_RX_PAYLOAD;
							//it is not possible to do the address decoding, there is no destination address fields
							//send the full packet up
							call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 4, rxmpdu_ptr->length- 3);
							
						}
					}
					else
					{
						//address decode is not activated
						m_state = S_RX_PAYLOAD;
						call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 4, rxmpdu_ptr->length - 3);
					}
	
	
					break;			
	case S_RX_ADDR:
					m_state = S_RX_PAYLOAD;
					
					
					switch ((rxmpdu_ptr->frame_control1 & 0x7))
					{
						case TYPE_BEACON:
									////printfUART("RB \n","");
									
									beacon_addr_short_ptr = (beacon_addr_short *) &rxmpdu_ptr->data[0];
									
									////printfUART("pb %x %x %x %x\n",rxmpdu_ptr->seq_num, beacon_addr_short_ptr->destination_PAN_identifier,beacon_addr_short_ptr->destination_address, beacon_addr_short_ptr->source_address);
																		
									/*
									for (i=0;i<6;i++)
									{
										//printfUART("r %i %x %x %x\n",i,rxmpdu_ptr->data[i],rx_buf[i],rx_buf[i+4]);
									}
									*/
									
									//printfUART("RB %x %x \n",ver_macCoordShortAddress,ver_macShortAddress);

									
									//avoid VERIFY static assignment of coordinator parent
									if (beacon_addr_short_ptr->source_address != ver_macCoordShortAddress)
									{
											//printfUART("bad bec %x %x\n", beacon_addr_short_ptr->source_address,ver_macCoordShortAddress);
											
											m_state = S_RX_DISCARD;
											call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 10, rxmpdu_ptr->length - 9);
											return;
									}
									/*
									if (ver_macShortAddress != 0xffff)
									{
										if ( beacon_addr_short_ptr->source_address != ver_macShortAddress)
										{
											//printfUART("pb %x %x\n", beacon_addr_short_ptr->source_address,ver_macShortAddress);
											
											m_state = S_RX_DISCARD;
											call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 10, rxmpdu_ptr->length - 9);
											return;
										}
									}
									*/
									break;
							case TYPE_DATA:
							case TYPE_CMD:
							
									//VALIDATION OF DESTINATION ADDRESSES - NOT TO OVERLOAD THE PROCESSOR
									if (destination_address > 1)
									{
										switch(destination_address)
										{
											case SHORT_ADDRESS: 
													dest_short_ptr = (dest_short *) &rxmpdu_ptr->data[0];
																
													if ( dest_short_ptr->destination_address != 0xffff && dest_short_ptr->destination_address != ver_macShortAddress)
													{
														//printfUART("nsm %x %x\n", dest_short_ptr->destination_address,ver_macShortAddress); 
														
														m_state = S_RX_DISCARD;
														call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 10, rxmpdu_ptr->length - 9);
														return;
													}
													
													//If a destination PAN identifier is included in the frame, it shall match macPANId or shall be the
													//broadcast PAN identifier (0 x ffff).
													if(dest_short_ptr->destination_PAN_identifier != 0xffff && dest_short_ptr->destination_PAN_identifier != ver_macPANId )
													{
														//printfUART("wsP %x %x \n", dest_short_ptr->destination_PAN_identifier,ver_macPANId); 
														
														m_state = S_RX_DISCARD;
														call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 10, rxmpdu_ptr->length - 9);
														return;
													}
													
													break;
											
											case LONG_ADDRESS: 
													
													dest_long_ptr = (dest_long *) &rxmpdu_ptr->data[0];
													/*
													if ( dest_long_ptr->destination_address0 !=ver_aExtendedAddress0 && dest_long_ptr->destination_address1 !=ver_aExtendedAddress1 )
													{
														//printfUART("nlm %x %x \n",dest_long_ptr->destination_address0,dest_long_ptr->destination_address1); 
														
														m_state = S_RX_DISCARD;
														call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 16, rxmpdu_ptr->length - 15);
														return;
													}
													
													
													//If a destination PAN identifier is included in the frame, it shall match macPANId or shall be the
													//broadcast PAN identifier (0 x ffff).
													if(dest_long_ptr->destination_PAN_identifier != 0xffff && dest_long_ptr->destination_PAN_identifier != ver_macPANId )
													{
														//printfUART("wLP %x %x\n", dest_long_ptr->destination_PAN_identifier,ver_macPANId); 
																	
														m_state = S_RX_DISCARD;
														call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 16, rxmpdu_ptr->length - 15);
														return;
													}
													*/
													break;
										}
									}
									
									break;
									
							case TYPE_ACK:
							
										//printfUART("error ack \n",""); 
										//call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr);
										
										return;
										
									break;
									

					}
					
					//read the remaining packet
					switch(destination_address)
					{
						case SHORT_ADDRESS:
							////printfUART("as %i\n", (rxmpdu_ptr->length - 9));
								
							call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 10, rxmpdu_ptr->length - 9); //7
							break;
								
						case LONG_ADDRESS:
							////printfUART("al %i\n", (rxmpdu_ptr->length - 15));
							call RXFIFO.continueRead((uint8_t*)rxmpdu_ptr + 16, rxmpdu_ptr->length - 15);
							break;
					}
			
			break;
					
					
	case S_RX_PAYLOAD:
				call CSN.set();
				//signal Receiveframe.receive((uint8_t*)rxmpdu_ptr, rssi);
				
				
				//rssi= 255 - rx_buf[len-1];
				
				/*
				for (i=6;i<12;i++)
				{
					//printfUART("p %i %x %x\n",i,rxmpdu_ptr->data[i],rx_buf[i-6]);
				}
				*/
				
				if(!m_missed_packets) {
					// Release the SPI only if there are no more frames to download
					call SpiResource.release();
				}
				
				rssi = 255 - rxmpdu_ptr->data[rxmpdu_ptr->length-4];
				
				//printfUART("pay %i %x %i\n",rxmpdu_ptr->seq_num, rssi,m_missed_packets);
				
				signal Receiveframe.receive((uint8_t*)rxmpdu_ptr, rssi);
				
				
				if (m_missed_packets == 0)
				{
					flush();
				}
				else
				{
					waitForNextPacket();
				}
				
			break;
	
	
	case S_RX_DISCARD:
			atomic receivingPacket = FALSE;
			call CSN.set();
			call SpiResource.release();	
				if (m_missed_packets == 0)
				{
					flush();
				}
				else
				{
					waitForNextPacket();
				}
				
			break;
				
	default:
			  atomic receivingPacket = FALSE;
			  call CSN.set();
			  call SpiResource.release();
			  break;
	
	
	}
  
  }
  
  
  /*
    cc2420_header_t* header = call CC2420PacketBody.getHeader( m_p_rx_buf );
    cc2420__t* metadata = call CC2420PacketBody.getMetadata( m_p_rx_buf );
    uint8_t* buf = (uint8_t*) header;
    rxFrameLength = buf[ 0 ];

    switch( m_state ) {

    case S_RX_LENGTH:
      m_state = S_RX_FCF;
      if ( rxFrameLength + 1 > m_bytes_left ) {
        // Length of this packet is bigger than the RXFIFO, flush it out.
        flush();
        
      } else {
        if ( !call FIFO.get() && !call FIFOP.get() ) {
          m_bytes_left -= rxFrameLength + 1;
        }
        
        if(rxFrameLength <= MAC_PACKET_SIZE) {
          if(rxFrameLength > 0) {
            if(rxFrameLength > SACK_HEADER_LENGTH) {
              // This packet has an FCF byte plus at least one more byte to read
              call RXFIFO.continueRead(buf + 1, SACK_HEADER_LENGTH);
              
            } else {
              // This is really a bad packet, skip FCF and get it out of here.
              m_state = S_RX_PAYLOAD;
              call RXFIFO.continueRead(buf + 1, rxFrameLength);
            }
                            
          } else {
            // Length == 0; start reading the next packet
            atomic receivingPacket = FALSE;
            call CSN.set();
            call SpiResource.release();
            waitForNextPacket();
          }
          
        } else {
          // Length is too large; we have to flush the entire Rx FIFO
          flush();
        }
      }
      break;
      
    case S_RX_FCF:
      m_state = S_RX_PAYLOAD;
      
      /*
       * The destination address check here is not completely optimized. If you 
       * are seeing issues with dropped acknowledgements, try removing
       * the address check and decreasing SACK_HEADER_LENGTH to 2.
       * The length byte and the FCF byte are the only two bytes required
       * to know that the packet is valid and requested an ack.  The destination
       * address is useful when we want to sniff packets from other transmitters
       * while acknowledging packets that were destined for our local address.
       *//*
      if(call CC2420Config.isAutoAckEnabled() && !call CC2420Config.isHwAutoAckDefault()) {
        if (((( header->fcf >> IEEE154_FCF_ACK_REQ ) & 0x01) == 1)
            && (header->dest == call CC2420Config.getShortAddr())
            && ((( header->fcf >> IEEE154_FCF_FRAME_TYPE ) & 7) == IEEE154_TYPE_DATA)) {
          // CSn flippage cuts off our FIFO; SACK and begin reading again
          call CSN.set();
          call CSN.clr();
          call SACK.strobe();
          call CSN.set();
          call CSN.clr();
          call RXFIFO.beginRead(buf + 1 + SACK_HEADER_LENGTH, 
              rxFrameLength - SACK_HEADER_LENGTH);
          return;
        }
		
		
      }
      
      // Didn't flip CSn, we're ok to continue reading.
      call RXFIFO.continueRead(buf + 1 + SACK_HEADER_LENGTH, 
          rxFrameLength - SACK_HEADER_LENGTH);
      break;
    
    case S_RX_PAYLOAD:
      call CSN.set();
      
      if(!m_missed_packets) {
        // Release the SPI only if there are no more frames to download
        call SpiResource.release();
      }
      
      if ( m_timestamp_size ) {
        if ( rxFrameLength > 10 ) {
          metadata->time = m_timestamp_queue[ m_timestamp_head ];
          m_timestamp_head = ( m_timestamp_head + 1 ) % TIMESTAMP_QUEUE_SIZE;
          m_timestamp_size--;
        }
      } else {
        metadata->time = 0xffff;
      }
      
      // We may have received an ack that should be processed by Transmit
      // buf[rxFrameLength] >> 7 checks the CRC
      if ( ( buf[ rxFrameLength ] >> 7 ) && rx_buf ) {
        uint8_t type = ( header->fcf >> IEEE154_FCF_FRAME_TYPE ) & 7;
       // signal CC2420Receive.receive( type, m_p_rx_buf );
        if ( type == IEEE154_TYPE_DATA ) {
          post receiveDone_task();
          return;
        }
      }
      
      waitForNextPacket();
      break;

    default:
      atomic receivingPacket = FALSE;
      call CSN.set();
      call SpiResource.release();
      break;
      
    }
    */
  }

  async event void RXFIFO.writeDone( uint8_t* tx_buf, uint8_t tx_len, error_t error ) {
  }  
  
  /***************** Tasks *****************/
  /**
   * Fill in metadata details, pass the packet up the stack, and
   * get the next packet.
   */
   /*
  task void receiveDone_task() {
    cc2420_metadata_t* metadata = call CC2420PacketBody.getMetadata( m_p_rx_buf );
    uint8_t* buf = (uint8_t*) call CC2420PacketBody.getHeader( m_p_rx_buf );;
    
    metadata->crc = buf[ rxFrameLength ] >> 7;
    metadata->rssi = buf[ rxFrameLength - 1 ];
    metadata->lqi = buf[ rxFrameLength ] & 0x7f;
    m_p_rx_buf = signal Receive.receive( m_p_rx_buf, m_p_rx_buf->data, 
                                         rxFrameLength );

    atomic receivingPacket = FALSE;
    waitForNextPacket();
  }
  */
  /****************** CC2420Config Events ****************/
  event void CC2420Config.syncDone( error_t error ) {
  }
  
  /****************** Functions ****************/
  /**
   * Attempt to acquire the SPI bus to receive a packet.
   */
   
  void beginReceive() { 
  
    m_state = S_RX_LENGTH;
    
    atomic receivingPacket = TRUE;
  
  ////printfUART("br %i\n",m_state);

	if(call SpiResource.isOwner()) {
      receive();
      
    } else if (call SpiResource.immediateRequest() == SUCCESS) {
      receive();
      
    } else {
      call SpiResource.request();
    }
  }
  
  /**
   * Flush out the Rx FIFO
   */
  void flush() {
	//printfUART("f %i\n",m_state);
    reset_state();
    call CSN.set();
    call CSN.clr();
    call SFLUSHRX.strobe();
    call SFLUSHRX.strobe();
    call CSN.set();
    call SpiResource.release();
    waitForNextPacket();
  }
  
  /**
   * The first byte of each packet is the length byte.  Read in that single
   * byte, and then read in the rest of the packet.  The CC2420 could contain
   * multiple packets that have been buffered up, so if something goes wrong, 
   * we necessarily want to flush out the FIFO unless we have to.
   */
  void receive() {
	//call Leds.led2Toggle();
  
    call CSN.clr();
    
	//call RXFIFO.beginRead( (uint8_t*)(call CC2420PacketBody.getHeader( m_p_rx_buf )), 1 );
  
	//call RXFIFO.beginRead ((uint8_t*)rxmpdu_ptr,100);
  
	//my old
	call RXFIFO.beginRead((uint8_t*)rxmpdu_ptr,1);
	
	

  
  }


  /**
   * Determine if there's a packet ready to go, or if we should do nothing
   * until the next packet arrives
   */
   
  void waitForNextPacket() {
    atomic {
      if ( m_state == S_STOPPED ) {
        call SpiResource.release();
        return;
      }
      
	   //printfUART("wn %i %i\n",m_state,m_missed_packets );
	  
	  
      atomic receivingPacket = FALSE;
	  
      if ( ( m_missed_packets && call FIFO.get() ) || !call FIFOP.get() ) {
        // A new packet is buffered up and ready to go
        if ( m_missed_packets ) {
          m_missed_packets--;
        }
        
        beginReceive();
        
      } else {
        // Wait for the next packet to arrive
		
		
		
        m_state = S_STARTED;
		
		//printfUART("wnP %i\n",m_state);
		
        m_missed_packets = 0;
        call SpiResource.release();
      }
    }
  }
 
  /**
   * Reset this component
   */
   
  void reset_state() {
    m_bytes_left = RXFIFO_SIZE;
    atomic receivingPacket = FALSE;
    //m_timestamp_head = 0;
    //m_timestamp_size = 0;
    m_missed_packets = 0;
  }

}