CC120x digital temperature readout

//******************************************************************************
//! @file       cc120x_easy_link_rx.c
//! @brief      This program sets up an easy link between two trxEB's with
//!             CC112x EM's connected.
//!             The program can take any recomended register settings exported
//!             from SmartRF Studio 7 without any modification with exeption
//!             from the assumtions decribed below.
//
//              Notes: The following asumptions must be fulfilled for
//              the program to work:
//
//                  1.  GPIO2 has to be set up with GPIO2_CFG = 0x06
//                      PKT_SYNC_RXTX for correct interupt
//                  2.  Packet engine has to be set up with status bytes enabled
//                      PKT_CFG1.APPEND_STATUS = 1
//
//  Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
//
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions
//  are met:
//
//      Redistributions of source code must retain the above copyright
//      notice, this list of conditions and the following disclaimer.
//
//      Redistributions in binary form must reproduce the above copyright
//      notice, this list of conditions and the following disclaimer in the
//      documentation and/or other materials provided with the distribution.
//
//      Neither the name of Texas Instruments Incorporated nor the names of
//      its contributors may be used to endorse or promote products derived
//      from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
//  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
//  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
//  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
//  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
//  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//*****************************************************************************/


/*******************************************************************************
* INCLUDES
*/
#include "msp430.h"
#include "lcd_dogm128_6.h"
#include "hal_spi_rf_trxeb.h"
#include "cc120x_spi.h"
#include "stdlib.h"
#include "cc120x_easy_link_reg_config.h"
#include "bsp.h"
#include "bsp_key.h"
#include "io_pin_int.h"
#include "bsp_led.h"


/*******************************************************************************
* DEFINES
*/
#define ISR_ACTION_REQUIRED 1
#define ISR_IDLE            0
#define RX_FIFO_ERROR       0x11

#define GPIO3               0x04
#define GPIO2               0x08
#define GPIO0               0x80


/*******************************************************************************
* LOCAL VARIABLES
*/
//static uint8  packetSemaphore;
static uint32 packetCounter = 0;

/******************************************************************************
* LOCAL VARIABLES
*/
static uint32 ADCValue_I = 0;
static uint32 ADCValue_Q = 0;
/*******************************************************************************
* STATIC FUNCTIONS
*/
static void initMCU(void);
static void registerConfig(void);
static void runRX(void);
static void run_MARC_debug(void);
static void radioRxISR(void);
static void updateLcd(void);
static void halMcuWaitUs(uint16 usec);
static void halMcuWaitMs(uint16 msec);


/*******************************************************************************
*   @fn         main
*
*   @brief      Runs the main routine
*
*   @param      none
*
*   @return     none
*/
void main(void){
  uint8 RegValue = 0;
  uint8 marcState;
  // Initialize MCU and peripherals
  initMCU();
  
  // Write radio registers
  registerConfig();
  
  //Set chip in RX
  trxSpiCmdStrobe(CC120X_SRX);
  
  // Read marcstate to check state
  cc120xSpiReadReg(CC120X_MARCSTATE, &marcState, 1);
  do {
        cc120xSpiReadReg(CC120X_MARCSTATE, &marcState, 1);
    } while (marcState != 0x6D);
  
  // Enter run_MARC_debug, the chip has to be reset to resume normal functionality
  run_MARC_debug();
  
  // Read marcstate to check state
  cc120xSpiReadReg(CC120X_MARCSTATE, &marcState, 1);
  
  while(1){
    
    halMcuWaitMs(1000);
    bspLedSet(BSP_LED_1);
    cc120xSpiReadReg(CC120X_CHFILT_I2, &RegValue, 1);
    ADCValue_I = ((uint32)RegValue) << 16;
    cc120xSpiReadReg(CC120X_CHFILT_I1, &RegValue, 1);
    ADCValue_I |= (((uint32)RegValue) << 8) & 0x0000FF00;
    cc120xSpiReadReg(CC120X_CHFILT_I0, &RegValue, 1);
    ADCValue_I |= (uint32)(RegValue) & 0x000000FF;

    cc120xSpiReadReg(CC120X_CHFILT_Q2, &RegValue, 1);
    ADCValue_Q = ((uint32)RegValue) << 16;
    cc120xSpiReadReg(CC120X_CHFILT_Q1, &RegValue, 1);
    ADCValue_Q |= (((uint32)RegValue) << 8) & 0x0000FF00;
    cc120xSpiReadReg(CC120X_CHFILT_Q0, &RegValue, 1);
    ADCValue_Q |= (uint32)(RegValue) & 0x000000FF;
    
    updateLcd();
    ADCValue_I = 0;
    ADCValue_Q = 0;
    bspLedClear(BSP_LED_1);
  }
}

/******************************************************************************
 * @fn          run_MARC_debug
 *
 * @brief       puts radio in RX and enter MARC debug, turns off the IFAMP
 *                
 * @param       none
 *
 * @return      none
 */
static void run_MARC_debug(void){
  uint8 txBuffer[18] = {0x0F,0x28,0x02,0x90,0x42,0x1B,0x7E,0x1F,0xFE,0xCD,0x06,0x1B,0x0E,0xA1,0x0E,0xA4,0x00,0x3F};
  uint8 writeByte;
 
   
  // Write debug init to tx fifo
  cc120xSpiWriteTxFifo(txBuffer,sizeof(txBuffer));
  // Run code from FIFO
  writeByte=0x01; 
  cc120xSpiWriteReg( CC120X_BIST, &writeByte, 1);
  // Strobe IDLE
  trxSpiCmdStrobe(CC120X_SIDLE); 
  // Set IF AMP in PD
  writeByte=0x1F;
  cc120xSpiWriteReg( CC120X_WOR_EVENT0_LSB, &writeByte, 1);
  // Strobe SXOFF to copy command over
  trxSpiCmdStrobe(CC120X_SXOFF); 
}


/*******************************************************************************
*   @fn         radioRxISR
*
*   @brief      ISR for packet handling in RX. Sets packet semaphore
*               and clears ISR flag
*
*   @param      none
*
*   @return     none
*/
//static void radioRxISR(void) {
//
//    // Set packet semaphore
//    packetSemaphore = ISR_ACTION_REQUIRED;
//
//    // Clear ISR flag
//    ioPinIntClear(IO_PIN_PORT_1, GPIO2);
//}


/*******************************************************************************
*   @fn         initMCU
*
*   @brief      Initialize MCU and board peripherals
*
*   @param      none
*
*   @return     none
*/
static void initMCU(void) {

    // Init clocks and I/O
    bspInit(BSP_SYS_CLK_8MHZ);

    // Init LEDs
    bspLedInit();

    // Init buttons
    bspKeyInit(BSP_KEY_MODE_POLL);

    // Initialize SPI interface to LCD (shared with SPI flash)
    bspIoSpiInit(BSP_FLASH_LCD_SPI, BSP_FLASH_LCD_SPI_SPD);

    // Init LCD
    lcdInit();

    // Instantiate transceiver RF SPI interface to SCLK ~ 4 MHz
    // Input parameter is clockDivider
    // SCLK frequency = SMCLK/clockDivider
    trxRfSpiInterfaceInit(2);

    // Enable global interrupt
    _BIS_SR(GIE);
}


/*******************************************************************************
*   @fn         registerConfig
*
*   @brief      Write register settings as given by SmartRF Studio found in
*               cc120x_easy_link_reg_config.h
*
*   @param      none
*
*   @return     none
*/
static void registerConfig(void) {

    uint8 writeByte;

    // Reset radio
    trxSpiCmdStrobe(CC120X_SRES);

    // Write registers to radio
    for(uint16 i = 0;
        i < (sizeof(preferredSettings)/sizeof(registerSetting_t)); i++) {
        writeByte = preferredSettings[i].data;
        cc120xSpiWriteReg(preferredSettings[i].addr, &writeByte, 1);
    }
}


/*******************************************************************************
*   @fn         updateLcd
*
*   @brief      updates LCD buffer and sends buffer to LCD module
*
*   @param      none
*
*   @return     none
*/
static void updateLcd(void){
  
      // Update LDC buffer and send to screen.
      lcdBufferClear(0);
      lcdBufferPrintString(0, "    Temp test    ", 0, eLcdPage0);     
      lcdBufferPrintInt(0, ADCValue_I, 10, eLcdPage3);
      lcdBufferPrintInt(0, ADCValue_Q, 10, eLcdPage4);
      lcdSendBuffer(0);
}


/***********************************************************************************
* @fn          halMcuWaitUs
*
* @brief       Busy wait function. Waits the specified number of microseconds. Use
*              assumptions about number of clock cycles needed for the various
*              instructions. The duration of one cycle depends on MCLK. In this HAL
*              , it is set to 8 MHz, thus 8 cycles per usec.
*
*              NB! This function is highly dependent on architecture and compiler!
*
* @param       uint16 usec - number of microseconds delay
*
* @return      none
*/

#pragma optimize=none
void halMcuWaitUs(uint16 usec) // 5 cycles for calling
{
    // The least we can wait is 3 usec:
    // ~1 usec for call, 1 for first compare and 1 for return
    while(usec > 3)       // 2 cycles for compare
    {                // 2 cycles for jump
        NOP();       // 1 cycles for nop
        NOP();       // 1 cycles for nop
        NOP();       // 1 cycles for nop
        NOP();       // 1 cycles for nop
        NOP();       // 1 cycles for nop
        NOP();       // 1 cycles for nop
        NOP();       // 1 cycles for nop
        NOP();       // 1 cycles for nop
        usec -= 2;        // 1 cycles for optimized decrement
    }
}                         // 4 cycles for returning

/***********************************************************************************
* @fn          halMcuWaitMs
*
* @brief       Busy wait function. Waits the specified number of milliseconds. Use
*              assumptions about number of clock cycles needed for the various
*              instructions.
*
*              NB! This function is highly dependent on architecture and compiler!
*
* @param       uint16 millisec - number of milliseconds delay
*
* @return      none
*/
#pragma optimize=none
void halMcuWaitMs(uint16 msec)
{
    while(msec-- > 0)
    {
        halMcuWaitUs(1000);
    }
}