flex.h

// Copyright (c) 2024, Myriota Pty Ltd, All Rights Reserved
// SPDX-License-Identifier: BSD-3-Clause-Attribution
// This file is licensed under the BSD with attribution  (the "License"); you
// may not use these files except in compliance with the License.
//
// You may obtain a copy of the License here:
// LICENSE-BSD-3-Clause-Attribution.txt and at
// https://spdx.org/licenses/BSD-3-Clause-Attribution.html
//
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef FLEX_H
#define FLEX_H
 
#include <stdbool.h>
#include <stdint.h>
#include <time.h>
 
#include "flex_diag_conf.h"
#include "flex_errors.h"


const char *FLEX_VersionString(void);
uint16_t FLEX_VersionMajor(void);
uint16_t FLEX_VersionMinor(void);
uint16_t FLEX_VersionPatch(void);

const char *FLEX_AppVersionString(void);



typedef enum {
  FLEX_ANALOG_IN_VOLTAGE,  
  FLEX_ANALOG_IN_CURRENT   
} FLEX_AnalogInputMode;

int FLEX_AnalogInputInit(const FLEX_AnalogInputMode InputMode);
int FLEX_AnalogInputDeinit(void);
int FLEX_AnalogInputReadCurrent(uint32_t *const pMicroAmps);
int FLEX_AnalogInputReadVoltage(uint32_t *const pMilliVolts);



typedef enum {
  FLEX_POWER_OUT_24V,  
  FLEX_POWER_OUT_12V,  
  FLEX_POWER_OUT_5V    
} FLEX_PowerOut;

int FLEX_PowerOutInit(const FLEX_PowerOut Voltage);
int FLEX_PowerOutDeinit(void);



typedef enum {
  FLEX_LED_ON,   
  FLEX_LED_OFF,  
} FLEX_LEDState;

int FLEX_LEDGreenStateSet(const FLEX_LEDState LEDState);

int FLEX_LEDBlueStateSet(const FLEX_LEDState LEDState);



typedef enum {
  FLEX_HANDLER_MODIFY_ADD,     
  FLEX_HANDLER_MODIFY_REMOVE,  
} FLEX_HandlerModifyAction;



typedef enum {
  FLEX_EXT_DIGITAL_IO_1,  
  FLEX_EXT_DIGITAL_IO_2   
} FLEX_DigitalIOPin;

typedef enum {
  FLEX_EXT_DIGITAL_IO_LOW = 0,  
  FLEX_EXT_DIGITAL_IO_HIGH      
} FLEX_DigitalIOLevel;

int FLEX_ExtDigitalIOSet(const FLEX_DigitalIOPin PinNum, const FLEX_DigitalIOLevel Level);
int FLEX_ExtDigitalIOGet(const FLEX_DigitalIOPin PinNum);

typedef enum {
  FLEX_EXT_DIGITAL_IO_WAKEUP_ENABLE,   
  FLEX_EXT_DIGITAL_IO_WAKEUP_DISABLE,  
} FLEX_ExtDigitalIOWakeupModifyAction;

int FLEX_ExtDigitalIOWakeupModify(const FLEX_DigitalIOPin PinNum,
  const FLEX_ExtDigitalIOWakeupModifyAction Action);

typedef void (*FLEX_IOWakeupHandler)(void);

int FLEX_ExtDigitalIOWakeupHandlerModify(const FLEX_IOWakeupHandler Handler,
  const FLEX_HandlerModifyAction Action);



int FLEX_ExtI2CWrite(int Address, const uint8_t *const TxData, uint16_t TxLength);

int FLEX_ExtI2CRead(int Address, const uint8_t *const TxData, uint16_t TxLength,
  uint8_t *const RxData, uint16_t RxLength);



typedef enum {
  FLEX_SERIAL_PROTOCOL_RS485,  
  FLEX_SERIAL_PROTOCOL_RS232,  
} FLEX_SerialProtocol;

typedef enum {
  FLEX_SERIAL_PARITY_NONE,  
  FLEX_SERIAL_PARITY_EVEN,  
  FLEX_SERIAL_PARITY_ODD,   
} FLEX_SerialParity;

typedef enum {
  FLEX_SERIAL_DATABITS_EIGHT,  
  FLEX_SERIAL_DATABITS_NINE,   
} FLEX_SerialDatabits;

typedef enum {
  FLEX_SERIAL_STOPBITS_ONE,         
  FLEX_SERIAL_STOPBITS_HALF,        
  FLEX_SERIAL_STOPBITS_ONEANDHALF,  
  FLEX_SERIAL_STOPBITS_TWO,         
} FLEX_SerialStopbits;

typedef struct {
  FLEX_SerialProtocol protocol;  
  uint32_t baud_rate;            
  FLEX_SerialParity parity;      
  FLEX_SerialDatabits databits;  
  FLEX_SerialStopbits stopbits;  
} FLEX_SerialExOptions;

int FLEX_SerialInit(FLEX_SerialProtocol Protocol, uint32_t BaudRate);
int FLEX_SerialInitEx(const FLEX_SerialExOptions Options);
int FLEX_SerialWrite(const uint8_t *Tx, size_t Length);
int FLEX_SerialRead(uint8_t *Rx, size_t Length);
int FLEX_SerialDeinit(void);



typedef enum {
  FLEX_PCNT_DEFAULT_OPTIONS = 0,    
  FLEX_PCNT_EDGE_FALLING = 1 << 0,  
  FLEX_PCNT_DEBOUNCE_DISABLE =
    1 << 1,  
  FLEX_PCNT_PULL_UP
    __attribute__((deprecated)),  
} FLEX_PulseCounterOption;

int FLEX_PulseCounterInit(const uint32_t Limit, const uint32_t Options);
uint64_t FLEX_PulseCounterGet(void);
void FLEX_PulseCounterDeinit(void);

typedef void (*FLEX_PCNTWakeupHandler)(void);

int FLEX_PulseCounterHandlerModify(const FLEX_PCNTWakeupHandler Handler,
  const FLEX_HandlerModifyAction Action);



void FLEX_DelayMs(const uint32_t mSec);
void FLEX_DelayUs(const uint32_t uSec);
void FLEX_Sleep(const uint32_t Sec);



int FLEX_GNSSFix(int32_t *const Lat, int32_t *const Lon, time_t *const Time);

bool FLEX_GNSSHasValidFix(void);

void FLEX_LastLocationAndLastFixTime(int32_t *const LastLatitude, int32_t *const LastLongitude,
  time_t *const LastFixTime);

time_t FLEX_TimeGet(void);



typedef enum {
  FLEX_MSG_TRANSMIT_PENDING,   
  FLEX_MSG_TRANSMIT_ONGOING,   
  FLEX_MSG_TRANSMIT_COMPLETE,  
  FLEX_MSG_TRANSMIT_EXPIRED,   
} FLEX_MessageTransmitStatus;

typedef struct {
  uint16_t id;                        
  FLEX_MessageTransmitStatus status;  
} FLEX_MessageStatus;

int FLEX_MessageSchedule(const uint8_t *const Message, const size_t MessageSize);
int FLEX_MessageSlotsFree(void);
size_t FLEX_MessageBytesFree(void);
void FLEX_MessageSave(void);
void FLEX_MessageQueueClear(void);
int FLEX_MessageSlotsMax(void);
int FLEX_MessageQueueStatus(FLEX_MessageStatus *Status, const int StatusCount);
int FLEX_MessageQueueDelete(const uint16_t MessageID);



typedef void (*FLEX_MessageReceiveHandler)(uint8_t *const message, const int size);

int FLEX_MessageReceiveHandlerModify(const FLEX_MessageReceiveHandler Handler,
  const FLEX_HandlerModifyAction Action);



typedef time_t (*FLEX_ScheduledJob)(void);
int FLEX_JobSchedule(const FLEX_ScheduledJob Job, const time_t Time);

time_t FLEX_ASAP(void);
time_t FLEX_Never(void);
time_t FLEX_SecondsFromNow(const unsigned Secs);
time_t FLEX_MinutesFromNow(const unsigned Mins);
time_t FLEX_HoursFromNow(const unsigned Hours);
time_t FLEX_DaysFromNow(const unsigned Days);



const char *FLEX_ModuleIDGet(void);

const char *FLEX_RegistrationCodeGet(void);



int FLEX_TemperatureGet(float *const Temperature);



int FLEX_HWTest(void);



uint32_t FLEX_TickGet(void);



int FLEX_GetBatteryVoltage(int32_t *const VoltageMilliVolts);
 
// Reads if FlexSense is running on external power or battery power.
int FLEX_IsOnExternalPower(bool *const IsOnExternalPower);

typedef void (*FLEX_OnExternalPowerHandler)(const bool *const IsOnExternalPower);

void FLEX_OnExternalPowerHandlerSet(const FLEX_OnExternalPowerHandler Handler);

 
#endif /* FLEX_H */