Controlarea releelor ​​cu arduino prin Internet. Principiul de funcționare al unui tranzistor pentru controlul lin al unei benzi LED. Verificarea schemei de conectare

Până în prezent, sisteme precum „ casă inteligentă„Din un exotism uimitor, accesibil doar celor mai bogați oameni, au devenit banale, la care se poate alătura oricine. Există multe dintre care să alegeți: mulți dezvoltatori au stăpânit producția unor astfel de sisteme hardware și software. Una dintre cele mai cunoscute este compania Arduino, ale cărei produse le vom familiariza acum.

Ce este o „casă inteligentă”

Acest termen are un analog mai ușor de înțeles - „automatizare acasă”. Esența unor astfel de soluții este asigurarea execuției automate diverse procese, care apar într-o locuință, birou sau unități specializate. Cel mai simplu exemplu este pornire automată iluminarea în momentul în care unul dintre rezidenți intră în cameră.

Sistemul de casă inteligentă Arduino este un set de echipamente pentru controlul muncii diverse dispozitive folosind un telefon mobil Android

În orice sistem de casă inteligentă, se pot distinge următoarele componente:

Sistemele moderne de casă inteligentă sunt împărțite în mai multe tipuri:

1. Echipat cu propriul controler.
2. Folosind procesorul computerului unui utilizator (tabletă, smartphone) în această calitate.
3. Prelucrarea informațiilor folosind un server la distanță deținut de compania de dezvoltare (serviciu cloud).

Sistemul poate nu numai să activeze un anumit dispozitiv, ci și să informeze utilizatorul despre evenimentul care a avut loc prin trimiterea unui mesaj către telefon sau într-un alt mod. Astfel, i se pot atribui functii de alarma, inclusiv alarma de incendiu.

Scenariile pot fi mult mai complexe decât am descris în exemple. De exemplu, puteți învăța sistemul să pornească cazanul și să transfere alimentarea apa fierbinte la acesta atunci când alimentarea centralizată este oprită, dacă este detectată prezența unuia dintre rezidenți în casă (senzorii infraroșii, ultrasonici, precum și senzorii de mișcare ajută).

Cunoașterea Arduino

Arduino este o companie italiană dedicată dezvoltării și producției de componente și software Pentru sisteme simple„casa inteligenta” destinata nespecialistilor. Este de remarcat faptul că acest dezvoltator a făcut arhitectura sistemelor pe care le-a creat complet deschisă, ceea ce a făcut posibil ca producătorii terți să dezvolte și să copieze dispozitive compatibile cu Arduino existente, precum și să lanseze software pentru acestea.

Kit-ul Arduino Uno conține componentele necesare implementării dispozitivelor descrise în cartea inclusă

Această abordare a asigurat o popularitate ridicată pentru sistemele companiei italiene, dar are și un dezavantaj: datorită faptului că, ca să spunem așa, toți cei care nu sunt prea leneși preiau producția de componente pentru sistemele Arduino, nu este întotdeauna este posibil să achiziționați un produs de înaltă calitate de prima dată. De multe ori trebuie să ne confruntăm cu problema compatibilității componentelor de la diferiți producători.

Utilizatorii potențiali ar trebui să știe că din 2008 există două companii care produc produse sub marca Arduino. Primul, care a început această direcție, are un site oficial la www.arduino.cc; al doilea, nou format - la www.arduino.org. Ceea ce a fost dezvoltat înainte de scindare este prezentat identic pe ambele site-uri, dar gama de produse noi este deja diferită.

Software-ul pentru sistemele de casă inteligentă Arduino ia forma unui shell software (numit IDE) în care puteți scrie și compila programe. Distribuit gratuit. Programele sunt scrise în C++.

Versiuni de program Arduino IDE, prezentate pe aceste site-uri, sunt și ele foarte diferite, deși au același nume nu numai, ci și numere de versiune. Din această cauză, sunt destul de ușor de confundat. Diferența este că fiecare software acceptă propriile biblioteci și plăci.

„Hardware-ul” sistemului constă dintr-o placă cu un microcontroler (placă de procesor) și plăci de expansiune instalate pe ea, care sunt denumite în mod obișnuit scuturi. Conectarea scutului la placa procesorului vă permite să adăugați noi componente la casa inteligentă. Sistem asamblat poate fi complet autonom sau poate funcționa împreună cu un computer printr-un cablu standard sau interfață fără fir.

Poate fi instalat pe placa procesorului extensii speciale(scuturi) care măresc funcționalitatea sistemului

Avantajele sistemului Arduino

Acest complex hardware și software atrage utilizatorul cu următoarele avantaje:

• posibilitatea de funcționare autonomă datorită prezenței propriului controler;
• oportunități ample de personalizare a funcționării sistemului (utilizatorul însuși scrie un program care poate conține scenarii de orice complexitate);
• simplitatea procesului de încărcare a programului în controler: nu este necesar un programator pentru aceasta, este suficient să aveți un cablu USB (microcontrolerul are firmware Bootloader);
• costul accesibil al componentelor din cauza absenței drepturilor de monopol de la unul sau altul producător (arhitectura este deschisă).

Dacă Bootloader a început să funcționeze defectuos sau microcontrolerul achiziționat nu l-a avut, utilizatorul are posibilitatea de a-l flash el însuși. ÎN coajăÎn acest scop, IDE-ul oferă suport pentru un număr dintre cei mai accesibili și populari programatori. În plus, aproape toate plăcile de procesor Arduino au un antet care permite programarea în circuit.

Programul Arduino IDE prezentat pe site-ul arduino.cc include posibilitatea de a crea platforme hardware și software personalizate, în timp ce versiunea programului de pe arduino.org nu are o astfel de funcție.

Ce soluții oferă Arduino?

Deoarece multe companii sunt angajate în producția de senzori și dispozitive compatibile cu Arduino, gama acestor produse este destul de largă. Iată ce este folosit cel mai des:

Unele dintre aceste dispozitive sunt incluse în baza Kit Arduino Start, care este numit StarterKit de unii producători.

Set de pornire Sistemul Arduino include o placă de procesor și mai multe dispozitive utilizate în mod obișnuit

Partea executivă conține un set imens de dispozitive, de exemplu:

• motoare electrice;
• relee și diverse întrerupătoare;
• dimmer-uri (vă permit să schimbați fără probleme intensitatea luminii);
• închizători de uși;
• supape și supape cu 3 căi cu servomotorizări.

Dacă intenționați să vă conectați prin releu Arduino iluminat, este mai corect să le folosiți ca lămpi becuri LED. Lămpile cu incandescență ard rapid atunci când sunt conectate prin astfel de relee.

Video: începerea cu Arduino - controlul LED-ului prin interfața web

Crearea unui proiect pe Arduino

Procesul de creare și configurare " casă inteligentă» Vom arăta Arduino folosind exemplul unui sistem care va include următoarele funcții:

• monitorizarea temperaturii exterioare și interioare;
• urmărirea stării ferestrei (deschis/închis);
• monitorizarea conditiilor meteo (senin/ploios);
• generaţie semnal sonor când un senzor de mișcare este declanșat dacă funcția de alarmă este activată.

Vom configura sistemul astfel încât datele să poată fi vizualizate folosind aplicație specială, precum și un browser web, adică utilizatorul poate face acest lucru de oriunde unde există acces la Internet.

Abrevieri folosite:

1. "GND" - împământare.
2. "VCC" - sursă de alimentare.
3. "PIR" - senzor de mișcare.

Componente necesare pentru realizarea unui sistem smart home

Pentru sistemul de casă inteligentă Arduino veți avea nevoie de următoarele:

• placă cu microprocesor Arduino;
• Modul Ethernet ENC28J60;
• doi senzori de temperatură marca DS18B20;
• microfon;
• senzor de ploaie și zăpadă;
• Senzor de mișcare;
• comutator cu lamelă;
• releu;
• rezistor cu o rezistență de 4,7 kOhm;
• cablu torsadat;
• Cablu Ethernet.

Toate componentele costă aproximativ 90 USD.

Pentru a produce un sistem cu funcțiile de care avem nevoie, vom avea nevoie de un set de dispozitive care costă aproximativ 90 USD

Asamblarea unei „case inteligente”: instrucțiuni pas cu pas

Aceasta este ordinea în care trebuie să acționați.

Conectarea dispozitivelor de acționare și senzori

Conectăm toate componentele conform diagramei.

Asamblarea sistemului se reduce în principal la conectarea actuatoarelor la contactele corespunzătoare ale plăcii procesorului

Dezvoltarea codului programului

Utilizatorul scrie întregul program în shell-ul Arduino IDE, pentru care acesta din urmă este echipat cu un editor de text, manager de proiect, compilator, preprocesor și instrumente pentru încărcarea codului programului pe microprocesorul plăcii Arduino. Au fost dezvoltate versiuni IDE pentru sistemele de operare sisteme Mac OS X, Windows și Linux. Limbajul de programare este C++ cu unele simplificări. Programele de utilizator pentru Arduino sunt de obicei numite schițe sau schițe; programul IDE le salvează în fișiere cu extensia „.ino”.

Funcția main(), care este obligatorie în C++, este creată automat de shell-ul IDE, specificând un număr de acțiuni standard în ea. Utilizatorul trebuie să scrie funcțiile setup() (executat o dată în timpul pornirii) și loop() (executat într-o buclă nesfârșită). Ambele funcții sunt necesare pentru Arduino.

Fișiere antet biblioteci standard nu este nevoie să-l inserați în program - IDE-ul o face automat. Acest lucru nu se aplică bibliotecilor utilizatorilor - acestea trebuie specificate.

Adăugarea de biblioteci la IDE-ul „Manager de proiect” se realizează în mai multe moduri: într-un mod neobişnuit. La fel de textele sursă scrise în C++, acestea sunt adăugate într-un folder special din directorul de lucru al shell-ului IDE. După aceasta, numele acestor biblioteci vor apărea în meniul IDE corespunzător. Cele pe care utilizatorul le selectează vor fi incluse în lista de compilare.

IDE-ul oferă un minim de setări și nu există deloc posibilitatea de a personaliza compilatorul. Astfel, un programator începător este protejat de erori.

Iată un exemplu de cel mai simplu program care face ca LED-ul conectat la pinul 13 al plăcii să clipească la fiecare 2 secunde:

void setup() ( pinMode (13, OUTPUT); // Atribuiți pinul Arduino 13 ca ieșire)

void loop () ( digitalWrite (13, HIGH); // Activați pinul 13, parametru pentru apelarea funcției digitalWrite HIGH - un semn al unui nivel logic ridicat

întârziere (1000); // Întârziere buclă pentru 1000 ms - 1 secundă

digitalWrite(13, LOW); // Opriți pinul 13, apelați parametrul LOW - un semn al unui nivel logic scăzut

întârziere (1000); // bucla de întârziere pentru 1 secundă)

Cu toate acestea, în acest moment, utilizatorul nu se confruntă întotdeauna cu nevoia de a scrie personal un program: multe biblioteci și schițe gata făcute sunt postate pe Internet (consultați aici: http://arduino.ru/Reference). Disponibil program gata făcut iar pentru sistemul considerat în acest exemplu. Trebuie să fie descărcat, despachetat și importat în IDE. Textul programului este prevăzut cu comentarii care explică principiul funcționării acestuia.

Toate programele Arduino funcționează pe același principiu: utilizatorul trimite o solicitare procesorului și încarcă codul necesar pe ecranul computerului sau al smartphone-ului

Când utilizatorul face clic pe butonul „Reîmprospătare” din browser sau aplicație instalată pe smartphone, Microcontroler Arduino trimite date acestui client. Fiecare dintre paginile desemnate drept „/tempin”, „/tempout”, „/rain”, „/window”, „/alarm” primește codul programului, care este afișat pe ecran.

Instalarea aplicației client pe un smartphone (pentru sistemul de operare Android)

Pentru a primi online date de la sistemul smart home, puteți descărca o aplicație gata făcută.

Iată ce trebuie să facă proprietarul gadgetului:

Folosind această aplicație, nu numai că puteți primi informații de la sistemul de acasă inteligent, ci și le puteți controla - porniți și opriți alarma. Dacă este activat, o notificare va fi trimisă aplicației atunci când senzorul de mișcare este declanșat. Aplicația interoghează sistemul Arduino pentru activarea senzorului de mișcare o dată pe minut.

Prin activarea pictogramei „Setări”, vă puteți edita adresa IP.

Configurarea browserului pentru a funcționa cu o casă inteligentă

În bara de adrese a browserului, introduceți XXX.XXX.XXX.XXX/all, unde „XXX.XXX.XXX.XXX” este adresa dvs. IP. După aceasta, va fi posibil să primiți date din sistem și să le gestionați.

Codul de program prezentat aici vă permite să aprindeți și să stingeți lumina prin browser, în timp ce o astfel de funcție nu este implementată în aplicația pentru smartphone Android.

Lucrul cu un router

Configurarea unui cont pe noip.com

Acest pas este opțional, dar este obligatoriu dacă doriți să atribuiți un nume de domeniu adresei. Pentru a face acest lucru, trebuie să vă înregistrați pe site-ul https://www.noip.com/, să mergeți la secțiunea „Adăugați gazdă” și să introduceți adresa IP a sistemului.

După înregistrarea pe site-ul noip.com, puteți accesa sistemul nu doar prin adresa IP, ci și prin full numele domeniului

Crearea proiectului este finalizată, puteți verifica funcționalitatea sistemului.

Video: casă inteligentă folosind Arduino

Caracteristicile unor hardware Arduino

Datorită faptului că componentele compatibile cu Arduino sunt produse de multe companii terțe, a căror calitate a produselor nu este controlată de Arduino în sine, este posibil ca utilizatorul să achiziționeze o componentă care nu funcționează complet corect.

O situație similară s-a dezvoltat și în domeniul dezvoltării calculatoare personale. La un moment dat, IBM a deschis arhitectura computerelor sale, drept urmare Calculatoare compatibile cu IBMȘi componente individuale Multe companii au început să producă. Ca urmare, „echipamentul personal” de acest tip s-a răspândit pe scară largă în întreaga lume, cu toate acestea, calitatea componentelor și gradul de compatibilitate a acestora s-au dovedit în multe cazuri a nu fi cele mai bune nivel inalt. A aderat la tactica opusă Compania Apple. A limitat numărul de dezvoltatori care au avut acces la arhitectură și a implementat aceeași politică în domeniul dezvoltării software. În cele din urmă Calculatoare Apple s-au dovedit a fi mai puțin obișnuite și mai scumpe, dar calitatea lor este cu un ordin de mărime superioară dispozitivelor compatibile IBM care rulează Windows.

Utilizatorii au observat următoarele cu privire la unele componente pentru sistemele Arduino:

1. Senzor de temperatură DHT11 furnizat cu set de bază(StarterKit), dă o eroare semnificativă de 2-3 grade. Se recomandă utilizarea senzorului de temperatură DHT22 în interior, care oferă citiri mai precise, iar pentru instalarea în exterior - DHT21, care este capabil să funcționeze la temperaturi sub zero și este protejat de deteriorarea mecanică.
2. Pe unele plăci cu microprocesor Arduino, când releele conectate la ele sunt scurtcircuitate, portul COM eșuează. Din acest motiv, schița nu poate fi încărcată pe microcontroler: de îndată ce începe încărcarea, procesorul repornește. În același timp, releul face clic, portul COM este oprit și procesul de încărcare a schiței se oprește.
3. Senzorul de fereastră/uşă oferă uneori surprize sub formă de alarme false. Ținând cont de acest lucru, schița este scrisă astfel încât sistemul să producă actiune necesara numai la primirea mai multor semnale la rând.
4. Pentru a configura controlul procesului cu ajutorul palmelor, unii utilizatori, din cauza lipsei de experiență, comandă un detector de sunet cu reglare manuală a pragului în locul unui microfon. Această componentă nu este potrivită pentru astfel de scopuri, deoarece are o rază de acțiune prea scurtă: trebuie să bateți din palme nu mai mult de 10 cm de detector. În plus, acest senzor transmite semnale în impulsuri de scurtă durată, așa că dacă există o schiță mare, a cărei procesare durează un timp relativ lung, microcontrolerul pur și simplu nu are timp să le înregistreze.
5. Dispozitivul de alarmă de incendiu ar trebui să utilizeze un detector de fum mai degrabă decât un detector de incendiu. Acesta din urmă înregistrează o flacără la cel mult 30 cm de sine.
6. În cazul unei defecțiuni a microcontrolerului sau a unei erori în cod, este mai bine să utilizați relee normal închise cu comutatoare manuale conectate în serie.

Pentru a evita achiziționarea de componente de calitate scăzută, utilizatorii experimentați recomandă să studieze mai întâi recenziile despre acestea publicate pe Internet. Senzorii ieftini pot fi achiziționați în mai multe varietăți pentru a testa singuri care funcționează cel mai bine.

Poate că sistemul de acasă inteligent de la Arduino nu este de cea mai înaltă calitate, dar cea mai largă alegere componentele și costul lor accesibil l-au făcut cu siguranță unul dintre cele mai populare. Folosind sfaturile noastre, veți învăța rapid cum să creați Proiecte Arduino, automatizarea diferitelor procese de acasă.

Arduino este ideal pentru controlul oricărui dispozitiv. Microprocesorul ATmega folosește un program de schiță pentru a manipula o cantitate mare ieșiri discrete, intrări/ieșiri analog-digitale și controlere PWM.

Datorită flexibilității codului Microcontroler ATmega utilizat pe scară largă în diverse module de automatizare, inclusiv pe baza acestuia este posibil să se creeze un controler de control al luminii LED.

Principiul controlului sarcinii prin Arduino

Placa Arduino are două tipuri de porturi de ieșire: digitale și analogice (controller PWM). Un port digital are două stări posibile: zero logic și una logică. Dacă conectați un LED la el, acesta fie va lumina, fie nu.

Ieșirea analogică este un controler PWM, căruia îi este furnizat un semnal cu o frecvență de aproximativ 500 Hz cu un ciclu de lucru reglabil. Ce este un controler PWM și principiul funcționării acestuia pot fi găsite pe Internet. Prin portul analogic este posibil nu numai pornirea și oprirea sarcinii, ci și modificarea tensiunii (curentului) de pe aceasta.

Sintaxa comenzii

Ieșire digitală:

pinMode(12, OUTPUT);— setați portul 12 să fie portul de ieșire a datelor;
digitalWrite(12, HIGH);— aplicăm una logică la ieșirea discretă 12, aprinzând LED-ul.

Ieșire analogică:

analogOutPin = 3;– setați portul 3 pentru a scoate o valoare analogică;
analogWrite(3, valoare);– generăm un semnal la ieșire cu o tensiune de la 0 la 5V. Valoarea este ciclul de lucru al semnalului de la 0 la 255. La o valoare de 255, tensiunea maximă.

Modalități de a controla LED-urile prin Arduino

Doar un LED slab poate fi conectat direct prin port și chiar și atunci este mai bine printr-un rezistor de limitare. Încercarea de a conecta o sarcină mai puternică o va deteriora.

Pentru sarcini mai puternice, inclusiv benzi LED, se folosește un comutator electronic – un tranzistor.

Tipuri de comutatoare cu tranzistori

• Bipolar;
• Camp;
• Compozit (ansamblu Darlington).

Metode de conectare la încărcare
Prin tranzistor bipolar	Prin tranzistor cu efect de câmp	Prin comutator de tensiune

Când se aplică un nivel logic înalt (digitalWrite(12, HIGH);) prin portul de ieșire la baza tranzistorului, tensiunea de referință va curge la sarcină prin lanțul colector-emițător. În acest fel, puteți aprinde și opri LED-ul.

Un tranzistor cu efect de câmp funcționează într-un mod similar, dar deoarece în loc de o „bază” are un dren, care este controlat nu de curent, ci de tensiune, nu este necesar un rezistor limitator în acest circuit.

Vederea bipolară nu vă permite să reglați sarcini puternice. Curentul prin acesta este limitat la 0,1-0,3A.

Tranzistoarele cu efect de câmp funcționează cu sarcini mai puternice cu curenți de până la 2A. Pentru utilizarea încărcăturii și mai puternice tranzistoare cu efect de câmp Mosfet cu curent de până la 9A și tensiune până la 60V.

În loc de cele de câmp, puteți utiliza un ansamblu Darlington de tranzistoare bipolare pe microcircuite ULN2003, ULN2803.

cip ULN2003 și schema circuitului comutator electronic de tensiune:

Principiul de funcționare al unui tranzistor pentru controlul lin al unei benzi LED

Un tranzistor funcționează ca un robinet de apă, doar pentru electroni. Cu cât este mai mare tensiunea aplicată la baza tranzistorului bipolar sau scurgerea tranzistorului cu efect de câmp, cu atât este mai mică rezistența în circuitul emițător-colector, cu atât este mai mare curentul care trece prin sarcină.

După ce conectăm tranzistorul la portul analog Arduino, îi atribuim o valoare de la 0 la 255 și schimbăm tensiunea furnizată colectorului sau scurgerii de la 0 la 5V. Circuitul colector-emițător va trece de la 0 la 100% din tensiunea de referință a sarcinii.

Pentru a controla o bandă LED Arduino, trebuie să selectați un tranzistor de putere adecvată. Curentul de funcționare pentru alimentarea contorului LED este de 300-500mA un tranzistor bipolar de putere este potrivit pentru aceste scopuri. Pentru lungimi mai mari, va fi necesar un tranzistor cu efect de câmp.

Schema de conectare Benzi LED la arduino:

Controlul benzii RGB cu Andurino

Pe lângă LED-urile cu un singur cip, Arduino poate funcționa și cu LED-uri color. Conectând pinii fiecărei culori la ieșirile analogice ale Arduino, puteți modifica în mod arbitrar luminozitatea fiecărui cristal, obținând culoarea de strălucire dorită.

Schema de conectare pentru LED-ul Arduino RGB:

Managementul este structurat similar. bandă RGB Arduino:

Este mai bine să asamblați controlerul Arduino RGB folosind tranzistori cu efect de câmp.

Pentru control neted al luminozității se pot folosi două butoane. Unul va crește luminozitatea strălucirii, celălalt o va scădea.

Schiță de control al luminozității benzii LED Arduino

int led = 120; setați luminozitatea la un nivel mediu

void setup() (
pinMode(4, IEȘIRE); setați al 4-lea port analogic la ieșire
pinMode(2, INPUT);

pinMode(4, INPUT); setați al 2-lea și al 4-lea port digital la intrare pentru butoanele de interogare
}
buclă goală ()

butonul1 = digitalRead(2);

butonul2 = digitalRead(4);
dacă (button1 == HIGH) apăsarea primului buton va crește luminozitatea
{
led = led + 5;

analogWrite(4, led);
}
dacă (button2 == HIGH) apăsarea celui de-al doilea buton va scădea luminozitatea
{
led = led - 5;

analogWrite(4, led);
}

Când țineți apăsat primul sau al doilea buton, tensiunea furnizată contactului de control se schimbă fără probleme cheie electronică. Apoi va avea loc o schimbare lină a luminozității.

Module de control Arduino

Pentru a crea un driver complet de control al benzilor LED, puteți utiliza module de senzori.

control IR

Modulul vă permite să programați până la 20 de comenzi.

Raza semnalului este de aproximativ 8m.

Pretul setului este de 6 USD.

Pe canalul radio

Unitate cu patru canale cu o rază de acțiune de până la 100 m

Pretul setului este de 8 USD.

Vă permite să aprindeți iluminatul atunci când vă apropiați de apartament.

Fără contact

Senzorul de distanță este capabil să crească și să scadă luminozitatea luminii prin mișcarea mâinii.

Raza de actiune pana la 5 m.

Prețul modulului 0,3 USD

Cum să controlezi Arduino de la un computer prin USB. Vă vom spune cum să porniți un LED și să controlați un servomotor pe Arduino cu tastatura prin intermediul funcției Serial.available()Și Serial.read(). Aceste funcții verifică dacă microcontrolerul primește comenzi prin portul serial și apoi citesc comenzile primite introduse în monitorul serial de la computer.

Controlul Arduino prin computer

Funcţie Serial.available() Obține numărul de octeți disponibili pentru citire din portul serial. Aceștia sunt octeții care sunt trimiși de la computer și scrieți în bufferul portului serial. Bufferul monitorului serial Arduino poate stoca maximum 64 de octeți. Funcția este folosită și la conectare modul Bluetooth la Arduino și este util la depanarea dispozitivului în timpul proiectării.

Când testați și configurați diferite dispozitive controlate prin Bluetooth, de exemplu, un robot sau o barcă pe Arduino, va trebui să știți cum să controlați un LED și un servomotor prin intermediul unui computer. Prin urmare, vom lua în considerare acum controlul simplu al servomotorului printr-un computer printr-un cablu USB. În același timp, puteți trimite nu numai numere, ci și litere ale alfabetului latin prin monitor.

Cum să controlezi Arduino de la tastatură

Pentru această lecție vom avea nevoie de următoarele detalii:

• Placa Arduino Uno / Arduino Nano / Arduino Mega;
• tabla de paine;
• 1 LED și rezistor de 220 Ohm;
• 1 servomotor;
• fire mascul-mascul si barbat-fema.

Puteți lua restul actuatoarelor pentru Arduino UNO la discreția dvs. și încercați să le controlați singur prin intermediul unui computer cu prin USB cablu. Colectați la panou circuit cu un LED de la prima lecție Ce este Arduino și cum se folosește, iar după asamblarea circuitului cu un LED, încărcați următoarea schiță pe microcontroler.

Schiță. Controlul Arduino de pe un computer

int val; pinMode(13, IEȘIRE); // declar pinul 13 ca ieșire) bucla void () ( if (val == "1") (digitalWrite (13, HIGH );) // la 1 aprinde LED-ul if (val == "0") (digitalWrite (13, LOW );) // la 0 stinge LED-ul } }

Explicații pentru cod:

1. funcția Serial.available() verifică primirea comenzilor de la computer;
2. Funcția Serial.read() citește datele primite de monitorul Serial.
3. V operator condițional dacă (val == „1”) are un semn egal dublu „potrivire”, iar ghilimele simple trebuie folosite între paranteze.

După asamblarea circuitului, încărcați următoarea schiță pe placă

Schiță. Control servo drive de la computer

#include // conectează biblioteca pentru servo drive Servo servo; // declara o variabila servo de tip "servo" int val; // eliberăm memorie în controler pentru variabilă void setup() (Serial.begin(9600); // conectați port serial servo.attach(11); // leagă servo-ul la ieșirea 11) buclă goală () ( // verifică dacă sunt primite comenzi if (Serial . available ()) ( val = Serial . read (); // variabila val este egală cu comanda primită if (val == "1") ( servo.write(10); ) // la 1 întoarcem servo cu 10 if (val == "2") ( servo.write(45); ) // la 2 întoarcem servo cu 45 if (val == "3") ( servo.write(90); ) // la 3 întoarcem servo 90 } }

Explicații pentru cod:

1. În unele exemple de programe puteți găsi această opțiune pentru verificarea aspectului datelor în monitorul Serial dacă (Serial.available()>0) .
2. Puteți folosi nu numai numere, ci și litere ca comenzi. În acest caz, contează ce literă este majuscule sau minuscule.

Articolul discută despre modul de transfer Comenzi Arduino Pentru telecomandă dispozitiv periferic.

Considerat cel mai simplu exemplu: control motor DC. Sunt sigur că mulți vor fi interesați de acest exemplu, deoarece aceasta este baza pentru automatizarea casei tale inteligente. Poti folosi materialul de mai jos pentru a controla jaluzelele sau rulourile, care folosesc si motoare DC, dar cu putere mai mare. Pentru a implementa proiectul, veți avea nevoie de un Arduino și de câteva abilități de lucru cu Node.js și JavaScript.

Echipamente și software de care aveți nevoie

Pe lângă Arduino Uno și placa de circuit, veți avea nevoie de:

• Motor DC, cu o tensiune nominală de aproximativ 5 Volți, pentru a-l alimenta direct de la Arduino. Pot fi folosite chiar și motoare din jucării: mașini pentru copii etc.
• În acest proiect vom roti arborele motorului în două direcții. Dacă folosim un tranzistor, rotația va fi doar într-o singură direcție. Pentru a implementa rotația în două direcții, folosim un driver de motor.

Lista plina componentele necesare pentru proiect:

• Placa Arduino Uno R3;
• driver de motor L293D;
• motor DC 5V;
• placa de circuite si conectori.

În plus, veți avea nevoie de Node.js. În ea implementăm interfața cu utilizatorul. Descărcați Node.js

Echipamente de conectare

Trebuie să conectăm corect motorul și driverul. Mai întâi instalați driverul L293D pe placa de circuit. Vă recomandăm să instalați driverul în centrul plăcii de circuit, așa cum se arată în figura de mai jos. Șoferul începe la pista 3 și se termină la pista 10. Acum conectați pistele 8 și 9 la Arduino 5V. Pinul 5 este la pinul GND de pe Arduino. Au mai rămas 3 contacte care funcționează ca intrare și 2 ca ieșire.

Circuitul care funcționează pentru ieșire este simplu: conectăm două contacte de ieșire la contactele motorului de curent continuu. Pinii de ieșire sunt 3 și 6. Primul pin care trebuie conectat este pinul 1. Așa-numitul pin de activare. Acesta este contactul pe care îl folosim pentru a porni/opri motorul și pentru a-i modifica viteza de rotație. Conectați acest pin la pinul 6 de pe Arduino. În cele din urmă, dorim să conectăm pinii 2 și 7 de la L293D la pinii 4 și 5 de pe Arduino. Aceste contacte vor fi folosite pentru a schimba direcția de mișcare a rotorului motorului de curent continuu. Schema completă de conectare este prezentată în figura de mai jos:

Verificarea schemei de conectare

Înainte de a implementa controlul de la distanță, trebuie să vă asigurați că circuitul electric cu driverul L293D este proiectat și conectat corect. Pentru a verifica, vom implementa o schiță simplă, datorită căreia motorul va accelera și se va roti fără oprire. Pentru a face acest lucru folosim următoarea schiță:

// Inițializați contactele motorului

int motorPinPlus = 4;

int motorPinMinus = 5;

int motorPinEnable = 6;

Serial.begin(9600);

//Declară o variabilă pentru a stoca valorile vitezei

int motor_viteza;

setMotor(true, motor_speed);

// funcţie pentru controlul motorului

void setMotor (boolean înainte, int motor_speed)

Baza acestei schițe este funcția setMotor. Vom folosi aceeași funcție în restul proiectului nostru. Să ne uităm la asta mai detaliat:

// Funcție de control al motorului

void setMotor(boolean înainte, int motor_viteza)(

digitalWrite(motorPinPlus, înainte);

digitalWrite(motorPinMinus, !forward);

analogWrite(motorPinEnable, motor_speed);

Sunt două intrări implicate: direcția și viteza. Primul pas este implementarea a două operații digitalWrite() pentru a seta direcția de rotație a rotorului motorului. Un pin de pe cipul L293D primește un semnal de 5V, iar al doilea - 0 volți. Apoi folosim comanda analogWrite() pentru a modifica viteza rotorului motorului folosind modularea lățimii impulsului (PWM). Cu această funcție puteți schimba sensul de rotație al motorului. De exemplu, pentru a accelera folosim:

// Rotiți rotorul motorului într-o direcție dată

pentru (motor_speed = 0; motor_speed

setMotor(true, motor_speed);

Încărcați schița de mai sus pe Arduino și motorul ar trebui să înceapă să accelereze la viteza maximă. După aceasta, viteza va scădea la zero și accelerația va începe din nou. Dacă totul a funcționat așa cum este descris mai sus, putem trece la următoarea parte a proiectului nostru.

Punând totul împreună

Pe în această etapă Am implementat deja controlul motorului DC prin Arduino. Acum să punem totul împreună și să dezvoltăm o interfață web pentru proiectul nostru.

În primul rând, trebuie să modificăm schița Arduino, astfel încât să poată primi date de la gazdă. După aceea, folosim Node.js pentru a oferi o interfață de utilizator frumoasă. Dacă nu ați lucrat niciodată cu aplicații web, nu vă faceți griji, ghidul acoperă fiecare pas în detaliu.

Să începem cu o schiță Arduino. Aceasta este schița pe care o folosim în această parte:

// biblioteci

#include

// creează aREST

aREST rest = aREST();

// Inițializați pinii motorului

int motorPinPlus = 4;

int motorPinMinus = 5;

int motorPinEnable = 6;

void setup (void)

// începe schimbul de date prin protocolul de comunicare în serie și anunță pinii motorului

pinMode(motorPinPlus, OUTPUT);

pinMode(motorPinMinus, OUTPUT);

pinMode(motorPinEnable, OUTPUT);

Serial.begin(115200);

// dăm un nume și un ID dispozitivului nostru

rest.set_id("001");

rest.set_name ("control_motor");

// Gestionează apelurile REST

rest.maner(Serial);

Pe măsură ce studiezi schița, vei vedea că este diferită de cea anterioară. Conține același bloc pentru inițializarea contactelor motorului, dar există și aREST pentru primirea comenzilor. De exemplu, pentru a seta o anumită viteză a motorului, implementăm o solicitare de la computer precum:

Vom face solicitări similare de la panoul nostru de control pentru a gestiona alți pin. De exemplu, ace care sunt responsabile de direcție.

Ultimul bloc constă în dezvoltarea unei interfețe web pentru controlul de la distanță al vitezei motorului. Pentru aceasta vom folosi Node.js, care vă permite să dezvoltați aplicații care rulează pe partea serverului în Javascript. Acest tutorial nu este despre Node.js sau Javascript, dar punctele principale ar trebui acoperite. Desigur, toate fișierele sunt incluse pe GitHub.

Trebuie să creăm trei fișiere: fișierul principal Node.js, interfața în sine și o bucată de Javascript pentru procesarea clicurilor în interfața cu utilizatorul. Să începem cu fișierul Node.js. Codul începe cu încărcarea și configurarea modulului Express, care este un cadru pentru creație ușoară servere cu Node.js:

var express = require("express");

var app = expres();

// Declarați portul

var port = 3000;

// Afișează motorul

app.set(„vizualizare motor”, „jade”);

// Configurați un folder public

app.use(express.static(__dirname + "/public");

// Interfață

app.get("/", function(req, res)(

res.render("tabloul de bord");

După aceasta, importăm modulul Node-aREST, care asigură comunicarea între serverul nostru și placa Arduino:

var rest = require("arest")(app);

În acest fișier trebuie să stabilim și la ce port serial este conectată placa Arduino:

rest.addDevice("serial","/dev/tty.usbmodem1a12121",115200);

Desigur, trebuie să modificați această valoare în funcție de portul dvs. serial. Puteți găsi portul serial în Arduino IDE în meniul Instrumente>Port.

Să aruncăm o privire la fișierul de interfață, care se află în dashboard.jade. Jade este un limbaj care simplifică în esență scrierea de markup HTML. Jade conține o descriere a interfeței, care este apoi procesată folosind Node.js & Express. Mai jos este fișierul Jade pentru proiectul nostru. Creează două butoane (pentru direcții) și un glisor (pentru modificarea turației motorului):

h1 Control motor

button.btn.btn-block.btn-lg.btn-primary#1 Redirecționează

button.btn.btn-block.btn-lg.btn-danger#2 Reverse

input(type="range",min="0",max="255",value="0",id="motorspeed")

La sfârșit, trebuie să adăugăm Javascript pentru a gestiona clicurile utilizatorilor pe butoane și slider. Acesta este codul pentru butonul „Înainte”:

$("#1").click(function() (

$.get("/motor_control/digital/4/1", function() (

$.get("/control_motor/digital/5/0");

După cum putem vedea, pinul 4 este setat la HIGH și pinul 5 la LOW. Alte butoane funcționează exact invers. Adică, atunci când sunt apăsate, motorul se va mișca în direcția opusă.

Pentru a seta viteza motorului, detectăm când utilizatorul eliberează glisorul. Acest lucru este implementat folosind mouseup():

$("#motorspeed").mouseup(funcție())(

// Obține valoarea vitezei

viteza = $("#motorspeed").val();

// Trimite comanda

$.get("/control_motor/analog/6/" + viteza);

Acum putem trece la testarea proiectului de control de la distanță al motorului prin intermediul site-ului web. Nu uitați că tot codul sursă pentru programe poate fi găsit pe GitHub. Mai întâi, încărcați schița remote_motor pe Arduino. După aceasta, asigurați-vă că ați încărcat toate fișierele de interfață și ați configurat portul serial în fișierul principal app.js.

Accesați acest folder prin terminal și scrieți următoarele:

sudo npm install express jade arest

După aceea, rulați aplicația cu:

După aceasta, puteți accesa browserul și introduceți următoarele în bara de adrese:

http://localhost:3000

Ca rezultat, va fi afișată următoarea interfață:

Apoi puteți testa și juca. De exemplu, setând direcția de rotație sau folosind un glisor pentru a modifica viteza de rotație. Motorul ar trebui să răspundă la apăsările dvs. Puteți folosi smartphone-ul sau tableta. Pentru a face acest lucru, trebuie doar să utilizați IP-ul computerului și să schimbați în siguranță turația motorului de pe dispozitivul mobil.

Direcții suplimentare de dezvoltare a proiectului

Tutorialul de mai sus este foarte important pentru înțelegerea elementelor de bază ale controlului de la distanță al dispozitivelor dvs folosind Arduino. Baza este un proiect minimalist cu sarcini simple - schimbare de la distanță viteza și sensul de rotație al rotorului motorului de curent continuu prin intermediul unui server web. Vă recomandăm să citiți în detaliu toate explicațiile dezvăluite în articol. Acest lucru vă va oferi o bază bună pentru mai departe proiecte complexe. Completați codul, îmbogățiți-l. De exemplu, puteți adăuga o selecție de întârziere între schimbarea direcției de rotație a rotorului motorului etc. Singura limitare sunt orizonturile și entuziasmul dumneavoastră.

Lăsați comentariile, întrebările și distribuiți experienta personala de mai jos. Noi idei și proiecte se nasc adesea în discuții!

• Tutorial
• Mod de recuperare

Acest articol este destinat începătorilor. Aici se va descrie cum aplicații web cu ajutor cerere ajax ov trimite comenzi către scriptul phyton, care le va transmite prin portul serial direct către arduino.
Ți-ai cumpărat un Arduino, ai încercat câteva exemple, te-ai jucat cu schițe. Dar acest lucru nu este suficient pentru tine, vrei să gestionezi, să gestionezi toate aceste bunătăți prin Internet. Cel mai simplu mod este să achiziționați o plăcuță cu un port Ethernet și să o conectați la Arduino (sau să cumpărați o placă cu Ethernet deja încorporat). Dar, de asemenea, costă mai mult și trebuie să-l gestionați mai bine.

Pentru lucru vom avea nevoie de:
- server HTTP
- interpret python
- Arduino

Aici voi descrie de unde să obțineți primul și al doilea și cum să le împrietenești

Acum, în ordine. Eu folosesc Apache ca server HTTP. Instalarea acestuia nu este dificilă. Dacă ești un începător complet și folosești Windows, poți lua pachetul Denwer de pe site-ul oficial, acesta include Apache.
Python (am folosit versiunea 3.3) poate fi descărcat și de pe site-ul oficial și instalat. Acum trebuie să ne facem prieteni între Apache și python. Cel mai simplu mod este să rulați python ca cgi. Pentru a face acest lucru, deschideți fișierul httpd.conf din folderul conf în locul în care ați instalat apache (dacă ați instalat denwer, calea va fi cam așa: [litera unității virtuale]:\usr\local\bin\apache )

Căutăm o linie

AddHandler cgi-script .cgi

Adăugăm .py la sfârșit cu un spațiu și ne asigurăm că nu există semnul # la începutul liniei. Salvați și reporniți serverul.
Acum, pentru a testa prietenia strânsă dintre pythone și apache, puteți crea un fișier de testare și îl puteți pune în folderul de acasă.
#!/Python33/python.exe print ("STARE: 200 OK\n\n") print (" Salut Lume")
Vă rugăm să rețineți că în prima linie arătăm unde se află interpretul nostru de limbă. De exemplu, îl am la C:/Python33/python.exe. Cred că o să-ți dai seama. Numiți-l cum doriți și accesați-l printr-un browser, de exemplu, astfel: localhost/my_first_test_phyton_file.py. Dacă vezi „bună lume”, atunci totul este în regulă.

Codul scriptului de control principal din JavaScript este extrem de simplu:
//Portul la care este conectat Arduino var serialPort = "COM5"; //funcția de control direct var Arduino = function(comandă, callback)( $.get("c.py",( c:command, p:serialPort ), callback); )

Singurul lucru care trebuie schimbat aici, așa cum ați ghicit, este portul la care este conectat arduino. Îl puteți vizualiza oricând în Windows folosind Device Manager. Îl vom transfera în scriptul nostru python, astfel încât acesta să știe la ce port serial să trimită datele primite.
Acum, dacă facem un apel la funcția noastră, de exemplu: Arduino(123), atunci scriptul va crea o solicitare Ajax precum c.py?c=123&p=COM5 și o va trimite către scriptul nostru python c.py. Să ne uităm la ce este:
#!/Python33/python.exe import serial import cgi print ("STARE: 200 OK\n") req = cgi.FieldStorage(); ser = serial.Serial(req["p"].value, 9600, timeout=1) ser.write(bytes(req["c"].value,"latin")) ser.close() print ("ok" ")
De fapt, pur și simplu ia valoarea parametrului „c”, îl transmite la portul serial „p” și scrie „ok”. Ieftin și vesel.

Pentru cei care vor nu doar să dea, ci și să primească, vom scrie mai mult cod

Să ne îmbunătățim puțin partea de client.
//control direct funcția var Arduino = function(sp, errorCallback) ( this.serialPort = sp; this.errorCallback = errorCallback || function())( console.log("Eroare"); ) this.send = function(data , callback)( var callback = callback; var self = this; data["p"] = this.serialPort; data["s"] = Math.round(Math.random()*1000); //doar pentru orice eventualitate , astfel încât browserul să nu memoreze în cache $.ajax(( url:"c.py", data:data, success:function(data)( if($.trim(data) == "error")( self.errorCallback (); ) else ( if(tip de apel invers == „funcție”) callback(date); ) ) ) //trimite acest.set = funcție(comandă, apel invers)( this.send(( c:comandă, r:0) ) , callback ) //trimiteți și așteptați un răspuns this.get = function(command, callback)( this.send(( c:command, r:1 //flag responsabil pentru modul „așteptați răspuns”) , sună din nou); ) )
Acum, din moment ce am transformat Arduino într-o clasă, atunci cea mai simplă provocare va fi cam asa:
var myArduino = new Arduino ("COM5"); myArduino.set(113); //aprinde LED-ul de pe pinul 13 myArduino.get(36,function(data)(console.log(data))); //uita-te la starea pinului 6. si afiseaza-l in consola
Și, desigur, trebuie să schimbați puțin partea de server:
#!/Python33/python.exe import serial import cgi print ("STARE: 200 OK\n") req = cgi.FieldStorage(); încercați: ser = serial.Serial(req["p"].valoare, 9600, timeout=1) cu excepția: print("eroare") exit() ser.write(bytes(req["c"].valoare," latin")) if int(req["r"].value) == 1: res = ""; în timp ce nu res: res = ser.readline() print(res.decode("UTF-8")) else: print ("ok") ser.close()
Aproape nimic nu s-a schimbat aici, cu excepția faptului că atunci când serverul primește parametrul r=1 într-o solicitare, așteaptă un răspuns de la Arduino.
Și am adăugat o verificare pentru a vedea dacă scriptul nostru a putut deschide portul serial. Dacă nu, se va întoarce cuvânt cheie"eroare"

Acum să ne uităm la o schiță pentru arduino care acceptă și procesează toate acestea:
#include Servo myservo; void setup() ( Serial.begin(9600); ) String getParam())( String re; while (Serial.available()) ( re.concat(Serial.read()-48); ) return re; ) int getPin (String p)( return p.substring(0,2).toInt(); ) int getVal(String p)( return p.substring(2,6).toInt(); ) // Bucla principală void loop( ) ( while (Serial.available()) (comandă char = (char)Serial.read(); String param = getParam(); int pin = getPin(param); int p; switch (comandă) (case „0” : //Digital write pinMode(pin,OUTPUT case "1": //Digital write pinMode(pin, HIGH) = getVal(param); "3": //Digital read pinMode(pin,INPUT ) case "4": ( //Analog read int aPin = A0; switch (pin) (case 1: aPin = A1; case 2); : aPin = A2 caz 3: aPin = A3; ) pauză;
case "5": //Analog write pinMode(pin,OUTPUT); p = getVal(param); analogWrite(pin, p); pauză;
) ) )
Prin portul serial vom transmite comenzi precum: 1234567 unde:
- numărul echipei
- Numarul pin
- date pentru pin, dacă este necesar.
De exemplu:
113 - va instala pinul 13 pe ieșire și va transmite starea HIGH prin intermediul acestuia (adică, îl va porni).
013 - va seta pinul 13 la ieșire și va transmite starea LOW prin intermediul acestuia (adică, îl va opri).
209100 - va seta pinul 9 ca control al servomotor și îi va transmite valoarea 100 prin modulația PWM.
310 - va seta pinul 10 pentru a introduce și a citi date HIGH/LOW din acesta și va reveni ca 1 sau 0 în consecință.

Puteți adăuga cu ușurință propriile comenzi la blocul de carcasă comutatoare.
Acum să adăugăm puțină frumusețe părții noastre de front-end și să obținem, de exemplu, asta
Apoi, am adăugat puțină magie a interfeței cu utilizatorul. Dar nu o voi descrie oricine este interesat o poate lua din arhivă cu proiectul.
Pentru partea web am folosit Bootstrap (numai din cauza confortului și „cauciucului”) și jQuery (pentru ajax).

Dezavantajele acestei abordări includ viteza relativ lentă a schimbului de date. Pentru a afla starea, de exemplu, a unui buton, trebuie să trimiteți solicitări, dar acest lucru nu se poate face prea des, deoarece este posibil să ne întâlnim cu un port serial ocupat. Ar funcționa mai repede pe websocket-uri, dar acesta este un subiect puțin mai avansat, pe care îl voi trata mai târziu dacă doriți.
Totul a fost verificat sub Windows 8 x64. Probabil că există unele caracteristici de implementare a tuturor acestor lucruri pentru alte sisteme, voi fi bucuros să aud despre asta în comentarii.
Acum despre unde pot fi utile toate acestea: de exemplu, puteți face un stand demonstrativ; controlează poziția camerei; conectați un senzor de temperatură și alte dispozitive și monitorizați de la distanță un proces etc.

Arhiva cu proiectul
Pentru a rula pe iPad în Ecran complet Am folosit programul gratuit oneUrl

Nu l-am inserat în hub-uri tematice doar din cauza lipsei de karma.
Acesta este primul meu articol. Voi fi bucuros să vă răspund la întrebări.

UPD: La cererea muncitorilor, am testat și această metodă pe MacOS. Probleme speciale nu a apărut. Pe un Mac, python este de obicei deja instalat în mod implicit, singurul lucru pe care trebuie să-l faci este să-l împrietenești cu apache. Prima linie în c.py va fi
#!/usr/bin/python
De asemenea, este posibil să nu aveți instalată extensia pyserial, aceasta poate fi instalată cu o simplă comandă în consolă:
easy_install -U pyserial
În continuare, vă rugăm să rețineți că, de obicei, versiunea preinstalată de python este destul de veche și este posibil ca linia să nu funcționeze
ser.write(bytes(req["c"].valoare,"latină"))
L-am inlocuit cu
ser.write(bytes(req["c"].value.decode("latin")))
Totul a funcționat.
Nu uitați să vă uitați la ce port se va conecta dispozitivul dvs. Este convenabil să vizionați, de exemplu, prin intermediul Programul Arduino. Meniu Instrumente->Port serial. De exemplu, pentru mine arăta astfel: /dev/cu.usbmodemfd141
Le doresc tuturor experiențe de succes.

Etichete:

• arduino
• piton
• bricolaj sau fă-o singur
• casă inteligentă

Adaugă etichete