Création d'un pont infrarouge avec SmartThings ThingShield

Composants et fournitures

Arduino UNO

SmartThings Shield pour Arduino

LED émettant des infrarouges

Diode du récepteur infrarouge

Résistance 100 Ohm (facultatif)

À propos de ce projet

Présentation

Une simple télécommande de téléviseur est capable de changer beaucoup plus de chaîne lorsqu'elle est connectée au cloud SmartThings. Avec un petit nombre de pièces et un gain immédiat, le projet est un bon moyen d'explorer la plate-forme.

Contexte sur Arduino et ThingShield

Le SmartThings ThingShield facilite la création de prototypes SmartThings à l'aide d'Arduino. Le shield se connecte directement à l'UNO se connectant au hub SmartThings via le protocole Zigbee. Un switch sur le shield permet de choisir entre utiliser les pins 0,1 ou 2,3 pour communiquer avec l'Arduino. Le ThingShield se réserve déjà l'utilisation de la broche 6.

Pour plus d'informations sur la prise en main d'Arudino :http://arduino.cc/en/Guide/Introduction

Étape 1 :Vous aurez besoin

(x1) SmartThings Arduino ThingShield
(x1) Arduino Uno
(x1) Récepteur IR
(x1) LED émettant des infrarouges
(x1) Résistance 100 Ohm (en option)

Étape 2 :Téléchargez la bibliothèque IR

Le projet repose sur une merveilleuse bibliothèque Arduino développée par Ken Shirriff. https://github.com/shirriff/Arduino-IRremote

Installez la bibliothèque Arduino de la manière habituelle.

http://arduino.cc/en/Guide/Bibliothèques

Une fois installé, nous devons modifier IRRemoteInt.h pour utiliser la minuterie sur la broche 9. Dans cet exemple, nous utilisons la broche 3 pour la communication avec le ThingShield.

Étape 3 : esquisse Arduino

Ensuite, téléchargez le croquis sur votre carte Arduino (voir la section code).

Étape 4 :La construction

La construction est simple et directe. Connectez d'abord le ThingShield au-dessus de l'Arduino. Bien que seul l'Arduino soit illustré dans le schéma ci-dessous, les emplacements des broches sont les mêmes avec le blindage attaché.

Pour le récepteur IR, connectez les broches correspondantes à la terre et au 5V. Ensuite, connectez la broche de données à la broche Arduino 11. Connectez la LED émettant des infrarouges à la broche 9 et à la terre. La résistance de 100 ohms est facultative dans cette conception car la LED peut probablement gérer le courant maximal de l'Arduino car elle clignote rapidement pour envoyer des signaux. Laissé allumé en continu, le même courant brûlerait probablement la LED.

Étape 5 :Création d'un type d'appareil SmartThings personnalisé

Dans l'IDE SmartThings, nous créons ensuite un nouveau type de périphérique pour notre ThingShield.

Allez dans la section "Mes types d'appareils", cliquez sur "Nouveau SmartDevice" sur la droite.

La création d'un nouveau SmartDevice nécessite deux étapes. Tout d'abord, donnez un nom au nouveau type d'appareil en haut "Ir Bridge". Notez que nous référencerons le nom de notre SmartDevice dans notre code SmartApp plus tard.

Nous devons définir les attributs (variables) et les commandes (fonctions) de l'appareil. Pour ce tutoriel, nous allons créer les attributs et les commandes pour deux boutons programmables et un bouton d'enregistrement. Ajoutez chacun des attributs et commandes affichés. Sélectionnez « Créer » pour continuer le codage de l'appareil.

Ensuite, copiez la définition du périphérique dans la fenêtre de code de l'IDE (voir la section code). Cliquez sur le bouton « Enregistrer » en haut, puis sur « Publier » pour mettre l'appareil à votre disposition.

Étape 6 :Mise à jour de ThingShield vers votre nouveau type d'appareil

Assurez-vous d'ajouter votre ThingShield à votre hub SmartThings s'il n'est pas déjà configuré. Pour jumeler l'appareil, attachez le ThingShield à votre Arudino et mettez-le sous tension. Maintenez le bouton « Switch » sur le bouclier pendant 6 secondes. Avec l'application pour smartphone SmartThings, sélectionnez le bouton Ajouter. Appuyez une fois de plus sur le bouton physique « commutateur » et vous devriez voir le hub identifier le ThingShield.

De retour, dans l'IDE, accédez à votre Arduino ThingShield en cliquant sur « périphériques » sur l'écran d'accueil. Sélectionnez votre appareil dans la liste et cliquez sur le bouton « Modifier » en bas de la page. Dans le menu déroulant "Type", choisissez le nouveau type de SmartDevice que vous avez créé. Il est utile de donner aux appareils des noms d'étiquettes significatifs lorsque vous devez les sélectionner ultérieurement. Appuyez sur Mettre à jour pour configurer l'appareil sur votre nouveau type d'appareil.

Notez que lors de la publication des mises à jour de vos types d'appareils personnalisés à l'avenir, vous souhaiterez revenir pour confirmer que vos appareils physiques sont restés associés au type d'appareil correct après une mise à jour publiée.

Étape 7 :Écriture de l'application SmartThings

Nous avons un autre morceau de code dans le projet - la SmartApp elle-même. Accédez à « Mes SmartApps » et démarrez une « Nouvelle SmartApp » en cliquant sur le bouton à droite. Donnez-lui un nom, une description et une catégorie (« Mes applications »). Cliquez sur « Créer » pour continuer à coder l'application.

Copiez le code smartApp (voir section code). Sélectionnez « Enregistrer », puis cliquez sur « Publier » pour rendre la SmartApp disponible sur votre application Smartthings iOS ou Android (à venir).

Notez que nous référençons le type SmartDevice par son nom comme « IrBridge » sans l'espace d'origine que nous avons utilisé à l'origine dans le nom « Ir Bridge » :

saisir "irDevice", "device.IrBridge"

La ligne nous permet d'afficher uniquement les appareils de type « Ir Bridge » comme options à sélectionner dans la SmartApp. Le camelCasing utilisé est très spécifique :lors du référencement des types d'appareils dans les applications intelligentes, les espaces sont supprimés du nom. Le premier caractère et les caractères qui suivent à l'origine un espace sont en majuscule. Tous les autres sont en minuscules, quelle que soit la casse d'origine.

Étape 8 :Activez la SmartApp

Dans l'application pour smartphone SmartThings, associez la nouvelle SmartApp à notre nouveau périphérique IR et sélectionnez les commutateurs que vous souhaitez contrôler. Cliquez ensuite sur « installer ».

Pour programmer chacun des boutons de l'application, accédez aux détails de la vignette en cliquant sur l'engrenage dans le coin de la vignette. Sélectionnez le gros bouton d'enregistrement - il deviendra rouge pour indiquer que vous êtes en mode d'enregistrement. Cliquez ensuite sur la tuile (Lecture/Pause ou B) que vous souhaitez contrôler – elle deviendra jaune. Dirigez votre télécommande vers le ThingShield et appuyez sur le bouton que vous souhaitez apprendre. Le ThingShield enverra maintenant ce code au cloud SmartThings et l'associera au bouton que vous avez choisi dans la SmartApp. Le bouton nouvellement programmé deviendra vert et le bouton d'enregistrement redeviendra blanc.

La prochaine fois que vous appuierez sur ce bouton de votre télécommande, vous basculerez le commutateur que vous avez associé au bouton dans la SmartApp.

Code

Croquis Arduino
Définition de l'appareil
code smartApp

Croquis ArduinoC/C++

//************************************************ ********************************/// @file/// @brief/// Bouclier IR Arduino SmartThings/ /****************************************************** **************************#include // TODO doit être défini en raison d'un lien de langage filaire étrange, devrait nous absorbons toute cette bibliothèque dans smartthings#include #include //****************************** ******************************************************** // Définitions des broches | | | | | | | | | | | | | | | | | | | | | | | | | | | | |// VVVVVVVVVVVVVVVVVVVVVVVVVVVVV//************************************************ **********************************#define PIN_LED 13#define PIN_RECV 11#define PIN_THING_RX 3#define PIN_THING_TX 2 //****************************************************** ******************************** // Variables globales | | | | | | | | | | | | | | | | | | | | | | | | | | | | |// VVVVVVVVVVVVVVVVVVVVVVVVVVVVV//************************************************ ********************************SmartThingsCallout_t messageCallout ; // appel de la fonction décalaration avancéeSmartThings smartthing(PIN_THING_RX, PIN_THING_TX, messageCallout); // constructorbool isDebugEnabled; // activer ou désactiver le débogage dans cet exemple int stateLED ; // état pour suivre la dernière valeur définie de LEDIRrecv irrecv(PIN_RECV);IRsend irsend;decode_results results;//****************************** ******************************************************** // Fonctions API | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |// VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//************************************************ ********************************void setup(){ // configurer l'état par défaut des variables globales isDebugEnabled =true; LED d'état =0 ; // correspond à l'état de la broche matérielle définie ci-dessous // configure les broches matérielles pinMode(PIN_LED, OUTPUT); // définit PIN_LED comme sortie digitalWrite(PIN_LED, LOW); // définir la valeur sur LOW (off) pour correspondre à stateLED=0 if (isDebugEnabled) { // configurer le port série de débogage Serial.begin (9600); // configuration série avec un débit en bauds de 9600 Serial.println("setup.."); // affiche 'setup..' au démarrage } irrecv.enableIRIn(); // Démarrer le récepteur}//****************************************** ************************************* void loop () { // exécute la logique smartthing smartthing.run (); if (irrecv.decode(&results)) { blue(); irrecv.resume(); // Recevoir la valeur suivante Serial.println(results.value, HEX); //dump(&results); //EXEMPLE :smartthing.send("HEX,XXXCODE"); Chaîne irCmd; if (results.decode_type ==NEC) { irCmd =String(results.value, HEX) + "," + "NEC" + String(results.bits, DEC) + ":" + String(results.value, HEX); } else if (results.decode_type ==SONY) { irCmd =String(results.value, HEX) + "," + "SNY" + String(results.bits, DEC) + ":" + String(results.value, HEX); } else if (results.decode_type ==RC5) { irCmd =String(results.value, HEX) + "," + "RC5" + String(results.bits, DEC) + ":" + String(results.value, HEX); } else if (results.decode_type ==RC6) { irCmd =String(results.value, HEX) + "," + "RC6" + String(results.bits, DEC) + ":" + String(results.value, HEX); } else { irCmd =String(results.value, HEX) + "," + "RAW" + String(results.bits, DEC) + ":"; } Serial.println(irCmd); smartthing.send(irCmd); irCmd =""; }}//************************************************ *******************************void messageCallout(String message){ smartthing.shieldSetLED(0, 0, 0); // si le débogage est activé, imprime le message reçu if (isDebugEnabled) { Serial.print("Rx:'"); Serial.print(message); Serial.println("' "); } Type de chaîne =message.substring(0,3) ; int startCode =message.indexOf(':'); Chaîne lenStr =message.substring(3,startCode); Chaîne codeStr =message.substring(startCode + 1); code long non signé ; //transforme la chaîne hexadécimale en un long non signé if(type !="RAW") code =stringToNum(codeStr,16); //ne fonctionnera pas pour RAW int len =stringToNum(lenStr,10); //Pour chaque type - NEC,SON,PAN,JVC,RC5,RC6,etc... les 3 premiers if(type =="NEC") { Serial.println("NEC-SEND"); Serial.println(len); Serial.println(code,HEX); irsend.sendNEC(code,len); irrecv.enableIRIn(); } else if(type =="SNY") { irsend.sendSony(code,len); irrecv.enableIRIn(); } else if(type =="RC5") { irsend.sendRC5(code,len); irrecv.enableIRIn(); } else if(type =="RC6") { irsend.sendRC6(code,len); irrecv.enableIRIn(); } }// Vide la structure decode_results.// Appelez ceci après IRrecv::decode()// void * pour contourner le problème du compilateur//void dump(void *v) {// decode_results *results =(decode_results *) vvoid dump(decode_results *results) { int count =results-> rawlen; if (results->decode_type ==UNKNOWN) { Serial.print("Encodage inconnu :"); } else if (results->decode_type ==NEC) { Serial.print("Decoded NEC:"); } else if (results->decode_type ==SONY) { Serial.print("Decoded SONY:"); } else if (results->decode_type ==RC5) { Serial.print("Decoded RC5:"); } else if (results->decode_type ==RC6) { Serial.print("Decoded RC6:"); } else if (results->decode_type ==PANASONIC) { Serial.print("Decoded PANASONIC - Address:"); Serial.print(results->panasonicAddress,HEX); Serial.print(" Valeur :"); } else if (results->decode_type ==JVC) { Serial.print("Decoded JVC:"); } Serial.print(résultats->valeur, HEX); Serial.print(" ("); Serial.print(results->bits, DEC); Serial.println(" bits)"); Serial.print("Raw ("); Serial.print(count, DEC); Serial.print("):"); for (int i =0; i rawbuf[i]*USECPERTICK, DEC); } else { Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC); } Serial.print(" "); } Serial.println("");}//****************************************** *************************************** // Fonctions locales | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |// VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//************************************************ ********************************** chaîne longue non signéeToNum(String s, int base) //10 pour décimal, 16 pour hex{ long non signé i =0 ; valeur longue non signée =0 ; endroit long non signé =s.length(); caractère c; signe long non signé =1 ; for(i; i ='0' &&c <='9') //0 à 9 { value +=( c - '0') * exponent(base,place); } else if (c>='A' &&((c - 'A' + 10) ='a' &&(c - 'a' + 10)

Définition de l'appareilGroovy

/** * Smart Ir * * Auteur :[email protected] * Date :2013-03-06 */metadata { // Simulateur de métadonnées de simulateur {} // Tuiles de définitions de tuiles d'interface utilisateur { standardTile("recStatus", "device.recStatus", largeur :2, hauteur :2, canChangeIcon :true, canChangeBackground :true) { état "off", étiquette :"record", action :"record", backgroundColor :"#ffffff" état "on" , label :'record', action :"record", backgroundColor :"#ff0000" } //il s'agit d'une tuile secondaire //set, unset, prog - green, white, yellow standardTile("buttonA", "device.buttonAStatus ", largeur :1, hauteur :1, canChangeIcon :true, canChangeBackground :true) { état "unset", libellé :'', action :"buttonA", icône :"st.custom.buttons.play-pause", backgroundColor :"#cccccc" //état gris "prog", libellé :'', action :"boutonA", icône :"st.custom.buttons.play-pause", backgroundColor:"#FDE910" //état jaune "set ", label :'', action :"buttonA", icon :"st.custom.buttons.play-pause", backgroundColor :"#79b821" //green } //set, unset, prog - green, white, y ellow standardTile("buttonB", "device.buttonBStatus", largeur :1, hauteur :1, canChangeIcon :true, canChangeBackground :true) { état "unset", étiquette :'', action :"buttonB", icône :"st .custom.buttons.b", backgroundColor:"#cccccc" //état gris "prog", label:'', action:"buttonB", icon:"st.custom.buttons.b", backgroundColor:"#FDE910 " //yellow state "set", label :'', action :"buttonB", icon :"st.custom.buttons.b", backgroundColor:"#79b821" //green } //possible principales tuiles main ([ "buttonA","buttonB"]) // ceci est un tableau pour les détails de plusieurs tuiles (["recStatus","buttonA","buttonB"]) }}// Analyse les messages entrants de l'appareil pour générer eventsdef parse(String description) { log.trace "parse :" valeur def =zigbee.parse(description) ?.text def codeParts =value.split(/,/) log.trace "code :${codeParts[0]}" //[0] est l'hexadécimal, [1] est le renvoi //de [1], les trois premiers caractères sont le type, suivis du code if(device.currentValue("recStatus") =="on") //en mode d'enregistrement { log .trace "enregistrement activé" if(device.cur rentValue("lastButton") !="") { log.trace "le dernier bouton est actif" def buttonStatus ="${device.currentValue("lastButton")}Status" ; def buttonHex ="${device.currentValue("lastButton")}Hex" ; def buttonCode ="${device.currentValue("lastButton")}Code" ; def result =[ createEvent(name:buttonStatus, value:"set", isStateChange:true) //tourner le bouton vert ,createEvent(name:buttonHex, value:codeParts[0], isStateChange:true) //stocker le code, createEvent(name:buttonCode, value:codeParts[1], isStateChange:true) //stocker le code ,createEvent(name:"recStatus", value:"off", isStateChange:true) ,createEvent(name:"lastButton", value:"", isStateChange:true) //réinitialiser le dernier bouton ] return result } else{ log.trace "aucun bouton sélectionné" } } else { //si non //vérifier qu'il correspond à tous les boutons if(codeParts[ 0] ==device.currentValue("buttonAHex")) { //envoyer un événement lié à buttonA def result =createEvent(name:"button", value:"A",isStateChange:true) log.debug "Parse return $ {result?.descriptionText}" return result } else if(codeParts[0] ==device.currentValue("buttonBHex")) { //envoyer un événement lié à buttonB def result =createEvent(name:"button", value:"B", isStateChange:true ) log.debug "L'analyse a renvoyé ${result?.descriptionText}" ret urn result } } def result =createEvent(name:null, value:"") return result}def record(){ //entrer en mode d'enregistrement log.debug "RecordMode change de ${device.currentValue("recStatus")}" clearLast() //effacer le dernier bouton //activer/désactiver l'attribut if(device.currentValue("recStatus") =="on") { sendEvent(name:"recStatus", value:"off", isStateChange:true ) //la couleur de la tuile passe au blanc } else { sendEvent(name:"recStatus", value:"on", isStateChange:true) //la couleur de la tuile passe au rouge }}def buttonA(){ log.debug "ButtonA pressed" if(device.currentValue("recStatus") =="on") //si en mode enregistrement, définir le bouton à programmer { clearLast() log.debug "Mettre le boutonA en mode de programmation" //définir l'attribut lastTile sur tileA // le vire en jaune sendEvent(name:"buttonAStatus", value:"prog", isStateChange:true) sendEvent(name:"lastButton", value:"buttonA", isStateChange:true) } else if(device.currentValue(" buttonAStatus") =="set") //s'il est défini, envoyez le code stocké { log.debug "Send buttonA Code" //envoyez le code à distance vers le blaster zigbee.smartShield(text:"${device.currentValue("buttonACode")}").format() } else { log.debug "le bouton est actuellement ${device.currentValue("buttonAStatus")} " }}def buttonB(){ clearLast() log.debug "ButtonB pressed" if(device.currentValue("recStatus") =="on") //si en mode enregistrement, définir le bouton à programmer { log.debug "Mettre le bouton en mode programmation" //définir l'attribut lastTile sur tileA //le rendre jaune sendEvent(name:"buttonBStatus", value:"prog", isStateChange:true) sendEvent(name:"lastButton", value:"buttonB ", isStateChange:true) } else if(device.currentValue("buttonBStatus") =="set") //si il est défini, envoyez le code stocké { log.debug "Send buttonB Code" //envoyez le code distant à le blaster zigbee.smartShield(text:"${device.currentValue("buttonBCode")}").format() } else if(device.currentValue("buttonBStatus") =="unset") { log.debug "bouton est actuellement non défini" }}def clearLast(){ if(device.currentValue("lastButton") !="") { sendEvent(name:"${device.current Value("lastButton")}", value:"unset", isStateChange:true) sendEvent(name:"lastButton", value:"", isStateChange:true) }}

code smartAppGroovy

/** * Récepteur IR * * Auteur :[email protected] * Date :31/03/2013 */preferences { section("Choisissez un périphérique IR...") { input "irDevice", "device .IrBridge" } section("Le bouton A s'allume ou s'éteint..."){ input "switch1", "capability.switch", titre :"Cette lumière", requis :false } section("Le bouton B s'allume ou s'éteint ..."){ input "switch2", "capability.switch", title:"This light", required:false } }def Install() { log.debug "Installed with settings:${settings}" subscription(irDevice , "button.B", handleB) subscription(irDevice, "button.A",handleA)}def updated() { log.debug "Mise à jour avec les paramètres :${settings}" unsubscribe() subscription(irDevice, "button. B", handleB) subscription(irDevice, "button.A",handleA)}def handleA(evt) { log.debug "reçu le bouton A" if (switch1.currentValue("switch") =="on") { switch1 .off() } else { switch1.on() }}def handleB(evt) { log.debug "bouton B reçu" if (switch2.currentValue("switch") =="on") { switch2.off() } else { switch2.on() }}

Contrôleur de testeur Arduino DMX-512 Transformez (presque) n'importe quelle surface en bouton tactile avec MPR121

Processus de fabrication

impression en 3D

Système de contrôle d'automatisation

Technologie industrielle