arm.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
// Created date: 17.11.2015
// ---------------------------------------------------------------------

/***********************************************************************

 Copyright (c) 2016 ATIM
 
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.

***********************************************************************/

#ifndef ARM_H
#define ARM_H

// ---------------------------------------------------------------------
// Include
// ---------------------------------------------------------------------
#include <stdbool.h>

#include "armconfig.h"
#include "armconst.h"
#include "armport.h"

// ---------------------------------------------------------------------
// Define
// ---------------------------------------------------------------------

#define ARM_FSK_BROADCAST           255

#define ARM_FSK_POWER_AUTO          (-127)

#define ARM_LW_UNCONFIRMED(val)     ((-1)*(val))

#define ARM_LW_IS_UNCONFIRMED(val)  ((val)<=0)

// ---------------------------------------------------------------------
// Enum
// ---------------------------------------------------------------------

typedef enum armError_e
{
    ARM_ERR_NONE,                   
    ARM_ERR_NO_SUPPORTED,           

    ARM_ERR_PORT_OPEN,              
    ARM_ERR_PORT_CONFIG,            
    ARM_ERR_PORT_READ,              
    ARM_ERR_PORT_WRITE,             
    ARM_ERR_PORT_WRITE_READ,        
    ARM_ERR_PORT_CLOSE,             

    ARM_ERR_PARAM_OUT_OF_RANGE,     
    ARM_ERR_PARAM_INCOMPATIBLE,     
    ARM_ERR_ADDRESSING_NOT_ENABLE,  
    ARM_ERR_WOR_ENABLE,             

    ARM_ERR_ARM_GO_AT,              
    ARM_ERR_ARM_BACK_AT,            
    ARM_ERR_ARM_CMD,                
    ARM_ERR_ARM_GET_REG,            
    ARM_ERR_ARM_SET_REG,            
}armError_t;

typedef enum armBaudrate_e
{
    ARM_BAUDRATE_NONE       = 0,        
    ARM_BAUDRATE_1200       = 1200,     
    ARM_BAUDRATE_2400       = 2400,     
    ARM_BAUDRATE_4800       = 4800,     
    ARM_BAUDRATE_9600       = 9600,     
    ARM_BAUDRATE_19200      = 19200,    
    ARM_BAUDRATE_38400      = 38400,    
    ARM_BAUDRATE_57600      = 57600,    
    ARM_BAUDRATE_115200     = 115200,   
}armBaudrate_t;

typedef enum armFskWor_e
{
    ARM_FSK_WOR_DISABLE,    
    ARM_FSK_WOR_LP,         
    ARM_FSK_WOR_CS,         
    ARM_FSK_WOR_PQT         
}armFskWor_t;

typedef enum armLed_e
{
    ARM_LED_OFF,        
    ARM_LED_OFF_RF,     
    ARM_LED_ON_RF       
}armLed_t;

typedef enum armFskLbtAfa_e
{
    ARM_FSK_LBTAFA_DISABLE, 
    ARM_FSK_LBTAFA_LBT,     
    ARM_FSK_LBTAFA_AFA,     
    ARM_FSK_LBTAFA_LBTAFA,  
}armFskLbtAfa_t;

typedef enum armMode_e
{
    ARM_MODE_FSK,               
    ARM_MODE_SFX,       
    ARM_MODE_LORAWAN,       
}armMode_t;

typedef enum armType_e
{
    ARM_TYPE_NONE   = 0x01, 
    ARM_TYPE_N8_LP  = 0x02, 
    ARM_TYPE_N8_LD  = 0x04, 
    ARM_TYPE_N8_LW  = 0x08, 
}armType_t;

// ---------------------------------------------------------------------
// struct
// ---------------------------------------------------------------------

#ifndef __DOXYGEN__

typedef struct uint128_s
{
    uint64_t lsb;
    uint64_t msb;
}uint128_t;

typedef struct armReg_s
{   
    uint8_t reg;    
    uint8_t val;    
    uint8_t newVal; 
}armReg_t;

typedef struct armN8LpLd_s
{
    armReg_t    regsH[_ARM_N8LPLD_REGH_SIZE];
}armN8LpLd_t;

typedef struct armN8Lw_s
{
    armReg_t    regsM[_ARM_N8LW_REGM_SIZE];
    armReg_t    regsO[_ARM_N8LW_REGO_SIZE];
}armN8Lw_t;

typedef struct arm_s
{
    void*       _port;
    armType_t   _type;
    union
    {
        #ifdef ARM_WITH_N8_LPLD
        armN8LpLd_t _N8LPLD;
        #endif
        #ifdef ARM_WITH_N8_LW
        armN8Lw_t   _N8LW;
        #endif
    };
}arm_t;

#endif

// ---------------------------------------------------------------------
// Prototypes functions
// ---------------------------------------------------------------------

armError_t armInit(arm_t* arm, void* port);

armError_t armDeInit(arm_t* arm);

armError_t armReboot(arm_t* arm);

armError_t armInfo(arm_t* arm, armType_t* armType, uint8_t* rev, uint64_t* sn, uint16_t* rfFreq, uint8_t* rfPower);

armError_t armSetMode(arm_t* arm, armMode_t mode);

armMode_t armGetMode(arm_t* arm);

armError_t armSfxEnableDownlink(arm_t* arm, bool enable);

bool armSfxIsEnableDownlink(arm_t* arm);

int8_t armFskMaxPower(uint16_t radioChannel, armBaudrate_t radioBaud);

armError_t armFskSetRadio(arm_t* arm, uint16_t channel, armBaudrate_t baud, int8_t power);

void armFskGetRadio(arm_t* arm, uint16_t* channel, armBaudrate_t* baud, int8_t* power);

armError_t armFskSetRemoteAdd(arm_t* arm, uint8_t add);

uint8_t armFskGetRemoteAdd(arm_t* arm);

armError_t armFskSetLocalAdd(arm_t* arm, uint8_t add);

uint8_t armFskGetLocalAdd(arm_t* arm);

void armFskEnableAddressing(arm_t* arm, bool enable);

bool armFskIsEnableAddressing(arm_t* arm);

void armFskEnableCrc(arm_t* arm, bool enable);

bool armFskIsEnableCrc(arm_t* arm);
 
armError_t armFskEnableInfinityMode(arm_t* arm, bool enable);

bool armFskIsEnableInfinityMode(arm_t* arm);

void armFskEnableWhitening(arm_t *arm, bool enable);

bool armFskIsEnableWhitening(arm_t *arm);

armError_t armSetSerial(arm_t* arm, armPortBaudrate_t baud, armPortDatabits_t databits, armPortParity_t parity, armPortStopbit_t stopbit);

void armGetSerial(arm_t* arm, armPortBaudrate_t* baud, armPortDatabits_t* databits, armPortParity_t* parity, armPortStopbit_t* stopbit);

armError_t armFskSetWorMode(arm_t* arm, armFskWor_t mode, uint16_t periodTime, uint16_t postTime, int8_t rssiLevel, bool filterLongPreamble);

void armFskGetWorMode(arm_t* arm, armFskWor_t* mode, uint16_t* periodTime, uint16_t* postTime, int8_t* rssiLevel, bool* filterLongPreamble);

armError_t armEnableWakeUpUart(arm_t *arm, bool enable);

bool armIsEnableWakeUpUart(arm_t *arm);

#if defined ARMPORT_WITH_nSLEEP || defined __DOXYGEN__

void armSleep(arm_t* arm, bool sleep);
#endif
 
armError_t armFskSetLbtAfaMode(arm_t* arm, armFskLbtAfa_t mode, int8_t rssiLevel, uint16_t nSamples, uint16_t channel2);

void armFskGetLbtAfaMode(arm_t* arm, armFskLbtAfa_t* mode, int8_t* rssiLevel, uint16_t* nSamples, uint16_t* channel2);


armError_t armLwSetRadio(arm_t* arm, uint8_t txChannel, uint8_t power, uint8_t txSf, uint8_t rx2Sf, uint8_t rx2Channel);

void armLwGetRadio(arm_t* arm, uint8_t* txChannel, uint8_t* power, uint8_t* txSf, uint8_t* rx2Sf, uint8_t* rx2Channel);

armError_t armLwSetConfirmedFrame(arm_t* arm, int8_t nbFrame);

int8_t armLwGetConfirmedFrame(arm_t* arm);

void armLwSetPortField(arm_t* arm, uint8_t port);

uint8_t armLwGetPortField(arm_t* arm);

void armLwEnableOtaa(arm_t* arm, bool enable);

bool armLwIsEnableOtaa(arm_t* arm);

void armLwEnableRxWindows(arm_t* arm, bool enable);

bool armLwIsEnableRxWindows(arm_t* arm);

void armLwEnableTxAdaptiveSpeed(arm_t* arm, bool enable);

bool armLwIsEnableTxAdaptiveSpeed(arm_t* arm);

void armLwEnableDutyCycle(arm_t* arm, bool enable);

bool armLwIsEnableDutyCycle(arm_t* arm);

void armLwEnableTxAdaptiveChannel(arm_t* arm, bool enable);

bool armLwIsEnableTxAdaptiveChannel(arm_t* arm);

void armLwEnableRx2Adaptive(arm_t* arm, bool enable);

bool armLwIsEnableRx2Adaptive(arm_t* arm);

armError_t armLwIds(arm_t* arm,     uint32_t* devAddr,
                                    uint64_t* devEui,
                                    uint64_t* appEui,
                                    uint128_t* appKey,
                                    uint128_t* nwkSKey,
                                    uint128_t* appSKey);
                                    
void armSetLed(arm_t* arm, armLed_t led);

armLed_t armGetLed(arm_t* arm);

armError_t armUpdateConfig(arm_t* arm);

int armSend(arm_t* arm, const void* buf, size_t nbyte);

int armReceive(arm_t* arm, void* buf, size_t nbyte, int timeout);

#endif //ARM_H