cpu/avr/radio/rf230bb/halbb.c

   1 /*   Copyright (c) 2009, Swedish Institute of Computer Science
   2  *  All rights reserved.
   3  *
   4  *  Additional fixes for AVR contributed by:
   5  *
   6  *      Colin O'Flynn coflynn@newae.com
   7  *      Eric Gnoske egnoske@gmail.com
   8  *      Blake Leverett bleverett@gmail.com
   9  *      Mike Vidales mavida404@gmail.com
  10  *      Kevin Brown kbrown3@uccs.edu
  11  *      Nate Bohlmann nate@elfwerks.com
  12  *      David Kopf dak664@embarqmail.com
  13  *
  14  *   All rights reserved.
  15  *
  16  *   Redistribution and use in source and binary forms, with or without
  17  *   modification, are permitted provided that the following conditions are met:
  18  *
  19  *   * Redistributions of source code must retain the above copyright
  20  *     notice, this list of conditions and the following disclaimer.
  21  *   * Redistributions in binary form must reproduce the above copyright
  22  *     notice, this list of conditions and the following disclaimer in
  23  *     the documentation and/or other materials provided with the
  24  *     distribution.
  25  *   * Neither the name of the copyright holders nor the names of
  26  *     contributors may be used to endorse or promote products derived
  27  *     from this software without specific prior written permission.
  28  *
  29  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  30  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  31  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  32  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  33  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  34  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  35  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  36  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  37  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  38  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  39  *  POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  *
  42 */
  43
  44 /**
  45  *   \addtogroup wireless
  46  *  @{
  47 */
  48
  49 /**
  50  *   \defgroup hal RF230 hardware level drivers
  51  *   @{
  52  */
  53
  54 /**
  55  *  \file
  56  *  This file contains low-level radio driver code.
  57  *  This version is optimized for use with the "barebones" RF230bb driver,
  58  *  which communicates directly with the contiki core MAC layer.
  59  */
  60
  61
  62
  63 /*============================ INCLUDE =======================================*/
  64 #include <stdlib.h>
  65
  66 #include "hal.h"
  67 #include "at86rf230_registermap.h"
  68 /*============================ MACROS ========================================*/
  69
  70 /*
  71  * Macros defined for the radio transceiver's access modes.
  72  *
  73  * These functions are implemented as macros since they are used very often.
  74  */
  75 #define HAL_DUMMY_READ         (0x00) /**<  Dummy value for the SPI. */
  76
  77 #define HAL_TRX_CMD_RW         (0xC0) /**<  Register Write (short mode). */
  78 #define HAL_TRX_CMD_RR         (0x80) /**<  Register Read (short mode). */
  79 #define HAL_TRX_CMD_FW         (0x60) /**<  Frame Transmit Mode (long mode). */
  80 #define HAL_TRX_CMD_FR         (0x20) /**<  Frame Receive Mode (long mode). */
  81 #define HAL_TRX_CMD_SW         (0x40) /**<  SRAM Write. */
  82 #define HAL_TRX_CMD_SR         (0x00) /**<  SRAM Read. */
  83 #define HAL_TRX_CMD_RADDRM     (0x7F) /**<  Register Address Mask. */
  84
  85 #define HAL_CALCULATED_CRC_OK   (0) /**<  CRC calculated over the frame including the CRC field should be 0. */
  86 /*============================ TYPDEFS =======================================*/
  87 /*============================ VARIABLES =====================================*/
  88 /** \brief This is a file internal variable that contains the 16 MSB of the
  89  *         system time.
  90  *
  91  *         The system time (32-bit) is the current time in microseconds. For the
  92  *         AVR microcontroller implementation this is solved by using a 16-bit
  93  *         timer (Timer1) with a clock frequency of 1MHz. The hal_system_time is
  94  *         incremented when the 16-bit timer overflows, representing the 16 MSB.
  95  *         The timer value it self (TCNT1) is then the 16 LSB.
  96  *
  97  *  \see hal_get_system_time
  98  */
  99 static uint16_t hal_system_time = 0;
 100
 101 /*Flag section.*/
 102 //static uint8_t volatile hal_bat_low_flag; /**<  BAT_LOW flag. */
 103 //static uint8_t volatile hal_pll_lock_flag;   /**<  PLL_LOCK flag. */
 104
 105 /*Callbacks.*/
 106
 107 /** \brief This function is called when a rx_start interrupt is signaled.
 108  *
 109  *         If this function pointer is set to something else than NULL, it will
 110  *         be called when a RX_START event is signaled. The function takes two
 111  *         parameters: timestamp in IEEE 802.15.4 symbols (16 us resolution) and
 112  *         frame length. The event handler will be called in the interrupt domain,
 113  *         so the function must be kept short and not be blocking! Otherwise the
 114  *         system performance will be greatly degraded.
 115  *
 116  *  \see hal_set_rx_start_event_handler
 117  */
 118 //static hal_rx_start_isr_event_handler_t rx_start_callback;
 119
 120 /** \brief This function is called when a trx_end interrupt is signaled.
 121  *
 122  *         If this function pointer is set to something else than NULL, it will
 123  *         be called when a TRX_END event is signaled. The function takes one
 124  *         parameter: timestamp in IEEE 802.15.4 symbols (16 us resolution).
 125  *         The event handler will be called in the interrupt domain,
 126  *         so the function must not block!
 127  *
 128  *  \see hal_set_trx_end_event_handler
 129  */
 130 //static hal_trx_end_isr_event_handler_t trx_end_callback;
 131 /*============================ PROTOTYPES ====================================*/
 132 /*============================ IMPLEMENTATION ================================*/
 133
 134 /** \brief  This function initializes the Hardware Abstraction Layer.
 135  */
 136 void
 137 hal_init(void)
 138 {
 139     /*Reset variables used in file.*/
 140     hal_system_time = 0;
 141 //  hal_reset_flags();
 142
 143     /*IO Specific Initialization.*/
 144     DDR_SLP_TR |= (1 << SLP_TR); /* Enable SLP_TR as output. */
 145     DDR_RST    |= (1 << RST);    /* Enable RST as output. */
 146
 147     /*SPI Specific Initialization.*/
 148     /* Set SS, CLK and MOSI as output. */
 149     HAL_DDR_SPI  |= (1 << HAL_DD_SS) | (1 << HAL_DD_SCK) | (1 << HAL_DD_MOSI);
 150     HAL_PORT_SPI |= (1 << HAL_DD_SS) | (1 << HAL_DD_SCK); /* Set SS and CLK high */
 151     /* Run SPI at max speed */
 152     SPCR         = (1 << SPE) | (1 << MSTR); /* Enable SPI module and master operation. */
 153     SPSR         = (1 << SPI2X); /* Enable doubled SPI speed in master mode. */
 154
 155     /*TIMER1 Specific Initialization.*/
 156     TCCR1B = HAL_TCCR1B_CONFIG;       /* Set clock prescaler */
 157     TIFR1 |= (1 << ICF1);             /* Clear Input Capture Flag. */
 158     HAL_ENABLE_OVERFLOW_INTERRUPT(); /* Enable Timer1 overflow interrupt. */
 159     hal_enable_trx_interrupt();    /* Enable interrupts from the radio transceiver. */
 160 }
 161
 162 /*----------------------------------------------------------------------------*/
 163 /** \brief  This function reset the interrupt flags and interrupt event handlers
 164  *          (Callbacks) to their default value.
 165  */
 166 //void
 167 //hal_reset_flags(void)
 168 //{
 169 //    AVR_ENTER_CRITICAL_REGION();
 170
 171     /* Reset Flags. */
 172 //    hal_bat_low_flag     = 0;
 173 //    hal_pll_lock_flag    = 0;
 174
 175     /* Reset Associated Event Handlers. */
 176 //    rx_start_callback = NULL;
 177 //    trx_end_callback  = NULL;
 178
 179 //    AVR_LEAVE_CRITICAL_REGION();
 180 //}
 181
 182 /*----------------------------------------------------------------------------*/
 183 /** \brief  This function returns the current value of the BAT_LOW flag.
 184  *
 185  *  The BAT_LOW flag is incremented each time a BAT_LOW event is signaled from the
 186  *  radio transceiver. This way it is possible for the end user to poll the flag
 187  *  for new event occurances.
 188  */
 189 //uint8_t
 190 //hal_get_bat_low_flag(void)
 191 //{
 192 //    return hal_bat_low_flag;
 193 //}
 194
 195 /*----------------------------------------------------------------------------*/
 196 /** \brief  This function clears the BAT_LOW flag.
 197  */
 198 //void
 199 //hal_clear_bat_low_flag(void)
 200 //{
 201 //    AVR_ENTER_CRITICAL_REGION();
 202 //    hal_bat_low_flag = 0;
 203 //    AVR_LEAVE_CRITICAL_REGION();
 204 //}
 205
 206 /*----------------------------------------------------------------------------*/
 207 /** \brief  This function is used to set new TRX_END event handler, overriding
 208  *          old handler reference.
 209  */
 210 //hal_trx_end_isr_event_handler_t
 211 //hal_get_trx_end_event_handler(void)
 212 //{
 213 //    return trx_end_callback;
 214 //}
 215
 216 /*----------------------------------------------------------------------------*/
 217 /** \brief  This function is used to set new TRX_END event handler, overriding
 218  *          old handler reference.
 219  */
 220 //void
 221 //hal_set_trx_end_event_handler(hal_trx_end_isr_event_handler_t trx_end_callback_handle)
 222 //{
 223 //    AVR_ENTER_CRITICAL_REGION();
 224 //    trx_end_callback = trx_end_callback_handle;
 225 //    AVR_LEAVE_CRITICAL_REGION();
 226 //}
 227
 228 /*----------------------------------------------------------------------------*/
 229 /** \brief  Remove event handler reference.
 230  */
 231 //void
 232 //hal_clear_trx_end_event_handler(void)
 233 //{
 234 //    AVR_ENTER_CRITICAL_REGION();
 235 //    trx_end_callback = NULL;
 236 //    AVR_LEAVE_CRITICAL_REGION();
 237 //}
 238
 239 /*----------------------------------------------------------------------------*/
 240 /** \brief  This function returns the active RX_START event handler
 241  *
 242  *  \return Current RX_START event handler registered.
 243  */
 244 //hal_rx_start_isr_event_handler_t
 245 //hal_get_rx_start_event_handler(void)
 246 //{
 247 //    return rx_start_callback;
 248 //}
 249
 250 /*----------------------------------------------------------------------------*/
 251 /** \brief  This function is used to set new RX_START event handler, overriding
 252  *          old handler reference.
 253  */
 254 //void
 255 //hal_set_rx_start_event_handler(hal_rx_start_isr_event_handler_t rx_start_callback_handle)
 256 //{
 257 //    AVR_ENTER_CRITICAL_REGION();
 258 //    rx_start_callback = rx_start_callback_handle;
 259 //    AVR_LEAVE_CRITICAL_REGION();
 260 //}
 261
 262 /*----------------------------------------------------------------------------*/
 263 /** \brief  Remove event handler reference.
 264  */
 265 //void
 266 //hal_clear_rx_start_event_handler(void)
 267 //{
 268 //    AVR_ENTER_CRITICAL_REGION();
 269 //    rx_start_callback = NULL;
 270 //    AVR_LEAVE_CRITICAL_REGION();
 271 //}
 272
 273 /*----------------------------------------------------------------------------*/
 274 /** \brief  This function returns the current value of the PLL_LOCK flag.
 275  *
 276  *  The PLL_LOCK flag is incremented each time a PLL_LOCK event is signaled from the
 277  *  radio transceiver. This way it is possible for the end user to poll the flag
 278  *  for new event occurances.
 279  */
 280 //uint8_t
 281 //hal_get_pll_lock_flag(void)
 282 //{
 283 //    return hal_pll_lock_flag;
 284 //}
 285
 286 /*----------------------------------------------------------------------------*/
 287 /** \brief  This function clears the PLL_LOCK flag.
 288  */
 289 //void
 290 //hal_clear_pll_lock_flag(void)
 291 //{
 292 //    AVR_ENTER_CRITICAL_REGION();
 293 //    hal_pll_lock_flag = 0;
 294 //    AVR_LEAVE_CRITICAL_REGION();
 295 //}
 296
 297 /*----------------------------------------------------------------------------*/
 298 /** \brief  This function reads data from one of the radio transceiver's registers.
 299  *
 300  *  \param  address Register address to read from. See datasheet for register
 301  *                  map.
 302  *
 303  *  \see Look at the at86rf230_registermap.h file for register address definitions.
 304  *
 305  *  \returns The actual value of the read register.
 306  */
 307 uint8_t
 308 hal_register_read(uint8_t address)
 309 {
 310     /* Add the register read command to the register address. */
 311     address &= HAL_TRX_CMD_RADDRM;
 312     address |= HAL_TRX_CMD_RR;
 313
 314     uint8_t register_value = 0;
 315
 316     AVR_ENTER_CRITICAL_REGION();
 317
 318     HAL_SS_LOW(); /* Start the SPI transaction by pulling the Slave Select low. */
 319
 320     /*Send Register address and read register content.*/
 321     SPDR = address;
 322     while ((SPSR & (1 << SPIF)) == 0) {;}
 323     register_value = SPDR;
 324
 325     SPDR = register_value;
 326     while ((SPSR & (1 << SPIF)) == 0) {;}
 327     register_value = SPDR;
 328
 329     HAL_SS_HIGH(); /* End the transaction by pulling the Slave Select High. */
 330
 331     AVR_LEAVE_CRITICAL_REGION();
 332
 333     return register_value;
 334 }
 335
 336 /*----------------------------------------------------------------------------*/
 337 /** \brief  This function writes a new value to one of the radio transceiver's
 338  *          registers.
 339  *
 340  *  \see Look at the at86rf230_registermap.h file for register address definitions.
 341  *
 342  *  \param  address Address of register to write.
 343  *  \param  value   Value to write.
 344  */
 345 void
 346 hal_register_write(uint8_t address, uint8_t value)
 347 {
 348     /* Add the Register Write command to the address. */
 349     address = HAL_TRX_CMD_RW | (HAL_TRX_CMD_RADDRM & address);
 350
 351     AVR_ENTER_CRITICAL_REGION();
 352
 353     HAL_SS_LOW(); /* Start the SPI transaction by pulling the Slave Select low. */
 354
 355     /*Send Register address and write register content.*/
 356     SPDR = address;
 357     while ((SPSR & (1 << SPIF)) == 0) {;}
 358     uint8_t dummy_read = SPDR;
 359
 360     SPDR = value;
 361     while ((SPSR & (1 << SPIF)) == 0) {;}
 362     dummy_read = SPDR;
 363
 364     HAL_SS_HIGH(); /* End the transaction by pulling the Slave Slect High. */
 365
 366     AVR_LEAVE_CRITICAL_REGION();
 367 }
 368
 369 /*----------------------------------------------------------------------------*/
 370 /** \brief  This function reads the value of a specific subregister.
 371  *
 372  *  \see Look at the at86rf230_registermap.h file for register and subregister
 373  *       definitions.
 374  *
 375  *  \param  address  Main register's address.
 376  *  \param  mask  Bit mask of the subregister.
 377  *  \param  position   Bit position of the subregister
 378  *  \retval Value of the read subregister.
 379  */
 380 uint8_t
 381 hal_subregister_read(uint8_t address, uint8_t mask, uint8_t position)
 382 {
 383     /* Read current register value and mask out subregister. */
 384     uint8_t register_value = hal_register_read(address);
 385     register_value &= mask;
 386     register_value >>= position; /* Align subregister value. */
 387
 388     return register_value;
 389 }
 390
 391 /*----------------------------------------------------------------------------*/
 392 /** \brief  This function writes a new value to one of the radio transceiver's
 393  *          subregisters.
 394  *
 395  *  \see Look at the at86rf230_registermap.h file for register and subregister
 396  *       definitions.
 397  *
 398  *  \param  address  Main register's address.
 399  *  \param  mask  Bit mask of the subregister.
 400  *  \param  position  Bit position of the subregister
 401  *  \param  value  Value to write into the subregister.
 402  */
 403 void
 404 hal_subregister_write(uint8_t address, uint8_t mask, uint8_t position,
 405                             uint8_t value)
 406 {
 407     /* Read current register value and mask area outside the subregister. */
 408     uint8_t register_value = hal_register_read(address);
 409     register_value &= ~mask;
 410
 411     /* Start preparing the new subregister value. shift in place and mask. */
 412     value <<= position;
 413     value &= mask;
 414
 415     value |= register_value; /* Set the new subregister value. */
 416
 417     /* Write the modified register value. */
 418     hal_register_write(address, value);
 419 }
 420
 421 /*----------------------------------------------------------------------------*/
 422 /** \brief  This function will upload a frame from the radio transceiver's frame
 423  *          buffer.
 424  *
 425  *          If the frame currently available in the radio transceiver's frame buffer
 426  *          is out of the defined bounds. Then the frame length, lqi value and crc
 427  *          be set to zero. This is done to indicate an error.
 428  *          This version is optimized for use with contiki RF230BB driver
 429  *
 430  *  \param  rx_frame    Pointer to the data structure where the frame is stored.
 431  *  \param  rx_callback Pointer to callback function for receiving one byte at a time.
 432  */
 433 void
 434 hal_frame_read(hal_rx_frame_t *rx_frame, rx_callback_t rx_callback)
 435 {
 436     uint8_t *rx_data=0;
 437
 438     /*  check that we have either valid frame pointer or callback pointer */
 439 //  if (!rx_frame && !rx_callback)
 440 //      return;
 441
 442     AVR_ENTER_CRITICAL_REGION();
 443
 444     HAL_SS_LOW();
 445
 446     /*Send frame read command.*/
 447     SPDR = HAL_TRX_CMD_FR;
 448     while ((SPSR & (1 << SPIF)) == 0) {;}
 449     uint8_t frame_length = SPDR;
 450
 451     /*Read frame length.*/
 452     SPDR = frame_length;
 453     while ((SPSR & (1 << SPIF)) == 0) {;}
 454     frame_length = SPDR;
 455
 456     /*Check for correct frame length.*/
 457     if ((frame_length >= HAL_MIN_FRAME_LENGTH) && (frame_length <= HAL_MAX_FRAME_LENGTH)){
 458         uint16_t crc = 0;
 459 //      if (rx_frame){
 460             rx_data = (rx_frame->data);
 461             rx_frame->length = frame_length;
 462 //      } else {
 463 //          rx_callback(frame_length);
 464 //      }
 465         /*Upload frame buffer to data pointer. Calculate CRC.*/
 466         SPDR = frame_length;
 467         while ((SPSR & (1 << SPIF)) == 0) {;}
 468
 469         do{
 470             uint8_t tempData = SPDR;
 471             SPDR = 0;       /*  dummy write */
 472
 473 //           if (rx_frame){
 474                 *rx_data++ = tempData;
 475 //          } else {
 476 //              rx_callback(tempData);
 477 //          }
 478
 479             crc = _crc_ccitt_update(crc, tempData);
 480
 481             while ((SPSR & (1 << SPIF)) == 0) {;}
 482
 483         } while (--frame_length > 0);
 484
 485         /*Read LQI value for this frame.*/
 486 //      if (rx_frame){
 487             rx_frame->lqi = SPDR;
 488 //      } else {
 489 //          rx_callback(SPDR);
 490 //      }
 491
 492         HAL_SS_HIGH();
 493
 494         /*Check calculated crc, and set crc field in hal_rx_frame_t accordingly.*/
 495 //      if (rx_frame){
 496             rx_frame->crc = (crc == HAL_CALCULATED_CRC_OK);
 497 //      } else {
 498 //          rx_callback(crc != HAL_CALCULATED_CRC_OK);
 499 //      }
 500     } else {
 501         HAL_SS_HIGH();
 502
 503 //      if (rx_frame){
 504             rx_frame->length = 0;
 505             rx_frame->lqi    = 0;
 506             rx_frame->crc    = false;
 507 //      }
 508     }
 509
 510     AVR_LEAVE_CRITICAL_REGION();
 511 }
 512
 513 /*----------------------------------------------------------------------------*/
 514 /** \brief  This function will download a frame to the radio transceiver's frame
 515  *          buffer.
 516  *
 517  *  \param  write_buffer    Pointer to data that is to be written to frame buffer.
 518  *  \param  length          Length of data. The maximum length is 127 bytes.
 519  */
 520 void
 521 hal_frame_write(uint8_t *write_buffer, uint8_t length)
 522 {
 523     length &= HAL_TRX_CMD_RADDRM; /* Truncate length to maximum frame length. */
 524
 525     AVR_ENTER_CRITICAL_REGION();
 526
 527     HAL_SS_LOW(); /* Initiate the SPI transaction. */
 528
 529     /*SEND FRAME WRITE COMMAND AND FRAME LENGTH.*/
 530     SPDR = HAL_TRX_CMD_FW;
 531     while ((SPSR & (1 << SPIF)) == 0) {;}
 532     uint8_t dummy_read = SPDR;
 533
 534     SPDR = length;
 535     while ((SPSR & (1 << SPIF)) == 0) {;}
 536     dummy_read = SPDR;
 537
 538     /* Download to the Frame Buffer. */
 539     do{
 540         SPDR = *write_buffer++;
 541         --length;
 542
 543         while ((SPSR & (1 << SPIF)) == 0) {;}
 544
 545         dummy_read = SPDR;
 546     } while (length > 0);
 547
 548     HAL_SS_HIGH(); /* Terminate SPI transaction. */
 549
 550     AVR_LEAVE_CRITICAL_REGION();
 551 }
 552
 553 /*----------------------------------------------------------------------------*/
 554 /** \brief Read SRAM
 555  *
 556  * This function reads from the SRAM of the radio transceiver.
 557  *
 558  * \param address Address in the TRX's SRAM where the read burst should start
 559  * \param length Length of the read burst
 560  * \param data Pointer to buffer where data is stored.
 561  */
 562 //void
 563 //hal_sram_read(uint8_t address, uint8_t length, uint8_t *data)
 564 //{
 565 //    AVR_ENTER_CRITICAL_REGION();
 566
 567 //    HAL_SS_LOW(); /* Initiate the SPI transaction. */
 568
 569     /*Send SRAM read command.*/
 570 //    SPDR = HAL_TRX_CMD_SR;
 571 //    while ((SPSR & (1 << SPIF)) == 0) {;}
 572 //    uint8_t dummy_read = SPDR;
 573
 574     /*Send address where to start reading.*/
 575 //    SPDR = address;
 576 //    while ((SPSR & (1 << SPIF)) == 0) {;}
 577
 578 //    dummy_read = SPDR;
 579
 580     /*Upload the chosen memory area.*/
 581 //    do{
 582 //        SPDR = HAL_DUMMY_READ;
 583 //        while ((SPSR & (1 << SPIF)) == 0) {;}
 584 //        *data++ = SPDR;
 585 //    } while (--length > 0);
 586
 587 //    HAL_SS_HIGH();
 588
 589 //    AVR_LEAVE_CRITICAL_REGION();
 590 //}
 591
 592 /*----------------------------------------------------------------------------*/
 593 /** \brief Write SRAM
 594  *
 595  * This function writes into the SRAM of the radio transceiver.
 596  *
 597  * \param address Address in the TRX's SRAM where the write burst should start
 598  * \param length  Length of the write burst
 599  * \param data    Pointer to an array of bytes that should be written
 600  */
 601 //void
 602 //hal_sram_write(uint8_t address, uint8_t length, uint8_t *data)
 603 //{
 604 //    AVR_ENTER_CRITICAL_REGION();
 605
 606 //    HAL_SS_LOW();
 607
 608     /*Send SRAM write command.*/
 609 //    SPDR = HAL_TRX_CMD_SW;
 610 //    while ((SPSR & (1 << SPIF)) == 0) {;}
 611 //    uint8_t dummy_read = SPDR;
 612
 613     /*Send address where to start writing to.*/
 614 //    SPDR = address;
 615 //    while ((SPSR & (1 << SPIF)) == 0) {;}
 616 //    dummy_read = SPDR;
 617
 618     /*Upload the chosen memory area.*/
 619 //    do{
 620 //        SPDR = *data++;
 621 //        while ((SPSR & (1 << SPIF)) == 0) {;}
 622 //        dummy_read = SPDR;
 623 //    } while (--length > 0);
 624
 625 //    HAL_SS_HIGH();
 626
 627 //    AVR_LEAVE_CRITICAL_REGION();
 628 //}
 629
 630 /*----------------------------------------------------------------------------*/
 631 /* This #if compile switch is used to provide a "standard" function body for the */
 632 /* doxygen documentation. */
 633 #if defined(DOXYGEN)
 634 /** \brief ISR for the radio IRQ line, triggered by the input capture.
 635  *  This is the interrupt service routine for timer1.ICIE1 input capture.
 636  *  It is triggered of a rising edge on the radio transceivers IRQ line.
 637  */
 638 void RADIO_VECT(void);
 639 #else  /* !DOXYGEN */
 640 /* These link to the RF230BB driver in rf230.c */
 641 void rf230_interrupt(void);
 642 extern hal_rx_frame_t rxframe;
 643
 644 #define DEBUG 0
 645 #if DEBUG
 646 volatile int rf230_interrupt_flag=0;
 647 #define INTERRUPTDEBUG(arg) rf230_interrupt_flag=arg
 648 #else
 649 #define INTERRUPTDEBUG(arg)
 650 #endif
 651
 652 ISR(RADIO_VECT)
 653 {
 654     /*The following code reads the current system time. This is done by first
 655       reading the hal_system_time and then adding the 16 LSB directly from the
 656       TCNT1 register.
 657      */
 658     uint32_t isr_timestamp = hal_system_time;
 659     isr_timestamp <<= 16;
 660     isr_timestamp |= TCNT1;
 661     volatile uint8_t state;
 662
 663     INTERRUPTDEBUG(1);
 664
 665     /*Read Interrupt source.*/
 666     HAL_SS_LOW();
 667
 668     /*Send Register address and read register content.*/
 669     SPDR = RG_IRQ_STATUS | HAL_TRX_CMD_RR;
 670
 671     /* This is the second part of the convertion of system time to a 16 us time
 672        base. The division is moved here so we can spend less time waiting for SPI
 673        data.
 674      */
 675     isr_timestamp /= HAL_US_PER_SYMBOL; /* Divide so that we get time in 16us resolution. */
 676     isr_timestamp &= HAL_SYMBOL_MASK;
 677
 678     while ((SPSR & (1 << SPIF)) == 0) {;}
 679     uint8_t interrupt_source = SPDR; /* The interrupt variable is used as a dummy read. */
 680
 681     SPDR = interrupt_source;
 682     while ((SPSR & (1 << SPIF)) == 0) {;}
 683     interrupt_source = SPDR; /* The interrupt source is read. */
 684
 685     HAL_SS_HIGH();
 686
 687     /*Handle the incomming interrupt. Prioritized.*/
 688     if ((interrupt_source & HAL_RX_START_MASK)){
 689            INTERRUPTDEBUG(10);
 690 //       if(rx_start_callback != NULL){
 691 //            /* Read Frame length and call rx_start callback. */
 692 //            HAL_SS_LOW();
 693
 694 //            SPDR = HAL_TRX_CMD_FR;
 695 //            while ((SPSR & (1 << SPIF)) == 0) {;}
 696 //            uint8_t frame_length = SPDR;
 697
 698 //            SPDR = frame_length; /*  frame_length used for dummy data */
 699 //            while ((SPSR & (1 << SPIF)) == 0) {;}
 700 //            frame_length = SPDR;
 701
 702 //            HAL_SS_HIGH();
 703
 704 //            rx_start_callback(isr_timestamp, frame_length);
 705 //       }
 706     } else if (interrupt_source & HAL_TRX_END_MASK){
 707            INTERRUPTDEBUG(11);
 708 //         if(trx_end_callback != NULL){
 709 //           INTERRUPTDEBUG(12);
 710 //       trx_end_callback(isr_timestamp);
 711 //     }
 712
 713        state = hal_subregister_read(SR_TRX_STATUS);
 714        if((state == BUSY_RX_AACK) || (state == RX_ON) || (state == BUSY_RX) || (state == RX_AACK_ON)){
 715        /* Received packet interrupt */
 716        /* Buffer the frame and call rf230_interrupt to schedule poll for rf230 receive process */
 717 //         if (rxframe.length) break;                   //toss packet if last one not processed yet
 718          INTERRUPTDEBUG(42);
 719          hal_frame_read(&rxframe, NULL);
 720          rf230_interrupt();
 721 //       trx_end_callback(isr_timestamp);
 722        /* Enable reception of next packet */
 723          hal_subregister_write(SR_TRX_CMD, RX_AACK_ON);
 724        }
 725
 726     } else if (interrupt_source & HAL_TRX_UR_MASK){
 727         INTERRUPTDEBUG(13);
 728         ;
 729     } else if (interrupt_source & HAL_PLL_UNLOCK_MASK){
 730         INTERRUPTDEBUG(14);
 731             ;
 732     } else if (interrupt_source & HAL_PLL_LOCK_MASK){
 733         INTERRUPTDEBUG(15);
 734 //      hal_pll_lock_flag++;
 735         ;
 736     } else if (interrupt_source & HAL_BAT_LOW_MASK){
 737         /*  Disable BAT_LOW interrupt to prevent endless interrupts. The interrupt */
 738         /*  will continously be asserted while the supply voltage is less than the */
 739         /*  user-defined voltage threshold. */
 740         uint8_t trx_isr_mask = hal_register_read(RG_IRQ_MASK);
 741         trx_isr_mask &= ~HAL_BAT_LOW_MASK;
 742         hal_register_write(RG_IRQ_MASK, trx_isr_mask);
 743 //      hal_bat_low_flag++; /* Increment BAT_LOW flag. */
 744         INTERRUPTDEBUG(16);
 745         ;
 746      } else {
 747         INTERRUPTDEBUG(99);
 748             ;
 749     }
 750 }
 751 #   endif /* defined(DOXYGEN) */
 752
 753 /*----------------------------------------------------------------------------*/
 754 /* This #if compile switch is used to provide a "standard" function body for the */
 755 /* doxygen documentation. */
 756 #if defined(DOXYGEN)
 757 /** \brief Timer Overflow ISR
 758  * This is the interrupt service routine for timer1 overflow.
 759  */
 760 void TIMER1_OVF_vect(void);
 761 #else  /* !DOXYGEN */
 762 ISR(TIMER1_OVF_vect)
 763 {
 764     hal_system_time++;
 765 }
 766 #endif
 767
 768 /** @} */
 769 /** @} */
 770
 771 /*EOF*/