Il est temps de combiner ces deux techniques pour obtenir une communication bidirectionnelle complète entre Android et Arduino.
Pour ce faire, nous allons monter un projet simple utilisant un télémètre à ultrasons et un buzzer piézo.
Algorithme de travail
Sur l'écran de l'appareil Android, une activité s'affiche avec le bouton "Mesurer", lorsqu'on appuie dessus, la commande correspondante est envoyée à la carte Arduino. La carte Arduino traite la commande et démarre un cycle de mesure, après quoi la distance moyenne jusqu'à l'obstacle en centimètres est calculée. Cette distance à l'objet est retransmise à l'appareil Android, où elle est affichée sous forme de texte, ainsi que sur le curseur (ProgressBar).
Le traitement des données a également lieu sous Android : si la distance à l'objet est inférieure à 20 cm, alors un signal de commande est transmis à l'Arduino pour activer le buzzer. Naturellement, cela pourrait être fait dans le code Arduino, mais pour plus de clarté, j'ai confié cette tâche aux épaules de l'appareil Android. En général, il s'est avéré qu'il s'agissait d'un petit parktronic.
Donc, vous devez d’abord décider des commandes de contrôle. Ils doivent être définis de la même manière sur l’Arduino et sur l’appareil Android. J'ai choisi les numéros suivants :
1 - commande pour activer la transmission
2 - commande pour désactiver la transmission
3 - commande pour allumer le buzzer
Avec les deux premières commandes, cela s'est avéré un peu déroutant, etc. Je n'ai pas réussi à faire en sorte qu'Android reçoive correctement un envoi avec des données (j'ai essayé de l'envoyer dans un cycle et dans le temps, mais Android refuse obstinément d'accepter les données, je soupçonne que cela est lié à ADB et il ne devrait pas y avoir de tels problèmes lors de l'utilisation Mode accessoire). Par conséquent, lorsque l'Arduino reçoit la commande 1 (activation de la transmission), il mesure la distance et active la transmission continue des données en boucle. Une fois qu'Android a reçu les données, il envoie la commande 2 à l'Arduino pour arrêter le transfert.
Programme pour Arduino
Croquis pour Arduino :
#include #include // connexion adb. Connexion * connexion ; // connexion adb. #define COMMAND_SEND_TRUE 1 // commande pour activer la transmission #define COMMAND_SEND_FALSE 2 // commande pour désactiver la transmission #define COMMAND_PLAY_BEEP 3 // commande pour activer le buzzer const int numOfReadings = 10; // nombre de mesures (éléments du tableau) int lectures ; // valeurs de mesure dans le tableau int arrayIndex = 0; // index de l'élément dans le tableau int total = 0; // valeurs totales int AverageDistance = 0 ; // distance moyenne // configuration des broches et des variables pour le capteur à ultrasons int echoPin = 2; // DYP_ME007 Broche ECHO int initPin = 3 ; // DYP_ME007 Broche TRIG int BeeperPin = 8 ; // broche du buzzer non signée longue pulseTime = 0 ; // durée de l'impulsion en microsecondes longue distance non signée = 0 ; // distance en (cm) booléen SendToAndroid = false; void setup() ( pinMode(initPin, OUTPUT); pinMode(echoPin, INPUT); pinMode(BeeperPin, OUTPUT); // Buzzer // forme un tableau pour (int thisReading = 0; thisReading< numOfReadings; thisReading++) { readings = 0; } Serial.begin(115200); // Инициализация подсистемы ADB. ADB::init(); // Open an ADB stream to the phone"s shell. Auto-reconnect. Use any unused port number eg:4568 connection = ADB::addConnection("tcp:4568", true, adbEventHandler); } void loop() { if(SendToAndroid == true) makeDimension(); ADB::poll(); // Poll the ADB subsystem. } void adbEventHandler(Connection * connection, adb_eventType event, uint16_t length, uint8_t * data) { if (event == ADB_CONNECTION_RECEIVE) // Если приняли данные { Serial.print("data:"); // Вывод в Serial Monitor для отладки Serial.println(data,DEC); if((data) == COMMAND_SEND_TRUE) SendToAndroid = true; // Флаг, что надо вкл. передачу данных else if ((data) == COMMAND_SEND_FALSE) SendToAndroid = false; //Флаг, что данные приняты и откл. передачу данных else if ((data) == COMMAND_PLAY_BEEP) playBeep(); } else if (event == ADB_CONNECTION_OPEN) Serial.println("ADB connection open"); else if (event == ADB_CONNECTION_CLOSE) Serial.println("ADB connection close"); else { Serial.println(event); } } void makeDimension() { for (int i = 0; i < numOfReadings; i++) { digitalWrite(initPin, HIGH); // посылаем импульс длительностью 10мс delayMicroseconds(10); digitalWrite(initPin, LOW); pulseTime = pulseIn(echoPin, HIGH); // Считываем длительность пришедшего импульса distance = pulseTime/58; // Дистанция = (длит. импульса / 58) см total= total - readings; readings = distance; total= total + readings; arrayIndex = arrayIndex + 1; // После того, как достигли последнего элемента, начинаем сначала if (arrayIndex >= numOfReadings) ( arrayIndex = 0; ) //Serial.println(distance, DEC); ) AverageDistance = total / numOfReadings ; // calcule la distance moyenne //Serial.println(averageDistance, DEC); connexion->write(2,(uint8_t*)&averageDistance); // Envoie un délai de 2 octets (10); ) void playBeep() ( pour (int j = 0; j< 10; j++) { analogWrite(BeeperPin, 20); delay(50); analogWrite(BeeperPin, 0); delay(150); } }
Au tout début, nous définissons 3 constantes - ce sont des commandes pour envoyer des messages entre appareils : COMMAND_SEND_TRUE = 1, COMMAND_SEND_FALSE = 2, COMMAND_PLAY_BEEP = 3
Gestionnaire adbEventHandler() est appelé à chaque fois que des données sont reçues et lorsque d'autres événements se produisent depuis ADB (ouverture et fermeture d'une connexion).
Fonction makeDimension() effectue 10 mesures de distances, puis en calcule la valeur moyenne, qui, grâce à la commande connexion->écrire>() 2 octets sont envoyés à l'appareil Android.
Avec fonction jouerBeep() c'est simple : il est conçu pour émettre 10 sons courts via le buzzer.
Programme pour Android
Notre fenêtre d’activité comprendra les éléments clés suivants :
bouton (Bouton) - pour envoyer une commande de mesure de distance
champ de texte (TextView) - pour afficher la distance reçue
barre de progression (ProgressBar) - pour l'affichage visuel de la distance (maximum - 500 cm)
icône de connexion (ImageView) - affichée lors d'une connexion active avec un appareil Android.
Voir les fichiers joints pour le fichier XML de cette activité
Le fichier de l'activité principale contient le code suivant :
Paquet com.example.arduino54 ; importer java.io.IOException ; importer org.microbridge.server.Server ; importer org.microbridge.server.AbstractServerListener ; importer com.example.arduino54.R ; importer android.os.AsyncTask ; importer android.os.Bundle ; importer android.app.Activity ; importer android.util.Log ; importer android.view.View ; importer android.widget.ImageView ; importer android.widget.ProgressBar ; importer android.widget.TextView ; importer android.widget.Button ; public class MainActivity étend l'activité (private int Distance = 0; public final String APP_NAME = "arduino54"; public final byte COMMAND_SEND_TRUE = 1; // Envoyer la commande d'activation public final byte COMMAND_SEND_FALSE = 2; // Envoyer la commande de désactivation public final byte COMMAND_PLAY_BEEP = 3; // Commande d'activation du buzzer public final int SYS_COMMAND_DATA = 0; // Commande interne : transfert de données public final int SYS_COMMAND_CONNECTED = 1; // Commande interne : connexion établie public final int SYS_COMMAND_DISCONNECTED = 2; // Commande interne : connexion perdue Serveur server = null; ImageViewconnectedImage; @Override public void onCreate(Bundle savingInstanceState) ( super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Créer un serveur TCP (basé sur le serveur MicroBridge LightWeight) try ( server = new Server(4568); //Ce port doit également être utilisé sur la carte ADK server.start(); ) catch (IOException e) ( Log.e(APP_NAME, "Impossible de démarrer le serveur TCP", e); Système.exit(-1); )connectedImage = (ImageView) findViewById(R.id.imageConnected); connectedImage.setAlpha(20); Bouton Bouton1 = (Bouton)findViewById(R.id.button1); Button1.setOnClickListener(new View.OnClickListener() ( public void onClick(View v) ( try ( server.send(new byte ((byte) COMMAND_SEND_TRUE)); //Envoyer des données //Log.d(APP_NAME, "data_send : "+bSend); ) catch (IOException e) ( Log.e(APP_NAME, "Problème d'envoi du message TCP", e); ) ) )); server.addListener(new AbstractServerListener() ( @Override public void onReceive(org.microbridge.server.Client client, byte data) ( Log.d(APP_NAME, "data0:"+data+"; data1:"+data); if (données.longueur<2) Log.e(APP_NAME, "Размер данных менее 2-х байт:"+data.length); else { try { server.send(new byte {(byte) COMMAND_SEND_FALSE}); //Посылаем данные } catch (IOException e) { Log.e(APP_NAME, "Problem sending TCP message", e); } } Distance = ((data << 8) | (data & 0xFF)); // Формируем слово из 2-х байт //Any update to UI can not be carried out in a non UI thread like the one used //for Server. Hence runOnUIThread is used. runOnUiThread(new Runnable() { //@Override public void run() { new UpdateData().execute(Distance,SYS_COMMAND_DATA); } }); } //@Override public void onClientConnect(org.microbridge.server.Server server, org.microbridge.server.Client client){ Log.d(APP_NAME, "ClientConnected"); runOnUiThread(new Runnable() { public void run() { new UpdateData().execute(0,SYS_COMMAND_CONNECTED); } }); } public void onClientDisconnect(org.microbridge.server.Server server, org.microbridge.server.Client client){ Log.d(APP_NAME, "ClientDisconnected"); runOnUiThread(new Runnable() { public void run() { new UpdateData().execute(0,SYS_COMMAND_DISCONNECTED); } }); } }); } @Override protected void onDestroy (){ super.onDestroy(); server.stop(); } class UpdateData extends AsyncTask< Integer, Integer, Integer>( // Appelé pour lancer l'activité en arrière-plan @Override protected Integer doInBackground(Integer... ArdState) ( if((ArdState< 20) && (ArdState != 0)){ //Если расстояние меньше 20см try { server.send(new byte {(byte) COMMAND_PLAY_BEEP}); } catch (IOException e) { Log.e(APP_NAME, "Problem sending TCP message", e); } } return (ArdState); //Возвращаем в onPostExecute() } @Override protected void onProgressUpdate(Integer... values) { super.onProgressUpdate(values); // Not used in this case } @Override protected void onPostExecute(Integer... result) { Log.d(APP_NAME, "onPostExecute:"+result); Log.d(APP_NAME, "onPostExecute:"+result); if(result == 1){ connectedImage.setAlpha(255); } else if(result == 2){ connectedImage.setAlpha(20); } TextView txt_Distance_Arduino = (TextView) findViewById(R.id.textDistance); txt_Distance_Arduino.setText(String.valueOf(result+" см")); // Выводим на activity дистанцию ProgressBar mProgressBar = (ProgressBar)findViewById(R.id.progressBar1); mProgressBar.setProgress(result); } } }
Nous voilà en cours serveur définir la méthode server.addListener (nouveau AbstractServerListener() ()), et: onReceive(), onClientConnect() Et onClientDisconnect() qui est appelé lors de la réception de données du serveur MicroBridge, lors de la connexion et de la déconnexion.
Sur le bouton Button1, nous suspendons le gestionnaire d'événements click setOnClickListener(). Lorsque le bouton est enfoncé, cette méthode est appelée et envoie la commande COMMAND_SEND_TRUE à la carte Arduino, par laquelle l'Arduino mesure la distance et transfère la valeur de la distance.
En méthode onReceive(), dès que nous avons reçu les données, nous renvoyons immédiatement la commande COMMAND_SEND_FALSE, afin que l'Arduino désactive la transmission des paquets. J'ai écrit sur cet algorithme ci-dessus.
Notez que nous utilisons les commandes système internes SYS_COMMAND_DATA, SYS_COMMAND_CONNECTED et SYS_COMMAND_DISCONNECTED pour transmettre les données à un thread distinct. Les commandes sont transmises par le 2ème élément du tableau, et le premier élément contient la distance mesurée reçue de l'Arduino.
Quand l'événement se déclenche surClientConnect(), un nouveau thread est créé auquel un tableau est passé avec la commande SYS_COMMAND_CONNECTED (dans notre cas 0), et dans la méthode onPostExecute() en réglant la valeur Alpha au maximum de 255, l'icône de connexion s'affiche. A réception de la commande SYS_COMMAND_DISCONNECTED, Alpha est mis à 20, l'icône devient estompée et quasiment invisible, ce qui signifie que la connexion n'a pas été établie. La transparence alpha est définie par la méthode setAlpha(int).
Lorsqu'un thread reçoit des données de la méthode onReceive, alors dans la méthode faireInBackground() les conditions sont comparées, et si la distance n'est pas précoce à zéro et inférieure à 20 cm, alors la méthode serveur.envoyer() la commande COMMAND_PLAY_BEEP est envoyée pour activer le buzzer sur la carte Arduino.
En méthode onPostExecute() Les éléments de l'interface utilisateur sont affichés pour afficher la valeur numérique de la distance et la bande sur la barre de progression.
Dans le fichier ci-joint vous pouvez télécharger projets pour Arduino et Android, ainsi que toutes les bibliothèques nécessaires
Chargeons l'exemple standard "Physical Pixel" via le menu File\Examples\4.Communication\PhysicalPixel. Ce programme attend les données de l'ordinateur. A la réception du caractère « H », le voyant test s’allume, à la réception du caractère « L », il s’éteint. Analysons son code source :
int sortiePin = 13 ; // ici nous stockons le numéro de contact
valeur entière ; // le caractère reçu sera stocké ici
void setup()
{
Série.begin(9600) ; //définit le port sur 9600 bps
pinMode(outputPin, SORTIE) ; // met la broche 13 en mode sortie
}
boucle vide()
{
if(Série.disponible())( //s'il y a un caractère accepté,
val = Série.read(); // puis lisez-le et stockez-le dans val
si (val == "H" ) ( // si le caractère "H" est accepté...
digitalWrite(outputPin, HIGH) ; // puis allume la LED
}
si (val == "L" ) ( // si le caractère "L" est accepté,
digitalWrite(outputPin, FAIBLE) ; // puis éteint la LED
}
}
}
Notez les conditions imbriquées et l’ordre des accolades ouvrantes et fermantes. Pour faciliter la lecture du code du programme, chaque niveau d'imbrication suivant est décalé vers la droite. De plus, l'éditeur aide à lire le code - si vous placez le curseur à droite du support, il mettra en surbrillance la paire de crochets correspondante.
Comment vérifier le fonctionnement de ce programme après l'avoir téléchargé sur le microcontrôleur ? Nous devons trouver un moyen d'envoyer des caractères au port COM de l'ordinateur afin que le microcontrôleur les reçoive et les traite. Il existe de nombreuses options pour résoudre ce problème.
Nous utilisons le moniteur de port COM intégré dans l'environnement de développement Arduino
C'est la méthode la plus simple et la plus compréhensible pour les débutants.
Le moniteur de port COM est lancé via le menu Outils\Moniteur série ou via la barre d'outils. Dans les anciennes versions du logiciel, le moniteur n'était disponible que via la barre d'outils : . Lorsque vous appelez le moniteur, assurez-vous que le même débit en bauds est sélectionné que dans le programme du microcontrôleur. Vous pouvez maintenant saisir n'importe quel caractère dans le champ de saisie à droite et appuyer sur le bouton "Envoyer" - les caractères saisis seront envoyés au port et votre programme les acceptera là-bas. Entrez-y la lettre latine "H", appuyez sur "Envoyer" - la LED de test s'allumera. Si vous envoyez "L", il s'éteindra. À propos, toutes les données que votre programme enverra au port COM seront affichées dans la fenêtre ci-dessous.
Utilisation du programme d'émulation de terminal HyperTerminal
Il s'agit d'une option d'échange légèrement plus complexe à mettre en œuvre.
Windows inclut généralement un programme d'émulation de terminal appelé HyperTerminal. Sous Windows XP, il se trouve sous Démarrer\Tous les programmes\Programmes\Accessoires\Communications\HyperTerminal. Au démarrage, vous devez refuser de créer une connexion, sélectionnez le menu Fichier \ Propriétés. Dans la boîte de dialogue qui apparaît, sélectionnez votre port COM, cliquez sur « Configurer » et configurez les paramètres de communication conformément à la figure :
Vous pouvez utiliser un autre émulateur de terminal – ils ont généralement tous des fonctionnalités et des paramètres similaires.
Cliquez sur "OK" dans les deux fenêtres, et une fois dans la fenêtre principale du programme, n'importe quelle touche du clavier - HyperTerminal se connectera au port COM. Désormais, tous les caractères tapés sur le clavier passent par le port COM vers le microcontrôleur, et tout ce que le microcontrôleur envoie va à l'écran. Appuyez sur les touches "H" et "L" (surveillez la langue et la casse sélectionnées) - la LED de test doit s'allumer et s'éteindre.
Écrivons notre propre programme PC !
Cette option est destinée aux vrais passionnés qui souhaitent programmer non seulement Freeduino, mais aussi PC. Pourquoi pas? Nous n'avons pas besoin d'apprendre les détails de la programmation série Windows ou toute autre chose compliquée. Surtout pour résoudre des tâches aussi simples, il existe le langage Processing (http://processing.org), qui est très similaire en termes de syntaxe et même d'environnement de développement au logiciel Arduino.
Installez et exécutez Processing - Vous verrez un environnement de développement de type Arduino.
Le code source du langage de traitement se trouve dans les commentaires sous le texte principal de l'exemple de pixel physique. Le voici avec des modifications minimes - nous avons corrigé l'ouverture du port afin que vous puissiez facilement remplacer son numéro :
importer le traitement.serial.* ;
port série;
void setup()
{
taille(200 , 200 ) ;
noStroke() ;
frameRate(10) ;
port = new Serial (this, "COM5", 9600) ; // !!! Entrez votre port COM ici !
}
booléen mouseOverRect() //Renvoie vrai si le curseur est à l'intérieur d'un carré
{
return ((mouseX >= 50 ) && (mouseX<=
150
)
&&
(mouseY >= 50 ) & (sourisY<=
150
)
)
;
}
tirage nul()
{
arrière-plan(#222222 ) ;
si (mouseOverRect() ) // Si le curseur est à l'intérieur d'un carré....
{
remplir(#BBBBB0) ; // change la couleur pour une couleur plus claire
port.write("H") ; // envoie "H" au microcontrôleur
) autre ( // si ce n'est pas à l'intérieur...
remplir(#666660 ) ; // change la couleur en plus foncée
port.write("L") ; // envoie "L" au microcontrôleur
}
rect(50 , 50 , 100 , 100 ) ; // dessine un carré
}
Exécutez le programme (via le menu Sketch \ Run) - une fenêtre avec un carré apparaîtra, lorsque vous y placerez le curseur de la souris, la LED de Freeduino s'allumera.
Une description du langage Processing et de ses capacités dépasse la portée de ce simple récit, mais de nombreux exemples Arduino dans les commentaires sous le corps du programme montrent du code PC Processing qui interagit avec Freeduino.
Il lui est tout simplement vital d'échanger des informations avec le microcontrôleur. Il existe des situations où vous devez manuellement, en contrôlant depuis un PC ou un ordinateur portable, activer l'une ou l'autre fonction du programme du microcontrôleur.
Mais passons aux choses sérieuses. Ce n'est pas si difficile d'échanger des données avec l'Arduino, mais le problème c'est que les données sont transmises caractère par caractère, ce qui est très mauvais. À la recherche de ce problème, j'ai dû passer beaucoup de temps jusqu'à ce que je tombe sur une merveilleuse bibliothèque sur Habrahabr. L'auteur y a implémenté la fonction d'acceptation des nombres, c'est-à-dire vous pouvez envoyer plus d'un chiffre au contrôleur et il fonctionnera correctement. Téléchargez la bibliothèque (lien), décompressez-la dans les bibliothèques matérielles et passons à la pratique.
Tout d'abord, nous allons écrire un croquis et le télécharger sur l'Arduino (Freeduino)
#include void setup() (
Série.begin(9600); // définit la vitesse du port
PinMode(9, SORTIE); // définit la broche 9 comme sortie haut-parleur
) boucle vide()
Numéro entier long ; Serial.print("Entrez le numéro : ");
Numéro = SerialInput.InputNumber(); // Entrez un numéro Serial.print("Résultat = ");
Serial.println (Numéro * Numéro, DEC);
Bip (500);
} bip nul (retards de caractères non signés) (
analogWrite(9, 20); // la valeur doit être comprise entre 0 et 255
// expérimente pour avoir un bon ton
analogWrite(9, 0); // 0 - éteint le piézo
Retard(retards); // pause retard ms
Qu'est-ce que tout cela veut dire. J'ai essayé de fournir au code des commentaires détaillés, tout semble clair. Ce croquis vous demande d'entrer n'importe quel nombre, après quoi il donne son carré et émet un signal sonore via un haut-parleur piézo connecté à la broche 9.
Et maintenant, le plus intéressant : il est temps d’essayer. Pour basculer avec le contrôleur, je recommande d'utiliser un programme gratuit mastic. Dans les paramètres du type de connexion, sélectionnez Série et entrez le numéro de port correct au lieu de COM1 (vous pouvez consulter l'environnement de programmation Arduino dans le menu Outils->Port série). Nous appuyons sur Ouvrir, et nous voyons l'inscription Enter number dans la console, nous entrons n'importe quel nombre (dans des limites raisonnables), nous appuyons sur Entrée et nous voyons le résultat.
Tout, vous pouvez vous réjouir et sauter de joie. Naturellement, tout cela peut être amélioré, par exemple, en affichant d'abord un menu à envoyer du contrôleur à la console, dans lequel décrire les commandes en détail. Par exemple, entrez le chiffre 0 - le rétroéclairage LED s'allume, appuyez sur 1 - il s'éteint. Ainsi, vous pouvez envoyer au moins 100 500 commandes, si seulement la mémoire du microcontrôleur est suffisante (qui est si petite). Et nous parlerons de la façon d'étendre la mémoire disponible la prochaine fois.
UPD : une partie du code a été coupée par l'analyseur du moteur, voici donc la source
Un port COM est le plus souvent utilisé pour connecter le microcontrôleur à un ordinateur. Dans cet article, nous montrerons comment envoyer des commandes de contrôle depuis un ordinateur et envoyer des données depuis un contrôleur.
Préparation au travail
La plupart des microcontrôleurs disposent de plusieurs ports d'E/S. Le protocole UART est le plus adapté à la communication avec un PC. Il s'agit d'un protocole de transfert de données asynchrone en série. Pour la convertir en interface USB, la carte dispose d'un convertisseur USB-RS232 - FT232RL.
Vous n'avez besoin que d'une carte compatible Arduino pour exécuter les exemples de cet article. Nous utilisons . Assurez-vous que votre carte dispose d'une LED connectée à la broche 13 et d'un bouton de réinitialisation.
Par exemple, téléchargeons un code sur le tableau qui affiche un tableau ASCII. ASCII est un codage permettant de représenter les chiffres décimaux, les alphabets latin et national, les signes de ponctuation et les caractères de contrôle.
symbole int = 33 ; void setup() ( Serial. start(9600 ) ; Serial. println(" Table ASCII ~ Carte de caractères " ) ; ) void loop() ( Serial. write(symbol) ; Serial. print(" , dec: " ) ; Serial .print(symbole) ; Serial.print(" , hex: " ) ; Serial.print(symbole, HEX) ; Serial.print(" , oct: " ) ; Serial.print(symbole, OCT) ; Serial.print( " , bin: " ) ; Serial.println(symbole, BIN) ; if (symbole == 126 ) ( while (true) ( continue ; ) ) symbole+ + ; )La variable symbole stocke le code du symbole. Le tableau commence à 33 et se termine à 126, le symbole est donc initialement défini sur 33.
Pour démarrer le fonctionnement du port UART, utilisez la fonction Série.begin(). Son seul paramètre est la vitesse. La vitesse doit être négociée à l'avance du côté de l'émission et de la réception, car le protocole de transmission est asynchrone. Dans cet exemple, la vitesse est de 9 600 bps.
Trois fonctions sont utilisées pour écrire une valeur sur un port :
- Série.write()– écrit les données sur le port sous forme binaire.
- Série.print() peut avoir de nombreuses valeurs, mais toutes servent à afficher des informations sous une forme conviviale. Par exemple, si les informations spécifiées comme paramètre à transmettre sont placées entre guillemets, le programme du terminal les affichera inchangées. Si vous souhaitez afficher une valeur dans un certain système numérique, vous devez alors ajouter un mot de service : BIN-binaire, OCT - octal, DEC - décimal, HEX - hexadécimal. Par exemple, Serial.print(25,HEX).
- Série.println() fait la même chose que Série.print(), mais traduit toujours la chaîne après avoir affiché les informations.
Pour vérifier le fonctionnement du programme, il est nécessaire que l'ordinateur dispose d'un programme terminal qui reçoit les données du port COM. L'IDE Arduino en a déjà un intégré. Pour l'appeler, sélectionnez Outils-> Port Monitor dans le menu. La fenêtre de cet utilitaire est très simple :
Cliquez maintenant sur le bouton de redémarrage. Le MK redémarrera et affichera la table ASCII :
Faites attention à cette partie du code :
if (symbole = = 126 ) ( while (true) ( continuer ; ) )Il arrête l'exécution du programme. Si vous l'excluez, le tableau sera affiché indéfiniment.
Pour consolider les connaissances acquises, essayez d'écrire une boucle infinie qui enverra votre nom au port série une fois par seconde. Ajoutez des numéros d'étape à la sortie et n'oubliez pas de traduire la ligne après le nom.
Envoi de commandes depuis le PC
Avant de faire cela, vous devez avoir une idée du fonctionnement d'un port COM.
Tout d’abord, tous les échanges s’effectuent via la mémoire tampon. Autrement dit, lorsque vous envoyez quelque chose d'un PC à un appareil, les données sont placées dans une section spéciale de la mémoire. Dès que l'appareil est prêt, il lit les données du tampon. La fonction permet de vérifier l'état du buffer série.avaliable(). Cette fonction renvoie le nombre d'octets dans le tampon. Pour soustraire ces octets, vous devez utiliser la fonction Série.read(). Voyons comment ces fonctions fonctionnent avec un exemple :
Une fois le code chargé dans la mémoire du microcontrôleur, ouvrez le moniteur du port COM. Tapez un caractère et appuyez sur Entrée. Dans le champ des données reçues, vous verrez : "J'ai reçu :X", où au lieu de X sera le caractère que vous avez entré.
Le programme tourne indéfiniment dans la boucle principale. Au moment où un octet est écrit sur le port, la fonction Serial.available() prend la valeur 1, c'est-à-dire que la condition est remplie Série.disponible() > 0. Fonction suivante Série.read() lit cet octet, effaçant ainsi le tampon. Après cela, en utilisant les fonctions que vous connaissez déjà, la sortie se produit.
L'utilisation du moniteur de port COM intégré à l'IDE Arduino présente certaines limites. Lors de l'envoi de données de la carte vers le port COM, la sortie peut être organisée dans un format arbitraire. Et lors de l'envoi du PC vers la carte, le transfert des caractères s'effectue conformément à la table ASCII. Cela signifie que lorsque vous saisissez, par exemple, le caractère « 1 », le binaire « 00110001 » (c'est-à-dire « 49 » en décimal) est envoyé via le port COM.
Modifions un peu le code et vérifions cette instruction :
Après le téléchargement, dans le moniteur de port lors de l'envoi de « 1 », vous verrez en réponse : « J'ai reçu : 110001 ». Vous pouvez modifier le format de sortie et voir ce que le tableau accepte avec d'autres caractères.
Contrôle de l'appareil via le port COM
Évidemment, par les commandes d'un PC, vous pouvez contrôler toutes les fonctions du microcontrôleur. Téléchargez le programme qui contrôle le fonctionnement de la LED :
int val = 0 ; void setup() ( Serial. start(9600 ) ; ) void loop() ( if (Serial. available() > 0 ) ( val = Serial. read() ; if (val= = "H" ) digitalWrite(13 , HAUT) ; if (val= = "L" ) digitalWrite(13 , BAS) ; ) )Lorsque le caractère « H » est envoyé au port COM, la LED de la 13ème sortie s'allume, et lorsque le « L » est envoyé, la LED s'éteint.
Si, sur la base des résultats de la réception des données du port COM, vous souhaitez que le programme effectue différentes actions dans la boucle principale, vous pouvez vérifier les conditions dans la boucle principale. Par exemple.
Avant-propos
Le développement de la technologie a permis d'installer plusieurs périphériques système sur une seule petite carte, le périphérique est appelé microcontrôleur. L'un de ces micro-ordinateurs monocristallins est Arduino, qui se compose d'un microcontrôleur monté sur une carte de circuit imprimé et du minimum de composants nécessaires au fonctionnement. Pour créer un nouvel appareil électronique, vous aurez besoin d'une carte Arduino, d'un câble de communication et d'un ordinateur. Pour les logiciels sous forme de programme de contrôle, connaissance de base de la variante du langage C/C++ pour microcontrôleurs, puisque des composants ont été ajoutés qui permettent d'écrire des programmes sans connaissance du matériel.
Communication via Bluetooth
En fait, le module Bluetooth est un modem, puisqu'il convertit le signal d'un support à un autre. Le signal série TTL transmis par des impulsions électriques à travers des conducteurs est converti en signal radio dans un émetteur-récepteur Bluetooth et vice versa, il est converti d'un signal radio en signal d'impulsion électrique. La fonction d'un modem est d'établir une connexion avec d'autres modems pour échanger des informations et déconnecter le canal de communication. Pour réaliser les fonctions de connexion, les modems disposent de deux modes de fonctionnement :
commande - l'échange d'informations dans ce mode s'effectue avec le modem lui-même ;
mode données - les informations sont échangées via le modem lui-même.
Les modems Bluetooth sont similaires dans leur principe de fonctionnement à tous les autres types de modems et contiennent un ensemble de commandes du protocole Hayes AT, similaires aux modems téléphoniques. Les commandes de ce protocole sont écrites en caractères ASCII. Les modems sur le protocole Hayes AT fonctionnent en mode données et commande, la commutation de mode s'effectue par la ligne +++.
Microcontrôleurs et contrôle des applications
Microcontrôleur - un microcircuit avec plusieurs contacts "entrée" et "sortie". Le contrôle via un microcircuit s'effectue selon le principe le plus simple et comporte trois étapes principales :
1) divers capteurs sont connectés aux entrées qui détectent le mouvement, le son, le niveau d'éclairage, etc.
2) Les dispositifs de contrôle sont connectés aux sorties, tels que les systèmes d'éclairage, les haut-parleurs, les moteurs, etc.
3) un programme de contrôle du microcontrôleur et l'application sont écrits.
Programme de contrôle :
#inclure
#inclure
const
intchipSelect= 4
;
vide
installation()
/* Ouvrir les communications série et attendre que le port s'ouvre : */
Série.begin( 9600 );
alors que(!En série)() /* attend que le port série se connecte. Nécessaire pour Leonardo uniquement */
Serial.print("Initialisation de la carte SD..." );
/* voir si la carte est présente et peut être initialisée : */
si(!SD.begin(chipSelect)) (
Série.println( « Carte défaillante ou absente »);
// ne fait rien de plus :
retour;
}
Serial.println("carte initialisée.");
}
vide
boucle()
// crée une chaîne pour assembler les données à enregistrer :
Chaîne dataString = "" ;
// lit trois capteurs et ajoute à la chaîne :
pour (intanalogiquePin = 0 ; analogiquePin< 3 ; analogiquePin++) (
intcapteur = analogRead (analogPin);
DataString += String(capteur);
si(analogiquePin< 2
) {
Chaîne de données += “,”
;
}
}
Arduino
Arduino est une plate-forme ouverte composée d'une carte microcontrôleur et d'un logiciel (logiciel) - IDE (Integrated Development Environment). Le logiciel de la carte est écrit dans des applications sur un ordinateur et est téléchargé sur l'appareil via le canal de connexion avec la carte.
La base du programme Arduino se compose de deux commandes : setup() et loop(). Les variables sont écrites avant la commande setup(), les bibliothèques sont impliquées. La commande setup() n'est exécutée qu'une seule fois après chaque connexion ou réinitialisation de la carte contrôlée par l'Arduino. Cette commande démarre les variables et le fonctionnement des ports d'entrée et de sortie de la carte. Cette commande est obligatoire pour le programme de contrôle. La commande loop() est destinée à l'exécution cyclique des commandes écrites dans son corps. Un exemple d'implémentation de ces commandes dans le programme :
installation()
{
Série.begin( 9600
);
}
boucle()
{
Série println(millis());
Retard( 1000
);
}
.
Un ensemble de codes regroupés dans un bloc et ayant un nom inscrit sur ce code est appelé une fonction. Le jeu de codes est exécuté lorsque la fonction est appelée. Pour réduire les erreurs dans le programme et exécuter des commandes répétitives, diverses fonctions sont écrites. Lors de l'écriture d'une fonction, son objectif est indiqué au début. Par exemple, la valeur renvoyée par une fonction est un entier (int). Les fonctions qui ne renvoient pas de valeur ont un type – vide (void). Derrière la fonction est écrit son nom et entre parenthèses les paramètres passés par la fonction. Par exemple:
taper Nom de la fonction(paramètres)
{
déclarations;
}
Le type intégral est la fonction de retard ou de pause delay(Val).
Les parenthèses () sont placées au début et à la fin des fonctions. Par exemple:
taper fonction()
{
déclarations;
}
Le nombre de parenthèses ouvrantes doit être égal au nombre de parenthèses fermantes, sinon des erreurs critiques se produiront dans le programme. Arduino a une fonction pratique de correspondance des parenthèses. Le contrôle s'effectue de deux manières : lorsqu'un support est sélectionné, le support apparié est mis en surbrillance, la mise en évidence du point derrière le support met également en évidence la paire de supports.
L'échange de données du microcontrôleur avec l'ordinateur s'effectue via une interface filaire ou par signal radio, l'échange d'informations s'effectue via la bibliothèque. L'Arduino dispose de bibliothèques standard installées, mais parfois leurs fonctions ne sont pas conçues pour fonctionner avec l'équipement contrôlé via le microcontrôleur. Des bibliothèques supplémentaires sont installées selon les besoins. Les bibliothèques standard sont installées dans le dossier « Bibliothèques », les bibliothèques supplémentaires sont installées dans le dossier bibliothèques.
Application Arduino et iOS
Afin d'intégrer Arduino avec Apple (iPad ou iPhone), vous aurez besoin de l'application Arduino Code et de l'environnement de développement Blynk. Arduino Code est installé sur l'iPad ou l'iPhone via cette application, l'intégration des appareils iOS et Arduino est réalisée. Blynk sera utilisé pour écrire le programme de contrôle de la carte Arduino. En plus de l'environnement cloud de travail, Blynk a la possibilité de télécharger des applications sur votre ordinateur. Étant donné que Blynk propose des versions pour iOS en plus d'Android pour le développement, cette application a été choisie pour l'intégration avec Apple. Il est également important que Blynk puisse communiquer avec les appareils via Bluetooth.
Dans un premier temps, nous connectons la carte de programmation au smartphone via les interfaces prises en charge : SeeedStudio Ethernet Shield V2.0 (W5200), Official Ethernet Shield (W5100), RN-XV WiFly, ESP8266, Official Arduino WiFi Shield, ESP8266 (WiFi modem), Adafruit CC3000 WiFi, ENC28J60 et USB (série). L'intégration d'Arduino avec les ordinateurs Macintosh (Apple) s'effectue via le menu Outils. Ensuite, la ligne Serial Port est sélectionnée dans le menu, puis la connexion s'effectue via le port dont le nom commence par /dev/cu.usbserial. Dans un deuxième temps, nous ajoutons des widgets (programmes) dans l'application, définissons les adresses de sortie et, si nécessaire, écrivons le code. Drag'n "drop est utilisé pour développer le widget. Blynk crée des programmes pour les cartes Arduino : Due, Mini, Uno et autres cartes Arduino. Le programme Arduino Code est installé sur un ordinateur et un code complet est requis pour écrire des commandes. L'application peut être téléchargé depuis l'App Store.Lors du téléchargement d'un programme sur la carte Arduino, vous devez désactiver le module Bluetooth, car la communication avec le microcontrôleur s'effectue via le même port.Une alimentation de 9 volts sera utilisée comme source d'alimentation pour le microcontrôleur. De plus, dans l'application Arduino Manager, il est possible de définir un widget prêt à l'emploi. Pour contrôler le dispositif de verrouillage, le widget Rotary Switch convient. Ce widget est essentiellement un commutateur rotatif (comme son nom l'indique. Il a deux positions marche/arrêt. Un widget simple et pratique pour contrôler l'appareil, qui ne dispose que de deux modes fermé/ouvert.
Nous créons une serrure électronique de la série « maison intelligente »
La carte Bluetooth HM-10 servira à connecter la carte Arduino. Ce module fonctionne en modes Maître et Esclave. Compatible avec les anciennes versions d'Arduino telles que : HC-05;-06;-07. Pour que les appareils Apple détectent le signal Bluetooth de la carte, vous devez installer le programme - LightBlue.
Nous connectons à la carte un lecteur contrôlé par Arduino, qui contrôlera le pêne de la serrure ou une électrovanne, qui remplira la fonction de verrouillage de la porte. Dans ce cas, le programme de contrôle ne sera pas encombrant et ressemblera à ceci :
#inclure
Servo monservo ;
intpos = 0
;
vide
installation() {
monservo.attacher( 10
); /* Attribuer 10 broches au contrôle du lecteur */
}
vide
boucle() {
pour(pos= 0
; position< 90
; pos += 1
)/* passe de 0° à 90° */
{
monservo.write(pos);
Retard( 25
); /* Spécifie le temps avec un délai (25 ms) pour passer à une autre position */
pour(pos= 90
; pos > 0
; pos -= 1
) /* Passer de 90° à 0° */
{
monservo.write(pos);
Retard( 25
); /* Délai de 25 ms pour atteindre la position inversée */
}
}
La communication se fera via l'application Arduino Manager, qui contrôle directement le contrôleur via le système d'exploitation iOS. Si nécessaire, modifiez le paramètre de vitesse de connexion de la carte Bluetooth HM-10.
// Connecter HM10
// Broche 7/TXD
// Broche 8/RXD
#si défini(ARDUINO_AVR_UNO)
#inclure
LogicielSérie monSérie(7 , 8 ); // Émission, Réception
#fin si
#si défini(ARDUINO_AVR_MEGA2560)
#define monSerial Serial3
#fin si
#définir DEVICE_SPEED 9600
#définir CONSOLE_SPEED 9600
vide
installation() {
Série.begin(CONSOLE_SPEED);
Mode Pin( 7
,SORTIR);
Mode Pin( 8
, SAISIR);
MySerial.begin(DEVICE_SPEED);
Serial.println("Prêt");
}
vide
boucle() {
carboniserc;
si(Série.disponible()) (
C = Série.read();
MonSerial.print(c);
si(monSérie.disponible()) (
C = monSerial.read();
Impression en série(c);
}
}
conclusions
Pour créer un tel mécanisme de verrouillage, vous aurez bien sûr besoin d'une carte Arduino, de servos et de l'écriture d'un programme de contrôle et d'autres composants, en fonction de la tâche. L'appareil sera contrôlé sur un iPad ou un iPhone via Bluetooth via l'application Arduino Manager. Cette application est téléchargée depuis l'App Store et est conçue pour gérer plusieurs appareils. Il dispose d’un réglage de contrôle simple et d’un capteur de rétroaction. Le générateur de code permet de créer une infrastructure de communication entre une carte Arduino et un appareil iOS et de générer du code pour chaque appareil sélectionné. Il est également possible d'utiliser un widget prêt à l'emploi pour contrôler l'appareil.
Arduino permet d'expérimenter et d'appliquer ce microcontrôleur à divers appareils. L'application Arduino Manager contrôle ces appareils depuis votre iPad ou iPhone.
Liste bibliographique
- Projets utilisant le contrôleur Arduino. Petin V. A. Saint-Pétersbourg "BHV-Pétersbourg" 2014. Pp. 18-19. Page 47.
- Arduino, capteurs et réseaux pour la communication des appareils. Par. de l'anglais. - 2e éd. - Saint-Pétersbourg : BHV-Pétersbourg, 2015. Pp. 102.
- Carnet du programmeur Arduino. Brian W Evans Publié : Première édition Auqust 2007 Page 9-10.
- Blynk est un environnement de développement de widgets basé sur le cloud pour iOS et Android. Ressource d'accès au réseau :
