Natalia Coria / Mbed 2 deprecated Training-Aug2018-SX1272-X-NUCLEO-IKS01A2_Natalia

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   X_NUCLEO_IKS01A2 driver_mbed_TH02 mbed LoRaWAN-lib-v1_0_1 SX1272Lib

Fork of Training-Aug2018-SX1272-X-NUCLEO-IKS01A2 by Uttam Bhat

app/LoRaApp.cpp

Committer:
ubhat
Date:
2017-04-06
Revision:
0:6cc76d70e2a1
Child:
2:19dd7bfcacf7

File content as of revision 0:6cc76d70e2a1:

/*
 / _____)             _              | |
( (____  _____ ____ _| |_ _____  ____| |__
 \____ \| ___ |    (_   _) ___ |/ ___)  _ \
 _____) ) ____| | | || |_| ____( (___| | | |
(______/|_____)_|_|_| \__)_____)\____)_| |_|
    (C)2015 Semtech

Description: User-defined applications such as GPS, Temp, Accelerometer, LED indications etc.
            Event based actions such as LED blink on Tx, LED toggle on downlink etc

License: Revised BSD License, see LICENSE.TXT file include in the project

Maintainer: Uttam Bhat
*/

#include "LoRaApp.h"

#ifdef USE_IKS01A1_SENSOR
float iks01a1_data;
int32_t Accl_Value[3] = {0};
#endif

#ifdef USE_CAYENNE_LPP
/*
.... Pressure
.... Temperature
.... Humidity
.... Accelerometer
*/
uint8_t maxLPPsize[4] = {4, 4, 3, 8};
#endif

bool VerticalStatus = false;


Application::Application( uint8_t * memptr )
{
    BuffAddr = memptr;
    memset( BuffAddr, 0, LORAWAN_APP_DATA_MAX_SIZE );
    BuffPtr = 0;    
}

Application::~Application( )
{
}

void Application::ApplicationAppendData( uint8_t *pData, uint8_t len )
{
    memcpy( BuffAddr + BuffPtr, pData, len );
    BuffPtr += len;
}

void Application::ApplicationPtrPos( uint8_t ptrPos )
{
    BuffPtr = ptrPos;
}

void Application::ApplicationCall( eAppType App )
{
    switch( App )
    {        
        // Appends 1 Byte to TX buffer
        case AppTemp:
        {    
#ifdef USE_IKS01A1_SENSOR 
                        
            temp_sensor2->GetTemperature(&iks01a1_data);
                                    
            printf("Temp = %f, %d\r\n", iks01a1_data, (int8_t) iks01a1_data);
                               
            if( ( BuffPtr + 1 ) <= LORAWAN_APP_DATA_SIZE )
            {
#ifdef USE_CAYENNE_LPP
                BuffAddr[BuffPtr++] = 0;
                BuffAddr[BuffPtr++] = (int8_t) ( iks01a1_data * 10 );
#else                
                BuffAddr[BuffPtr++] = (int8_t) iks01a1_data;
#endif                
            }
            
#endif            
            break;
        }
        
        // Appends 2 Bytes to TX buffer
        case AppPressr:
        {    
#ifdef USE_IKS01A1_SENSOR 
                        
            pressure_sensor->GetPressure(&iks01a1_data);
                                    
            printf("Pressure = %f, %d\r\n", iks01a1_data, (uint16_t) iks01a1_data);
                               
            if( ( BuffPtr + 2 ) <= LORAWAN_APP_DATA_SIZE )
            {
#ifdef USE_CAYENNE_LPP
                int16_t tmp;
                
                tmp =  (int16_t) ( iks01a1_data * 10 );
                BuffAddr[BuffPtr++] = ( tmp >> 8 ) & 0xFF;
                BuffAddr[BuffPtr++] = ( tmp ) & 0xFF;
#else                
                BuffAddr[BuffPtr++] = ( (int16_t) iks01a1_data >> 8 ) & 0xFF;
                BuffAddr[BuffPtr++] = ( (int16_t) iks01a1_data ) & 0xFF;
#endif                
            }
            
#endif            
            break;
        }
        
        // Appends 2 Bytes to TX buffer
        case AppHumid:
        {    
#ifdef USE_IKS01A1_SENSOR 
                        
            humidity_sensor->GetHumidity(&iks01a1_data);
                                    
            printf("Humidity = %f, %d\r\n", iks01a1_data, (uint8_t) iks01a1_data);
                               
            if( ( BuffPtr + 1 ) <= LORAWAN_APP_DATA_SIZE )
            {
#ifdef USE_CAYENNE_LPP
                BuffAddr[BuffPtr++] = (uint8_t) ( iks01a1_data * 2 );
#else                
                BuffAddr[BuffPtr++] = (int8_t) iks01a1_data;
#endif                
            }
            
#endif            
            break;
        }

        // Appends 1 Byte to TX buffer
        case AppBat:
        {  
            if( ( BuffPtr + 1 ) <= LORAWAN_APP_DATA_SIZE )
            {
                BuffAddr[BuffPtr++] = BoardGetBatteryLevel( );              // Per LoRaWAN spec; 0 = Charging; 1...254 = level, 255 = N/A
            }
            break;
        }

        // Appends incremental values of 1 Byte each to TX buffer until Full
        case AppRamp:
        {
            int32_t i, j;

            // Populate Tx Buffer with increasing byte values starting from 0x00, 0x01, 0x02 ... 
            for( i = BuffPtr, j = 0; i < LORAWAN_APP_DATA_SIZE; i++ )
            {
                BuffAddr[i] = j++;
            }
            BuffPtr = LORAWAN_APP_DATA_SIZE;
            break;
        }

        // Appends 2 Bytes to TX buffer
        case AppAccl:
        {  
#ifdef USE_IKS01A1_SENSOR 
                        
            accelerometer->Get_X_Axes(Accl_Value);
                                    
            printf("X/Y/Z = %d/%d/%d\r\n", Accl_Value[0], Accl_Value[1], Accl_Value[2]);
                               
            if( ( BuffPtr + 6 ) <= LORAWAN_APP_DATA_SIZE )
            {
                BuffAddr[BuffPtr++] = ( (int16_t) Accl_Value[0] >> 8 ) & 0xFF;
                BuffAddr[BuffPtr++] = ( (int16_t) Accl_Value[0] ) & 0xFF; 
                BuffAddr[BuffPtr++] = ( (int16_t) Accl_Value[1] >> 8 ) & 0xFF;
                BuffAddr[BuffPtr++] = ( (int16_t) Accl_Value[1] ) & 0xFF; 
                BuffAddr[BuffPtr++] = ( (int16_t) Accl_Value[2] >> 8 ) & 0xFF;
                BuffAddr[BuffPtr++] = ( (int16_t) Accl_Value[2] ) & 0xFF;                         
            }            
#endif            
            break;
        }       

        case AppPushButton:
        {   
            uint16_t PushButtonCnt;
            uint8_t *p = (uint8_t *) &PushButtonCnt;

            PushButtonCnt = LoRaMacUplinkStatus.UplinkCounter;
                
            memcpy( &BuffAddr[BuffPtr], p, sizeof(uint16_t) );
            
            break;
        }

        default:
        {            
            break;
        }
    }
}

/*
static void OnRedLedTimerEvent( void )
{
    TimerStop( &RedLedTimer.LedTimer );

    if( RedLed == LED_OFF )
    {
        RedLed = LED_ON;
    }
    else
    {
        RedLed = LED_OFF;
    }
}

static void OnYellowLedTimerEvent( void )
{
    TimerStop( &YellowLedTimer.LedTimer );

    if( YellowLed == LED_OFF )
    {
        YellowLed = LED_ON;
    }
    else
    {
        YellowLed = LED_OFF;
    }
}

static void OnGreenLedTimerEvent( void )
{
    TimerStop( &GreenLedTimer.LedTimer );

    if( GreenLed == LED_OFF )
    {
        GreenLed = LED_ON;
    }
    else
    {
        GreenLed = LED_OFF;
    }
}

TimerLed::TimerLed( eLedType led )
{
    switch( led )
    {
        case Red:
        {
            TimerInit( &LedTimer, OnRedLedTimerEvent );
            break;
        }

        case Yellow:
        {
            TimerInit( &LedTimer, OnYellowLedTimerEvent );
            break;
        }

        case Green:
        {
            TimerInit( &LedTimer, OnGreenLedTimerEvent );
            break;
        }
    }
    
}
        
TimerLed::~TimerLed( )
{
}

void BlinkLED( eLedType led, uint32_t time )
{
    switch( led )
    {
        case Red:
        {
            TimerSetValue( &RedLedTimer.LedTimer, time );
            TimerStart( &RedLedTimer.LedTimer );
            RedLed = LED_ON;
            break;
        }

        case Yellow:
        {
            TimerSetValue( &YellowLedTimer.LedTimer, time );
            TimerStart( &YellowLedTimer.LedTimer );
            YellowLed = LED_ON;
            break;
        }

        case Green:
        {
            TimerSetValue( &GreenLedTimer.LedTimer, time );
            TimerStart( &GreenLedTimer.LedTimer );
            GreenLed = LED_ON;
            break;
        }
    }
}

void ToggleLED( eLedType led )
{
    switch( led )
    {
        case Red:
        {
            if( RedLed == LED_OFF )
            {
                RedLed = LED_ON;
            }
            else
            {
                RedLed = LED_OFF;
            }
            break;
        }

        case Yellow:
        {
            if( YellowLed == LED_OFF )
            {
                YellowLed = LED_ON;
            }
            else
            {
                YellowLed = LED_OFF;
            }
            break;
        }

        case Green:
        {
            if( GreenLed == LED_OFF )
            {
                GreenLed = LED_ON;
            }
            else
            {
                GreenLed = LED_OFF;
            }
            break;
        }
    }
}   

void CtrlLED( eLedType led, uint8_t state )
{
    switch( led )
    {
        case Red:
        {
            RedLed = state;
            break;
        }

        case Yellow:
        {
            YellowLed = state;
            break;
        }

        case Green:
        {
            GreenLed = state;
            break;
        }

        case Usr:
        {
            if( state )
            {
                UsrLed = LED_ON;
            }
            else
            {
                UsrLed = LED_OFF;
            }
            break;
        }
    }
}
*/
void CheckOrientation( void )
{
    /*
    uint8_t statusReg; 
    
    // Read the PS_STATUS register
    statusReg = Mma8451q.read_single( MMA8451_PL_STATUS );

     // If Orientation of the Mote changed then populate Upper Nibble of 0th Byte of Tx Buffer                       
    if( ( statusReg & 0x40 ) != 0 )
    {           
        CtrlLED( Green, LED_OFF );
        VerticalStatus = false; // horizontal
    }
    else
    {        
        CtrlLED( Green, LED_ON );
        VerticalStatus = true; // vertical
    } 
    */      
}