MySensorsCore.h

Go to the documentation of this file.

/*
 * The MySensors Arduino library handles the wireless radio link and protocol
 * between your home built sensors/actuators and HA controller of choice.
 * The sensors forms a self healing radio network with optional repeaters. Each
 * repeater and gateway builds a routing tables in EEPROM which keeps track of the
 * network topology allowing messages to be routed to nodes.
 *
 * Created by Henrik Ekblad <[email protected]>
 * Copyright (C) 2013-2019 Sensnology AB
 * Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
 *
 * Documentation: http://www.mysensors.org
 * Support Forum: http://forum.mysensors.org
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 */
 
#ifndef MySensorsCore_h
#define MySensorsCore_h
 
#include "Version.h"
#include "MyConfig.h"
#include "MyEepromAddresses.h"
#include "MyMessage.h"
#include <stddef.h>
#include <stdarg.h>
 
#define GATEWAY_ADDRESS                 ((uint8_t)0)        
#define NODE_SENSOR_ID                  ((uint8_t)255)  
#define MY_CORE_VERSION                 ((uint8_t)2)        
#define MY_CORE_MIN_VERSION         ((uint8_t)2)        
 
#define MY_WAKE_UP_BY_TIMER         ((int8_t)-1)        
#define MY_SLEEP_NOT_POSSIBLE       ((int8_t)-2)        
#define INTERRUPT_NOT_DEFINED       ((uint8_t)255)  
#define MODE_NOT_DEFINED                ((uint8_t)255)  
#define VALUE_NOT_DEFINED               ((uint8_t)255)  
#define FUNCTION_NOT_SUPPORTED  ((uint16_t)0)       
 
 
typedef struct {
    uint8_t isMetric;                           
} controllerConfig_t;
 
typedef struct {
    controllerConfig_t controllerConfig;    
    // 8 bit
    bool nodeRegistered : 1;                
    bool presentationSent : 1;              
    uint8_t reserved : 6;                   
} coreConfig_t;
 
 
// **** public functions ********
 
uint8_t getNodeId(void);
 
uint8_t getParentNodeId(void);
 
void presentNode(void);
 
bool present(const uint8_t sensorId, const mysensors_sensor_t sensorType,
             const char *description = "",
             const bool requestEcho = false);
#if !defined(__linux__)
bool present(const uint8_t childSensorId, const mysensors_sensor_t sensorType,
             const __FlashStringHelper *description,
             const bool requestEcho = false);
#endif
 
bool sendSketchInfo(const char *name, const char *version, const bool requestEcho = false);
#if !defined(__linux__)
bool sendSketchInfo(const __FlashStringHelper *name, const __FlashStringHelper *version,
                    const bool requestEcho = false);
#endif
 
bool send(MyMessage &msg, const bool requestEcho = false);
 
bool sendBatteryLevel(const uint8_t level, const bool requestEcho = false);
 
bool sendHeartbeat(const bool requestEcho = false);
 
bool sendSignalStrength(const int16_t level, const bool requestEcho = false);
 
bool sendTXPowerLevel(const uint8_t level, const bool requestEcho = false);
 
bool request(const uint8_t childSensorId, const uint8_t variableType,
             const uint8_t destination = GATEWAY_ADDRESS);
 
bool requestTime(const bool requestEcho = false);
 
controllerConfig_t getControllerConfig(void);
 
void saveState(const uint8_t pos, const uint8_t value);
 
uint8_t loadState(const uint8_t pos);
 
void wait(const uint32_t waitingMS);
 
bool wait(const uint32_t waitingMS, const mysensors_command_t cmd);
 
bool wait(const uint32_t waitingMS, const mysensors_command_t cmd, const uint8_t msgtype);
 
void doYield(void);
 
 
int8_t sleep(const uint32_t sleepingMS, const bool smartSleep = false);
 
int8_t sleep(const uint8_t interrupt, const uint8_t mode, const uint32_t sleepingMS = 0,
             const bool smartSleep = false);
 
int8_t sleep(const uint8_t interrupt1, const uint8_t mode1, const uint8_t interrupt2,
             const uint8_t mode2, const uint32_t sleepingMS = 0, const bool smartSleep = false);
 
int8_t smartSleep(const uint32_t sleepingMS);
 
int8_t smartSleep(const uint8_t interrupt, const uint8_t mode, const uint32_t sleepingMS = 0);
 
int8_t smartSleep(const uint8_t interrupt1, const uint8_t mode1, const uint8_t interrupt2,
                  const uint8_t mode2, const uint32_t sleepingMS = 0);
 
int8_t _sleep(const uint32_t sleepingMS, const bool smartSleep = false,
              const uint8_t interrupt1 = INTERRUPT_NOT_DEFINED, const uint8_t mode1 = MODE_NOT_DEFINED,
              const uint8_t interrupt2 = INTERRUPT_NOT_DEFINED, const uint8_t mode2 = MODE_NOT_DEFINED);
 
uint32_t getSleepRemaining(void);
 
 
// **** private functions ********
 
void _nodeLock(const char *str);
 
void _checkNodeLock(void); // Node lock group
 
void _begin(void);
void _process(void);
bool _processInternalCoreMessage(void);
void _infiniteLoop(void);
void _registerNode(void);
bool _sendRoute(MyMessage &message);
void receive(const MyMessage&) __attribute__((weak));
void receiveTime(uint32_t) __attribute__((weak));
void presentation(void) __attribute__((weak));
void before(void) __attribute__((weak));
void preHwInit(void) __attribute__((weak));
void setup(void) __attribute__((weak));
void loop(void) __attribute__((weak));
 
 
// Inline function and macros
static inline MyMessage& build(MyMessage &msg, const uint8_t destination, const uint8_t sensor,
                               const mysensors_command_t command, const uint8_t type, const bool requestEcho = false)
{
    msg.setSender(getNodeId());
    msg.setDestination(destination);
    msg.setSensor(sensor);
    msg.setType(type);
    msg.setCommand(command);
    msg.setRequestEcho(requestEcho);
    msg.setEcho(false);
    return msg;
}
 
static inline MyMessage& buildGw(MyMessage &msg, const uint8_t type)
{
    msg.setSender(GATEWAY_ADDRESS);
    msg.setDestination(GATEWAY_ADDRESS);
    msg.setSensor(NODE_SENSOR_ID);
    msg.setType(type);
    msg.setCommand(C_INTERNAL);
    msg.setRequestEcho(false);
    msg.setEcho(false);
    return msg;
}
 
#endif