RAKSystem.h

Go to the documentation of this file.

#ifndef __RAK_SYSTEM_H__
#define __RAK_STSTEM_H__

#include "WString.h"

#include "sleep.h"
#include "wdt.h"
#include "atcmd.h"
#include "udrv_errno.h"
#include "udrv_system.h"
#include "udrv_serial.h"
#include "udrv_delay.h"
#include "service_mode_cli.h"
#include "service_battery.h"
#include "service_nvm.h"
#ifdef SUPPORT_FS
#include "service_fs.h"
#endif

using namespace std;

/* ATCMD PERMISSION */
typedef enum {
    RAK_ATCMD_PERM_WRITE         = ATCMD_PERM_WRITE,            
    RAK_ATCMD_PERM_READ          = ATCMD_PERM_READ,             
    RAK_ATCMD_PERM_WRITEONCEREAD = ATCMD_PERM_WRITEONCEREAD,    
    RAK_ATCMD_PERM_DISABLE       = ATCMD_PERM_DISABLE,          
} RAK_AT_PERMISSION;

typedef enum {
    RAK_TIMER_0 = TIMER_0,  
    RAK_TIMER_1 = TIMER_1,  
    RAK_TIMER_2 = TIMER_2,  
    RAK_TIMER_3 = TIMER_3,  
    RAK_TIMER_4 = TIMER_4,  
    RAK_TIMER_ID_MAX = TIMER_ID_MAX,    
} RAK_TIMER_ID;

typedef void (*RAK_TIMER_HANDLER) (void *data);

typedef enum {
    RAK_TIMER_ONESHOT = HTMR_ONESHOT,   
    RAK_TIMER_PERIODIC = HTMR_PERIODIC, 
} RAK_TIMER_MODE;

typedef void (*RAK_TASK_HANDLER) (void);

#define CHANGE_ATCMD_PERM(_atcmd_name,_atcmd_perm)                 \
    ATCMD_ITEM(atcmd_queue, atcmd_permission_item UNIQUE_NAME(permissions)) =   \
    {                                       \
    .atcmd_id = _atcmd_name,                \
    .permission = _atcmd_perm,              \
    }

#ifdef SUPPORT_FS

#define RAK_FS_OK                          SERVICE_FS_OK                       
#define RAK_FS_ERR_NOT_MOUNTED             SERVICE_FS_ERR_NOT_MOUNTED          
#define RAK_FS_ERR_FULL                    SERVICE_FS_ERR_FULL                 
#define RAK_FS_ERR_NOT_FOUND               SERVICE_FS_ERR_NOT_FOUND            
#define RAK_FS_ERR_END_OF_OBJECT           SERVICE_FS_ERR_END_OF_OBJECT        
#define RAK_FS_ERR_DELETED                 SERVICE_FS_ERR_DELETED              
#define RAK_FS_ERR_NOT_FINALIZED           SERVICE_FS_ERR_NOT_FINALIZED        
#define RAK_FS_ERR_NOT_INDEX               SERVICE_FS_ERR_NOT_INDEX            
#define RAK_FS_ERR_OUT_OF_FILE_DESCS       SERVICE_FS_ERR_OUT_OF_FILE_DESCS    
#define RAK_FS_ERR_FILE_CLOSED             SERVICE_FS_ERR_FILE_CLOSED          
#define RAK_FS_ERR_FILE_DELETED            SERVICE_FS_ERR_FILE_DELETED         
#define RAK_FS_ERR_BAD_DESCRIPTOR          SERVICE_FS_ERR_BAD_DESCRIPTOR       
#define RAK_FS_ERR_IS_INDEX                SERVICE_FS_ERR_IS_INDEX             
#define RAK_FS_ERR_IS_FREE                 SERVICE_FS_ERR_IS_FREE              
#define RAK_FS_ERR_INDEX_SPAN_MISMATCH     SERVICE_FS_ERR_INDEX_SPAN_MISMATCH  
#define RAK_FS_ERR_DATA_SPAN_MISMATCH      SERVICE_FS_ERR_DATA_SPAN_MISMATCH   
#define RAK_FS_ERR_INDEX_REF_FREE          SERVICE_FS_ERR_INDEX_REF_FREE       
#define RAK_FS_ERR_INDEX_REF_LU            SERVICE_FS_ERR_INDEX_REF_LU         
#define RAK_FS_ERR_INDEX_REF_INVALID       SERVICE_FS_ERR_INDEX_REF_INVALID    
#define RAK_FS_ERR_INDEX_FREE              SERVICE_FS_ERR_INDEX_FREE           
#define RAK_FS_ERR_INDEX_LU                SERVICE_FS_ERR_INDEX_LU             
#define RAK_FS_ERR_INDEX_INVALID           SERVICE_FS_ERR_INDEX_INVALID        
#define RAK_FS_ERR_NOT_WRITABLE            SERVICE_FS_ERR_NOT_WRITABLE         
#define RAK_FS_ERR_NOT_READABLE            SERVICE_FS_ERR_NOT_READABLE         
#define RAK_FS_ERR_CONFLICTING_NAME        SERVICE_FS_ERR_CONFLICTING_NAME     
#define RAK_FS_ERR_NOT_CONFIGURED          SERVICE_FS_ERR_NOT_CONFIGURED       
#define RAK_FS_ERR_NOT_A_FS                SERVICE_FS_ERR_NOT_A_FS             
#define RAK_FS_ERR_MOUNTED                 SERVICE_FS_ERR_MOUNTED              
#define RAK_FS_ERR_ERASE_FAIL              SERVICE_FS_ERR_ERASE_FAIL           
#define RAK_FS_ERR_MAGIC_NOT_POSSIBLE      SERVICE_FS_ERR_MAGIC_NOT_POSSIBLE   
#define RAK_FS_ERR_NO_DELETED_BLOCKS       SERVICE_FS_ERR_NO_DELETED_BLOCKS    
#define RAK_FS_ERR_FILE_EXISTS             SERVICE_FS_ERR_FILE_EXISTS          
#define RAK_FS_ERR_NOT_A_FILE              SERVICE_FS_ERR_NOT_A_FILE           
#define RAK_FS_ERR_RO_NOT_IMPL             SERVICE_FS_ERR_RO_NOT_IMPL          
#define RAK_FS_ERR_RO_ABORTED_OPERATION    SERVICE_FS_ERR_RO_ABORTED_OPERATION 
#define RAK_FS_ERR_PROBE_TOO_FEW_BLOCKS    SERVICE_FS_ERR_PROBE_TOO_FEW_BLOCKS 
#define RAK_FS_ERR_PROBE_NOT_A_FS          SERVICE_FS_ERR_PROBE_NOT_A_FS       
#define RAK_FS_ERR_NAME_TOO_LONG           SERVICE_FS_ERR_NAME_TOO_LONG        
#define RAK_FS_ERR_IX_MAP_UNMAPPED         SERVICE_FS_ERR_IX_MAP_UNMAPPED      
#define RAK_FS_ERR_IX_MAP_MAPPED           SERVICE_FS_ERR_IX_MAP_MAPPED        
#define RAK_FS_ERR_IX_MAP_BAD_RANGE        SERVICE_FS_ERR_IX_MAP_BAD_RANGE     
#define RAK_FS_ERR_SEEK_BOUNDS             SERVICE_FS_ERR_SEEK_BOUNDS          
#define RAK_FS_ERR_INTERNAL                SERVICE_FS_ERR_INTERNAL             
#define RAK_FS_ERR_TEST                    SERVICE_FS_ERR_TEST                 
#define RAK_FS_ERR_CONTINUE                SERVICE_FS_ERR_CONTINUE             


#endif

class RAKSystem {
  public:
    RAKSystem();
    class sleep sleep;
    class lpm lpm;
    class wdt wdt;

    class firmwareVersion {
      private:
        String ver;

      public:
        firmwareVersion();

        String get();
        bool set(String version);
    };

    class cliVersion {
      private:
        String ver;

      public:
        cliVersion();

        String get();
        bool set(String version);
    };

    class apiVersion {
      private:
        String ver;

      public:
        apiVersion();

        const String get();
    };

    class modelId {
      private:
        String id;

      public:
        modelId();

        String get();
        bool set(String model);
    };

    class chipId {
      private:
        String id;

      public:
        chipId();

        const String get();
    };
    
    firmwareVersion firmwareVer;
    firmwareVersion firmwareVersion;
    cliVersion cliVer;
    cliVersion cliVersion;
    apiVersion apiVersion;
    modelId hwModel;
    modelId modelId;
    chipId chipId;

    void reboot();

    void restoreDefault();

    class pword {
      public:
        bool set(char *passwd, uint32_t len);
        bool set(String passwd);

        void lock(void);

        void unlock(void);
    };

    class bat {
      public:
        float get(void);
    };

    class atMode {
      public:
        bool add(char *cmd, char *usage, char *title, PF_handle handle,unsigned int perm = RAK_ATCMD_PERM_WRITE | RAK_ATCMD_PERM_READ);
    };

#ifdef SUPPORT_FS
    class fs {
      public:

        int32_t         ferrno(SERVICE_FS_FILE file);

        int32_t         derrno(SERVICE_FS_DIR dir);

        SERVICE_FS             init(void);

        SERVICE_FS             reset(void);

        int32_t                list(SERVICE_FS fs, SERVICE_FS_DIR *d, SERVICE_FS_DIRENT *entry);

        SERVICE_FS_FILE        open(SERVICE_FS fs, const char* path, uint32_t flags, uint32_t mode);

        int32_t                read(SERVICE_FS fs, SERVICE_FS_FILE file, void* buf, uint32_t len);

        int32_t                write(SERVICE_FS fs, SERVICE_FS_FILE file, void* buf, uint32_t len);

        int32_t                lseek(SERVICE_FS fs, SERVICE_FS_FILE file, int32_t offs, uint32_t whence);

        int32_t                remove(SERVICE_FS fs, const char* path);

        int32_t                fremove(SERVICE_FS fs, SERVICE_FS_FILE file);

        int32_t                stat(SERVICE_FS fs, const char* path, SERVICE_FS_FILE_STAT* stat);

        int32_t                fstat(SERVICE_FS fs, SERVICE_FS_FILE file, SERVICE_FS_FILE_STAT* stat);

        int32_t                flush(SERVICE_FS fs, SERVICE_FS_FILE file);

        int32_t                close(SERVICE_FS fs, SERVICE_FS_FILE file);

        int32_t                rename(SERVICE_FS fs, const char* old_name, const char* new_name);

        int32_t                opendir(SERVICE_FS fs, const char* name, SERVICE_FS_DIR* d);

        int32_t                closedir(SERVICE_FS fs, SERVICE_FS_DIR* d);

        SERVICE_FS_DIRENT*     readdir(SERVICE_FS fs, SERVICE_FS_DIR* d, SERVICE_FS_DIRENT* e);

        int32_t                feof(SERVICE_FS fs, SERVICE_FS_FILE file);

        int32_t                ftell(SERVICE_FS fs, SERVICE_FS_FILE file);
    };
#else
    class flash {
      public:
        bool get(uint32_t offset, uint8_t *buf, uint32_t len);
        bool set(uint32_t offset, uint8_t *buf, uint32_t len);
    };
#endif
    class alias {
      public :
        bool    set(char * buf,uint32_t len);
        bool    get(char * buf,uint32_t len);
    };
    class timer {
      public :
        bool    create(RAK_TIMER_ID id, RAK_TIMER_HANDLER handler, RAK_TIMER_MODE mode);
        bool    start(RAK_TIMER_ID id, uint32_t ms, void *data);
        bool    stop(RAK_TIMER_ID id);
    };
    class scheduler {
      public :
      class task {
        public :
          bool    create(char *name, RAK_TASK_HANDLER handler);
          bool    destroy(char *name);
          bool    destroy(void);
      };
      task task;
    };
    pword pword;
    bat bat;
    atMode atMode;
#ifdef SUPPORT_FS
    fs fs;
#else
    flash flash;
#endif
    alias alias;
    timer timer;
    scheduler scheduler;
};

#endif