À l’aide de capteurs, modules RF 433Mhz et puce Bluefruit BLE de Adafruit pour recueillir des données sur Smartphone avec Evothings Studio (3 / 6 étapes)

Étape 3: Module émetteur Arduino

Nous allons commencer par faire les émetteurs. Ils sont tous construits et codées de la même manière, la seule différence est le numéro d’identification, que nous allons ajouter dans le code. Commençons par câblage il vers le haut.

J’ai utilisé le code pin 2 sur l’Arduino broche de données et la broche 3 pour axe de données de l' émetteurdu récepteur. Le récepteur possède 2 broches de données identiques, vous ne devez utiliser un. La cellule photoélectrique est connectée à la broche A0 sur l’Arduino. Toutefois, vous devez utiliser une résistance reliée à une des broches de la photocellule. La plupart du temps, une résistance Ω 10 k est suffisant, mais si vous prévoyez de l’utiliser dans une salle lumineuse, vous devrez peut-être remplacer par une résistance Ω 1 k, comme il sera probablement saturer.

Maintenant passons au code. Nous allons utiliser une bibliothèque appelée RadioHead pour envoyer et reçu le message avec les émetteurs/récepteurs RF. Celui dont vous avez besoin est celle appelée RH_ASK, qui signifie RadioHead Amplitude Shift Ktoisant. Vous pouvez le trouver sur ce site Web. Vous aurez également besoin de la bibliothèque de SPI (Serial Peripheral Interface) qui est utilisée pour la communication entre deux microcontrôleurs. Il n’est pas utilisé dans le code mais nécessaires pour compiler.

#include < RH_ASK.h > / / Bibliothèque de Radiohead pour modules RF
#include <SPI.h > / / pas réellement utilisé mais nécessaires à la compilation

L’étape suivante consiste à créer l’objet RH_ASK qu’on nommera le pilote. Si vous ne spécifiez aucun paramètre, il sera créé avec ses paramètres par défaut qui sont :

• Vitesse = 2000bps
• Les broches RX = 11 (euR)
• Broche TX = 12 (ransmitT)
• PTT pin = 10 (Push to talk)

Comme je suis avec les broches 2 et 3, je spécifierai ces paramètres. N’est pas le genre de modules RF, nous utilisons la fonction Ptt, donc vous pouvez l’ignorer, à moins que vous vous connecter à quelque chose à la broche 10, en auquel cas vous devrez définir le Ptt pin vers un pin inutilisé (ou -1) comme c’est perturber certains autrement.

Pilote RH_ASK (2000, 2, 3) ; Définition de goupille de RX (récepteur) à 2 et broche TX (émetteur) sur 3

Voici les variables globales utilisées dans le code :
La chambre variable est le numéro d’identification de l’Arduino. Vous devez incrémenter pour chaque émetteur Arduino vous utilisez.
La variable startRequest est composé de la lettre "a" suivi du numéro d’identification. L’émetteur Arduino comparera la demande qu’il reçoit de la « mère » Arduino à cette chaîne. S’ils correspondent, il puis renverra les données lues à partir du capteur.
La variable photocellPin est l’axe sur lequel la cellule photoélectrique est connectée.
La variable photocellReading stocke la valeur lue de la photocellule.

salle de constint = 0 ; Numéro d’identification
String startRequest = "a"String(room) ; Chaîne de demande envoyée par la « mère » Arduino

constint photocellPin = A0 ; Goupille de cellule photoélectrique
int photocellReading ; Variable pour stocker la lecture de la cellule photoélectrique

La partie du programme d’installation est assez simple. Vous devez définir l’axe de la cellule photoélectrique à un mode d’entrée et, si vous le souhaitez, commencer la communication série pour le débogage.

voidsetup()
{
pinMode (photocellPin, entrée) ;

Série.begin(9600) ; Pour le débogage
Si (! driver.init()) / / si les modules RF n’a pas pu initialiser
Série.println ("init a échoué") ;
}

Dans la partie de la boucle , nous allons écrire le code qui gère la réception des demandes et la transmission des données. Nous commençons par créer une mémoire tampon de 2 octets long qui permet de stocker la demande reçue. Le format uint8_t est identique à un octetet désigne un entier non signé de 8 bits de longueur. Il faut aussi spécifier sa longueur dans la variable buflen .

voidloop()
{
uint8_t buf [2] ; Mémoire tampon utilisée pour stocker la demande reçue, sa taille est définie sur 2 octets, comme la demande est: « a » + String(room) (eg. a0)
uint8_t buflen = sizeof(buf) ;

Une fois que le récepteur RF reçoit un message de taille buflen, elle les stocke dans buf. Puisque le format du message est un tableau d’octets, nous avons besoin de les stocker dans une variable de chaîne afin de le comparer à la demande attendue. Ceci est fait en assignant la variable buf , précédée d’un (char *). Notez que le * signifie que les caractères créés seront des pointeurs vers les octets, qui ne pas utilisé de stockage supplémentaire.

Quand je l’ai testé, j’ai reçu parfois la demande suivie par certains caractères bizarres qui a rendu la comparaison impossible. Je vais donc garder seulement les deux premiers caractères du message à l’aide de la chaîne fonction substring.

Si (driver.recv (buf, & buflen)) / / au moment de la réception d’une demande
{
Requête de chaîne = (char *) buf ; Stocker la demande d’une chaîne pour comparaison
demande = request.substring (0, 2) ; Message reçu est parfois suivie de caractères bizarres, gardant seulement les deux premiers
Série.print ("Got demande:") ; Imprimer la demande reçue pour le débogage
Série.println(request) ;

Maintenant que nous avons notre requête stockée dans une variable de chaîne, nous pouvons comparer il à la demande, que nous nous attendions, qui est startRequest que nous avons créé au commencement.

Si (demande == startRequest) / / si la demande correspond à la demande de départ de cet Arduino, mesurer les données et l’envoyer
{
Série.println ("Start demande reçue") ;
Série.println("") ;
Delay(150) ;

Si la demande reçue correspond à l' startRequest, l’Arduino doit renvoyer des données. Donc, nous commençons par la lecture de ces données, en l’occurrence de la photocellule en utilisant la fonction analogRead et stocker dans la variable photocellReading . Cela nous donne une valeur comprise entre 0 et 1023, mais ce n’est pas pratique pour l’analyse car varie selon la longueur de la valeur. Nous allons donc utiliser la fonction map pour mapper la valeur un nombre compris entre 100 et 999, afin qu’il soit toujours long de 3 chiffres.

Envoi de données
Série.println ("Sending data") ;
Série.println("") ;
photocellReading = analogRead(photocellPin) ; Mesure de luminosité
Série.print (« lecture cellule photoélectrique: ") ;
Série.println(photocellReading) ; Pour le débogage

Les données de cartographie un nombre compris entre 100 et 999, afin qu’il soit toujours 3 chiffres, qui rend plus facile à analyser par la mère Arduino
int mapPhotocellReading = carte (photocellReading, 0, 1023, 100, 999) ;

Dès que nous aurons nos données mappées correctement, il faut envoyer à la « mère » Arduino. Pour s’assurer qu’il ne se mélange pas les données, nous allons ajouter le numéro d’identification de la pièce jusqu’au début du message que nous vous enverrons. Après cela, nous avons créer un tableau de char (1 octet plus longue que la longueur du message) et copier notre message à l’aide de la chaîne fonction toCharArray.

Dim str As String = chambre + String(mapPhotocellReading) ; Création d’une chaîne contenant le numéro de chambre et de la lecture afin que la « mère » Arduino sait d'où il vient
données de char [5] ; Tableau de char pour stocker la réponse, doit être de 1 octet est plus que la longueur de la chaîne
str.toCharArray (données, 5) ; Copiez la chaîne en tableau char

Maintenant, tout ce qui reste à faire est d’envoyer le message. Ceci est fait en utilisant la méthode send de l’objet conducteur à un message dans le format uint8_t . La méthode waitPacketSent est utilisée pour s’assurer que les données sont bien envoyées avant d’exécuter le reste du code

les données de ((uint8_t *) de Driver.Send, strlen(data)) ; Envoi de réponse
driver.waitPacketSent() ; Attente jusqu'à ce que le paquet de réponse est entièrement envoyé

Série.print ("données envoyées:") ; Pour le débogage
Série.println(data) ;
Série.println("") ;
}
}
}