[ad_1]
Dans notre vie quotidienne, nous sommes régis par le temps et les horaires. Idem pour les produits connectés.
Nous pouvons nous réveiller à 6h30 UN M, prendre le bus à 7h34, commencer le travail à 8h10, ramasser à l’école à 16h00. Basé sur des heures de la journée synchronisées et souvent fixes.
Les produits connectés sont faits pour fonctionner avec nous et pour nous. Ils doivent donc aussi respecter les horaires.
Quelques exemples :
- Les lampadaires doivent s’allumer et s’éteindre à des moments précis de la journée.
- Les dispositifs d’éclairage horticoles suivent des schémas d’éclairage complexes pour assurer une croissance maximale des plantes.
- Les capteurs sans fil peuvent être désactivés la nuit pour économiser la batterie.
Ce sont des cas d’utilisation légèrement différents.
Mais ils partagent le même mécanisme sous-jacent : l’ordonnancement et la synchronisation temporelle.
La plupart des nombreux produits connectés et systèmes IoT que nous avons construits chez Thingsquare reposent sur la planification.
Aujourd’hui, nous examinons comment nous implémentons la planification dans le système Thingsquare IoT.
La base : synchronisation et distribution de l’heure
La base de la planification est le temps.
Sans savoir quelle heure il est, la planification est inutile.
Mais comment les appareils peuvent-ils savoir quelle heure il est ?
En général, la synchronisation temporelle est un problème complexe avec de nombreuses solutions différentes.
Mais pour nos besoins, l’appareil n’a besoin que de deux choses :
- Une horloge interne qui fonctionne à une vitesse raisonnablement précise.
- Un moyen de synchroniser l’horloge interne avec l’horloge mondiale actuelle.
Une fois que l’appareil s’est synchronisé avec l’heure globale, il peut fonctionner tout seul sans avoir à être à nouveau synchronisé. Du moins jusqu’à ce que son horloge interne s’éloigne trop de l’horloge globale. Ou jusqu’à ce que l’appareil tombe en panne.
Dans le système Thingsquare, les appareils sont déjà synchronisés les uns avec les autres dans le cadre du mécanisme de saut de canal sans fil intégré. En plus de cela, le backend distribue un décalage temporel absolu.
Avec le réseau synchronisé et avec la connaissance de l’horloge mondiale, tous les appareils connaissent l’heure absolue.
Les appareils utilisent leur notion du temps à la fois pour horodater toutes leurs données et pour les actions planifiées.
Planification : les détails
Tous les appareils Thingsquare savent quelle heure il est.
Comment utilisons-nous ces informations pour planifier des actions ?
La base des horaires dans le système Thingsquare est une semaine. En effet, la plupart des horaires du monde réel sont basés sur des événements hebdomadaires.
Pour déterminer le jour de la semaine, les appareils utilisent l’heure mondiale actuelle et effectuent un calcul simple : calculez le nombre de secondes à partir d’un lundi connu.
Sur la base de ces informations, des événements peuvent être programmés. Lorsqu’un événement se produit, une fonction de rappel dans le micrologiciel de l’appareil est appelée.
Notre fonction de rappel sera invoquée à une combinaison de jour de la semaine et heure de la journée. Nous jumelons également un argument d’action à la date/heure. L’argument est utilisé lorsque le rappel est invoqué, afin que nous puissions dire quoi faire.
Dans le rappel, nous pouvons faire l’action que nous voulons.
Par exemple, il peut s’agir d’un événement conditionnel, nous pouvons donc vérifier si ceux-ci sont remplis. Nous pouvons commencer un étalonnage d’un capteur ou allumer des lumières.
Le mettre en place
Ici, nous allons utiliser l’exemple d’un appareil qui doit être étalonné deux fois par jour. Il peut s’agir d’un outil industriel par exemple.
Pour les échantillons de capteurs périodiques, nous avons un autre mécanisme encore mieux adapté, à savoir le rappel Thingsquare avec THSQ_PERIOD argument. Mais c’est pour un autre article de blog.
Donc, pour commencer, nous aurons besoin d’une configuration de base. Nous donnerons un nom à l’horaire, de sorte que nous pourrons remplacer l’horaire in situ.
static struct thsq_schedule calib_schedule;
thsq_schedule_init(&calib_schedule, "calsched", calib_cb);Ajouter des événements
Ensuite, nous devrions ajouter des événements au calendrier. Pour cela, nous avons besoin d’un tampon et de quelques appels de fonction de commodité.
Par défaut, les arguments que nous enregistrons avec chaque événement font trois octets. Parfait pour les applications d’éclairage avec RVB canaux. Cela peut être changé cependant.
extern void thsq_schedule_build_schedule_action(uint8_t *buf,
int mon, int tue, int wed, int thu, int fri,
int sat, int sun,
uint8_t hours, uint8_t minutes,
uint8_t red, uint8_t green, uint8_t blue);
static uint8_t events[2 * EVENT_LEN];
thsq_schedule_build_schedule_action(&events[0],
1, 1, 1, 1, 1, 0, 0,
06, 00,
INSTRUMENT_0, 1, 2);
thsq_schedule_build_schedule_action(&events[7],
1, 1, 1, 1, 1, 0, 0,
18, 30,
INSTRUMENT_1, 3, 4);Ajouter des événements au programme
Maintenant que nous avons défini le planning et les événements, il ne nous reste plus qu’à les associer.
thsq_schedule_set_default(&calib_schedule, events, 2 * EVENT_LEN);Rappeler
La dernière pièce du puzzle consiste à créer le rappel réel.
Étant donné que le même rappel peut être utilisé avec différentes planifications, nous obtiendrons un pointeur sur la planification qui s’est déclenchée. Nous obtenons également un pointeur sur les arguments et la longueur des arguments.
Dans notre exemple, le rappel sera invoqué avec arglen égal 3, et arg égal à [0, 1, 2] ou [100, 3, 4], et nous l’utilisons ici dans le rappel pour indiquer à notre application comment s’exécuter.
static void
calib_cb(struct thsq_schedule *s, uint8_t *arg, int arglen)
{
uint8_t instrument = arg[0];
uint8_t calib_arg1 = arg[1];
uint8_t calib_arg2 = arg[2];
instrument_calibrate(instrument, calib_arg1, calib_arg2);
}Modifications après le déploiement
Maintenant, disons que nous avons déployé des appareils avec le calendrier ci-dessus. Supposons qu’un client préfère ne pas organiser d’événement d’étalonnage le matin. Comment pouvons-nous y arriver?
Le moyen le plus simple serait de pousser d.calsched avec le nouvel horaire, sans l’événement du matin. C’est facile puisque la liste d’événements n’est qu’un tampon.
S’ils changent d’avis plus tard, nous pourrions à nouveau pousser une mise à jour d.calsched.
Ajout d’aléatoire
Souvent, le hasard est une bonne chose. Surtout lorsqu’il s’agit de transmettre des données sur le réseau.
Avoir des centaines d’appareils poussant des données en même temps peut surcharger le réseau, dépassant la bande passante disponible.
Nous pouvons ajouter un peu d’aléatoire à ce qui précède assez facilement. Nous devons juste nous assurer que le calibrage ne s’exécute pas exactement au moment où le rappel est invoqué, mais à un moment aléatoire limité et ultérieur.
Voici à quoi cela ressemblerait.
static void
do_calibrate(void *arg)
{
uint8_t *p = (uint8_t *)arg;
uint8_t instrument = p[0];
uint8_t calib_arg1 = p[1];
uint8_t calib_arg2 = p[2];
instrument_calibrate(instrument, calib_arg1, calib_arg2);
}
static void
calib_cb(struct thsq_schedule *s, uint8_t *arg, int arglen)
{
static uint8_t argbuf[3];
static struct ctimer calibrate_timer;
memcpy((void *)argbuf, (const void *)arg, 3);
ctimer_set(&calibrate_timer,
random_rand32_interval_upper_half(TIMEOUT),
do_calibrate, (void *)argbuf);
}
À ton tour
Souhaitez-vous en savoir plus sur la façon dont Thingsquare peut aider votre produit à prendre vie ? Nous avons hâte de vous parler ! Envoyez-nous un e-mail ou démarrez une discussion avec nous.
N’hésitez pas à utiliser le planificateur de solutions IoT pour obtenir une estimation automatisée du temps et des coûts de votre produit.