NodeAPI

Nodapi

* L'API a également une version WiFi avec les mêmes définitions et fonctionnalités au cas où vous souhaitez bénéficier directement de la carte WIFI ou SIM800L SIM800L

** Exemples ULP (Ultra Low Power) également disponibles pour l'API WiFi et l'API LORA dans / Exemples / ESP32 / ULP

*** Sonoff / ESP8266-01 1,2,4 Exemples de relais dans: / Exemples / ESP8266-01

#FRÉQUENCE

Les prises en charge officiellement sont: 433 MHz, 868 MHz et 915 MHz - la valeur par défaut est 868 MHz pour passer à un autre, veuillez passer le paramètre RequencyRange (les options prises en charge sont: IOTTHING_433, iotthing_868, ioThthing_915) du côté de la passerelle dont vous avez également besoin pour choisir une fréquence appropriée:

Pour les nœuds sur 433, la passerelle peut être: 433.1, 433.3, 433.5

Pour les nœuds sur 868, la passerelle peut être: 868.1, 868.3, 868.5

Pour les nœuds sur 915, la passerelle peut être: 915.1, 915.3, 915.5

Exemple: iotthing Thing (cs_pin, int_pin, rst_pin, key, thing_id, null, iotthing_433);

#ENREGISTREMENT

Pour activer la journalisation à l'intérieur de la bibliothèque, vous devez ajouter à la mendicité de votre source principale échoue / sketch:

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////DEBLE

// Constantes de journaux

#define log64_enabled

#include <log64.h>

et assurez-vous également quelque part à l'intérieur de la fonction "Configuration" que vous avez: Serial.Begin (115200);

# Nœud / périphérique / chose API Send / Recevoir des données

Sur le côté nœud / chose, I4Things fournissent une classe simple simple qui peut être utilisée pour fournir des données à l'autorité / serveur.

 class IoTThing
{
  public:
    // constructor
    IoTThing(uint8_t slaveSelectPin_,
             uint8_t interruptPin_,
             uint8_t resetPin_,

             uint8_t key_[16],
             uint64_t id_,
             void (* receive_callback_)(uint8_t buf_[], uint8_t size_, int16_t rssi_) = NULL,
              uint8_t requencyRange = IoTThing_868,
             uint64_t gateway_id_ = 10); // default open gateway id

    // call before using
    void init();

    // set id ( in case after start needs to be changed)
    void set_id(uint64_t id_ );

    // set key ( in case after start needs to be changed)
    void set_key(uint8_t key_[16]);

    // set gateway id ( in case after start needs to be changed)
    void set_gateway_id(uint64_t gateway_id_ );

    // register to receive callback after the message has been acknowledged from the gateway
    void register_ack(void (* ack_callback_)(int16_t rssi_));

    // register to receive callback after the message has failed/ in msec
    void register_timeout(void (* timeout_callback_)(uint16_t timeout_));

    // return signal strength in %
    uint8_t signal_strength();

    // return total messages sent
    uint32_t total_messages();

    //return total acknowledged messages send
    uint32_t ack_messages();

    //return received messages count
    uint32_t recv_messages();

    //return total retransmit messages send
    uint32_t retransmit_messages()

    //add discrete data
    //use this if you want for example to store decimal(floating-point) temperature between -20 and +60 in one byte
    // pos is the position from which the data will be written
    // e.g. : add_discrete(buf, 0,  -20.0, 60.0, 23.65, 1);
    //you need to ensure that you at least have container_size bytes available in the buffer
    //1 <= conainer_size <= 4
    //on return pos will have the value of first free byte(next postion after the data)
    static void add_discrete(uint8_t buf_[], uint8_t &pos_, double min_, double max_, double value_, uint8_t container_size_);

    //read discrete value
    static double get_discrete(uint8_t buf_[], uint8_t &pos_, double min_, double max_, uint8_t container_size_);

    //add unsigned integer data up to 62bit ( 0 - 4611686018427387904) - the container size will be adjusted automatically depending on the value
    // pos is the position from which the data will be written
    //you need to ensure that you have at least 8 bytes available in the buffer - as this is the maximum bytes that the number can occupy in worst case scenario
    //on return pos will have the value of first free byte(next postion after the data)
    static void add_uint(uint8_t buf_[], uint8_t &pos_, uint64_t value_);

    // get unsigned integer value
   static uint64_t get_uint(uint8_t buf_[], uint8_t &pos_)

    // return false if a error is logged
    // max message size in bytes is 31
    bool send(uint8_t buf_[], uint8_t size_);

    // return true - if all previous tasks has been completed and ready to accept new data
    bool is_ready();

    // call if you want to stop retry's to send the message
     void cancel();

    // return true - if last message sending has hit timeout and failed
    bool timeout_hit();

    // please call in the main loop to be able to dispatch data and menage logic
    void work();
};

Exemple comment utiliser l'API:

 #include "IoTThing.h"


// exmaple PINS for Feather 32u4
#define CS_PIN 8
#define RST_PIN 4
#define INT_PIN 7

#define DEVICE_ID 1000
uint8_t key[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

// you can also optionally pass:
// - function pointer/address for callback messages when received
// - gateway id - in case you want to use a private/closed gateway
//
// example for message received callback:
//
// called when packet received from node
// void received(uint8_t buf_[], uint8_t size_, int16_t rssi)
// {
//  //process message in buf_[] here with length = size_ 
// };
//
// IoTThing thing(CS_PIN, INT_PIN, RST_PIN, key, DEVICE_ID, received);
//

IoTThing thing(CS_PIN, INT_PIN, RST_PIN, key, DEVICE_ID);



// 2 minutes
#define MESSAGE_INTERVAL  120000
uint32_t MESSAGE_LAST_SEND;

void setup() {
  MESSAGE_LAST_SEND = millis() + MESSAGE_INTERVAL * 2;

  thing.init();
}



void loop() {
  // let IoT layer do it job
  thing.work();

  // try send message every 2 min
  if (((uint32_t)(((uint32_t)millis()) - MESSAGE_LAST_SEND))  >= MESSAGE_INTERVAL) {
    MESSAGE_LAST_SEND = millis();

    uint8_t msg[2];

    msg[0] = 22; // e.g. temperature 
    msg[1] = 78; // e.g. humidity

    // check if IoT layer is ready to accept new message
    if (thing.is_ready()) {
      thing.send(msg, 2);
    }
    else {
      // cancel previous work and send new message
      thing.cancel();
      thing.send(msg, 2);
    }
  }

}

IMPORTANT

Pour la bibliothèque de nœuds open source simple, vous devrez également télécharger et mettre à disposition la bibliothèque Radiohead: radiohead.zip - celle fournie a un bugfix sur la plate-forme ESP32.

Pratique et efficacité

Dans l'API, il se trouve des fonctions statiques très utiles liées à une manière facile et efficace de représenter des données dans le message du tampon d'octets (tableau d'octets):

 static void add_discrete(uint8_t buf_[], uint8_t &pos_, double min_, double max_, double value_, uint8_t container_size_);
static double get_discrete(uint8_t buf_[], uint8_t &pos_, double min_, double max_, uint8_t container_size_);

static void add_uint(uint8_t buf_[], uint8_t &pos_, uint64_t value_);
static uint64_t get_uint(uint8_t buf_[], uint8_t &pos_);

À l'aide de l'ajout / obtenez discret, vous pouvez ajouter au tampon et lire à partir des valeurs discrètes du tampon - par exemple si vous voulez stocker tempéré dans l'intervalle entre -20C et + 60C efficacement dans un seul octet mais toujours une meilleure résolution puis 1/2 degré, vous pouvez utiliser les fonctions discrètes de la manière suivante:

 uint8_t buf[2];
uint8_t buf_pos = 0;

double temp1 = 23.5;
double temp2 = 18.1;

//insert into the buffer
IoTThing::add_discrete(buf, buf_pos,-20.0, 60.0, temp1, 1);
IoTThing::add_discrete(buf, buf_pos,-20.0, 60.0, temp2, 1);

buf_pos = 0;

double temp1_read_from_buffer = IoTThing::get_discrete(buf,buf_pos, -20.0, 60.0, 1);
double temp2_read_from_buffer = IoTThing::get_discrete(buf,buf_pos, -20.0, 60.0, 1);

À l'aide de l'addition / get uint, vous pouvez ajouter au tampon et lire à partir des valeurs entières positives de tampon comprises entre 0 et 4611686018427387904. La valeur sera stockée dans les octets minimum possibles, par exemple si la valeur peut occuper un octet n'en occupera qu'un seul octet, si elle peut s'adapter à 2 octets. De cette façon, vous pouvez économiser de l'espace dans le message, être efficace et optimiser votre trafic:

 uint8_t buf[8]; // make sure we have space for maximum size
uint8_t buf_pos = 0;

//insert into the buffer
IoTThing::add_uint(buf, buf_pos, 11); // will occupy only 1 byte
IoTThing::add_uint(buf, buf_pos, 500); // will occupy only 2 bytes

buf_pos = 0;
int val1 = (int)IoTThing::get_uint(buf, buf_pos);
int val2 = (int)IoTThing::get_uint(buf, buf_pos);