cs_Crownstone.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: Apr 24, 2015
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
#pragma once
 
 
#include <behaviour/cs_BehaviourStore.h>
#include <ble/cs_Advertiser.h>
#include <ble/cs_BleCentral.h>
#include <ble/cs_CrownstoneCentral.h>
#include <ble/cs_Stack.h>
#include <ble/cs_iBeacon.h>
#include <cfg/cs_Boards.h>
#include <events/cs_EventListener.h>
#include <localisation/cs_AssetFiltering.h>
#include <localisation/cs_MeshTopology.h>
#include <presence/cs_PresenceHandler.h>
#include <processing/cs_CommandAdvHandler.h>
#include <processing/cs_CommandHandler.h>
#include <processing/cs_FactoryReset.h>
#include <processing/cs_MultiSwitchHandler.h>
#include <processing/cs_PowerSampling.h>
#include <processing/cs_Scanner.h>
#include <processing/cs_TemperatureGuard.h>
#include <services/cs_CrownstoneService.h>
#include <services/cs_DeviceInformationService.h>
#include <services/cs_SetupService.h>
#include <storage/cs_State.h>
#include <switch/cs_SwitchAggregator.h>
#include <time/cs_SystemTime.h>
#include <tracking/cs_TrackedDevices.h>
#include <test/cs_TestAccess.h>
 
#if BUILD_MESHING == 1
#include <mesh/cs_Mesh.h>
#endif
 
#if BUILD_MICROAPP_SUPPORT == 1
#include <microapp/cs_Microapp.h>
#endif
 
#if BUILD_MEM_USAGE_TEST == 1
#include <test/cs_MemUsageTest.h>
#endif
 
#if BUILD_TWI == 1
#include <drivers/cs_Twi.h>
#endif
 
#if BUILD_GPIOTE == 1
#include <drivers/cs_Gpio.h>
#endif
 
class Crownstone : public EventListener, public Component {
    friend class TestAccess<Crownstone>;
public:
    enum ServiceEvent {
        CREATE_DEVICE_INFO_SERVICE,
        CREATE_SETUP_SERVICE,
        CREATE_CROWNSTONE_SERVICE,
        REMOVE_DEVICE_INFO_SERVICE,
        REMOVE_SETUP_SERVICE,
        REMOVE_CROWNSTONE_SERVICE
    };
 
    Crownstone(boards_config_t& board);
 
    void init(uint16_t step);
 
    void startUp();
 
    void run();
 
    void handleEvent(event_t& event);
 
    static void updateHeapStats();
 
    static void updateMinStackEnd();
 
    static void printLoadStats();
 
    static void staticTick(Crownstone* ptr) { ptr->tick(); }
 
protected:
    std::vector<Component*> getChildren() override;
 
private:
    void init0();
    void init1();
 
    void initDrivers0();
 
    void initDrivers1();
 
    void configure();
 
    void configureAdvertisement();
 
    void setName();
 
    void createService(const ServiceEvent event);
 
    void createSetupServices();
 
    void createCrownstoneServices();
 
    void startOperationMode(const OperationMode& mode);
 
    void switchMode(const OperationMode& mode);
 
    void tick();
 
    void scheduleNextTick();
 
    void increaseResetCounter();
 
    // Keep the board config in memory, so other classes can store a pointer to it.
    boards_config_t _boardsConfig;
 
    // drivers
    Stack* _stack;
    BleCentral* _bleCentral;
    CrownstoneCentral* _crownstoneCentral;
    Advertiser* _advertiser;
    Timer* _timer;
    Storage* _storage;
    State* _state;
 
    TemperatureGuard* _temperatureGuard                 = nullptr;
    PowerSampling* _powerSampler                        = nullptr;
 
    // services
    DeviceInformationService* _deviceInformationService = nullptr;
    CrownstoneService* _crownstoneService               = nullptr;
    SetupService* _setupService                         = nullptr;
 
    // advertise
    ServiceData* _serviceData                           = nullptr;
 
    // processing
#if BUILD_MESHING == 1
    Mesh* _mesh = nullptr;
#endif
    CommandHandler* _commandHandler         = nullptr;
    Scanner* _scanner                       = nullptr;
    FactoryReset* _factoryReset             = nullptr;
    CommandAdvHandler* _commandAdvHandler   = nullptr;
    MultiSwitchHandler* _multiSwitchHandler = nullptr;
    SystemTime _systemTime;
 
    SwitchAggregator _switchAggregator;
 
    // TODO: allocate and init only in normal mode.
    TrackedDevices _trackedDevices;
    MeshTopology _meshTopology;
    AssetFiltering _assetFiltering;
    BehaviourStore _behaviourStore;
    PresenceHandler _presenceHandler;
 
#if BUILD_MICROAPP_SUPPORT == 1
    Microapp* _microapp;
#endif
 
#if BUILD_MEM_USAGE_TEST == 1
    MemUsageTest _memTest;
#endif
 
#if BUILD_TWI == 1
    Twi* _twi = nullptr;
#endif
 
#if BUILD_GPIOTE == 1
    Gpio* _gpio = nullptr;
#endif
 
    app_timer_t _mainTimerData;
    app_timer_id_t _mainTimerId;
    TYPIFY(EVT_TICK) _tickCount = 0;
 
    OperationMode _operationMode;
    OperationMode _oldOperationMode = OperationMode::OPERATION_MODE_UNINITIALIZED;
 
    uint32_t _gpregret[2]           = {0};
 
    uint32_t _resetReason           = 0;
 
    static cs_ram_stats_t _ramStats;
 
    bool _setStateValuesAfterStorageRecover = false;
 
    bool _clearedGpRegRetCount              = false;
};