Pentru a schimba fără fir informații între diferite dispozitive pe distanțe scurte, puteți utiliza tehnologia Bluetooth. În aceste scopuri, industria chineză produce diverse module Bluetooth, printre care modelele HC-05 și HC-06 au devenit foarte populare. La un moment dat, am achiziționat un HC-06 de pe Aliexpress, pe care îl voi efectua experimente suplimentare, precum și îl voi conecta la analogul meu chinezesc al Arduino.

Direct modulul Bluetooth în sine. În această formă, poate fi folosit în diverse dispozitive, unde este lipit direct în placă. Modulul are 34 de pini, inclusiv: pini pentru conectarea la un computer prin UART, transmisie audio folosind metoda PCM (modularea codului de impulsuri), intrare și ieșire analogică, pini pentru conectarea la un conector USB, interfață SPI, precum și general- porturi de scop. De fapt, nu toți acești pini sunt disponibili pentru acces la pinii de transmisie audio (5-8), intrarea și ieșirea analogică (9, 10), precum și la grupul de contacte pentru conectarea la USB (15, 20) este blocat.

HC-06 este construit pe un cip BC417 (dispozitiv BlueCore4-External), specificație Bluetooth V2.0. Există, de asemenea, cuarț de 26 MHz și memorie flash de 8 MB la bord. Alimentarea este de la 3,3V.

Pentru modelele dvs., cel mai convenabil este să utilizați un modul cu o placă de breadboard, pe care sunt afișate contactele necesare pentru conexiuni și există, de asemenea, un stabilizator de tensiune care vă permite să fiți alimentat de la 5 volți.
La achiziționarea unor astfel de module, este posibil să întâlniți diferite marcaje. În esență, acesta este același dispozitiv, care diferă în firmware-ul care determină modul modulului (master / slave).

Diferența dintre HC-05 și HC-06 este că HC-05 poate fi folosit ca master sau slave. Aceste moduri sunt setate folosind comenzi AT. Un buton de pe placa modulului îl comută în modul de intrare comandă AT. Modul master permite modulului să detecteze singur un astfel de dispozitiv și să organizeze comunicarea cu acesta. Modulul HC-06 poate funcționa doar într-un singur mod slave fix.

Există și modele HC-03 și HC-04, dar sunt produse în scopuri industriale.

Desemnarea contactelor pe placa HC-06.

STAT- verificarea starii modulului. Acest pin dublează semnalul care este afișat de LED-ul încorporat în placă. Dacă clipește foarte repede, modulul este într-o stare activă. În modul de comunicare, curentul este de 30-40 mA. Când modulul stabilește comunicarea cu un alt dispozitiv, LED-ul pur și simplu se aprinde. În modul de transfer de date, curentul este de 8 mA.
RX- primirea datelor.
TX- transfer de date.
GND- se conectează la masă.
+5V- alimentare +5 Volti
RO- porniți/opriți modulul. Dacă aplicați 1 logic (5 volți) acestui contact, modulul se va opri dacă aplicați 0 logic sau nu vă conectați la acest contact, modulul va funcționa.

Implicit, HC-06 are un nume pentru detectarea de către alte dispozitive " HC-06", cu cod PIN " 1234 ».

Pentru a modifica aceste date, trebuie să conectați modulul la computer și să introduceți comenzi AT folosind un program terminal. Acest lucru se poate face folosind un adaptor USB la COM cu niveluri TTL. Un adaptor pentru PL2303HX, CH340G sau altul similar este potrivit pentru aceste scopuri. Până în acest moment, driverul pentru adaptorul USB ar trebui să fie deja instalat pe computer.

Conectăm contactele după cum urmează:

Când conectați acest ansamblu la computer, LED-ul roșu de pe placa modulului Bluetooth va începe să clipească rapid. Pentru a introduce comenzi AT, puteți folosi orice program de terminal, folosesc Arduino IDE în acest scop.

În setări, selectați numărul portului COM virtual la care este conectat adaptorul USB, în cazul meu este COM44. Hai sa deschidem fereastra" Monitor de port serial».

Introdu comanda cu majuscule „ LA", dacă dispozitivul s-a conectat cu succes, răspunsul ar trebui să revină" Bine" Rata implicită de schimb de date este de 9600 baud.

Pentru a verifica versiunea de firmware, introduceți comanda „ AT+VERSIUNE", în cazul meu răspunsul a revenit" OKlinvorV1.8».

Echipa" AT+NAMEaaaa", Unde Wow- un set arbitrar de caractere în latină, putem schimba numele cu care va fi găsit modulul dispozitivului nostru bluetooth (HC-06 implicit). În exemplul meu, am introdus „ AT+NAMEfox", răspunsul este returnat OKsetname.

Echipa" AT+PINxxxx", Unde xxxx– un set aleatoriu de numere, puteți schimba codul PIN (implicit 1234). Răspunsul revine" OKsetPIN».

Echipa" AT+BAUDx", Unde x– valoare de la 1 la 9, puteți modifica viteza de transmisie (implicit 9600).

1 - 1200
2 - 2400
3 - 4800
4 - 9600
5 - 19200
6 - 38400
7 - 57600
8 - 115200
9 - 230400
De exemplu, dacă rulăm comanda „ AT+BAUD8", unde 8 este viteza de 115200 baud, răspunsul va reveni" OK115200».

Conectarea HC-06 la Arduino.

Exemplul 1. Să încărcăm o schiță pe Arduino, cu care vom aprinde și stinge LED-ul, lipit pe pinul 13 al Arduino, prin modulul Bluetooth.

Dacă nu aveți acest LED pe placă, conectați-l la pinul 13 conform diagramei, valorile rezistenței pot fi luate de la 220 Ohm la 1 kOhm.

Dezactivați Arduino și conectați HC-06. Contact TX conectați modulul la contact RX Arduino (pinul 0 de pe placa UNO) și pinul RX, pentru a contacta TX(pin 1). Contacte +5VŞi GND, conectați-vă la pinii Arduino corespunzători.

Structură asamblată. Odată ce Arduino este alimentat, LED-ul de pe HC-06 ar trebui să clipească rapid.

Controlul Arduino prin HC-06 folosind un computer.

Voi arăta un exemplu pe Windows XP. Orice adaptor USB Bluetooth trebuie să fie conectat la computer și driverele instalate pe acesta.

În cazul meu, am folosit acest adaptor.

Când este conectat la un computer, în tavă apare o pictogramă corespunzătoare (lângă ceas).

Faceți clic dreapta pe această pictogramă și selectați „ Adăugați un dispozitiv Bluetooth».

Setați comutatorul " Dispozitivul este instalat și gata pentru a fi descoperit" și faceți clic pe " Următorul».

Modulul nostru Bluetooth va apărea în lista de dispozitive detectate, cu noul nume pe care l-am schimbat mai devreme. Selectați-l și faceți clic pe „ Următorul».

În fereastra următoare, introduceți codul PIN pentru a vă conecta la modul selectând „ Utilizați cheia de acces din documentație:». Valoarea implicită este „1234” dar l-am schimbat în „9999”. Faceți clic pe " Următorul».

Modulul Bluetooth a comunicat cu succes cu computerul, ceea ce poate fi văzut în fereastra corespunzătoare. Vă rugăm să rețineți că atunci când se formează o conexiune între două dispozitive Bluetooth, două porturi COM virtuale noi vor fi create pe computer (vor fi afișate în managerul de dispozitive), unul pentru datele de ieșire, celălalt pentru datele de intrare. Vom avea nevoie de un port pentru datele de ieșire, în cazul meu este COM45.

Să deschidem din nou un program terminal, voi folosi IDE-ul Arduino. În setări, selectați portul de ieșire (am COM45), deschideți „ Monitorul portului serial", introduceți comenzile" 1 " Și " 0 " La comanda „1” LED-ul se aprinde, la „0” se stinge.

Controlați Arduino prin HC-06 folosind un smartphone.

Probabil că toate smartphone-urile moderne au deja Bluetooth încorporat. Tot ce rămâne este să instalezi programul terminal. In cazul meu a fost folosit Lumia 640DS, cu instalat Windows Mobile 10. Folosesc „” ca program terminal. Pe smartphone-urile Android totul este similar, puteți folosi „; Terminal Bluetooth».

Pentru posesorii de smartphone-uri Apple, nu va fi posibil să lucreze cu modulele Bluetooth HC-05 și HC-06 (Bluetooth V2.0), vor trebui să folosească adaptoare cu tehnologie BLE (Bluetooth low energy), specificație Bluetooth 4.0; Un reprezentant proeminent este modulul HM-10.

Asociem HC-06 cu Bluetooth-ul smartphone-ului.

1. În „ Parametrii» smartphone selectați elementul « Dispozitive».
2. Următorul " Bluetooth și alte dispozitive».
3. Porniți glisorul Bluetooth al smartphone-ului și faceți clic pe „ plus pătrat» pentru a căuta și adăuga un nou dispozitiv Bluetooth, în cazul nostru HC-06.

4. În secțiunea „ Adăugați dispozitivul„selectați „”.
5. Smartphone-ul va căuta dispozitive Bluetooth în zonă și va afișa numele acestora. În exemplul meu, a fost găsit modulul HC-06, pe care l-am redenumit în „ vulpe».

6. Introduceți codul PIN al dispozitivului la care ne conectăm, apăsați butonul „ Conectați-vă».

Instalați și lansați programul terminal „”. Modulul HC-06 conectat la smartphone este afișat în listă, selectați-l.

Va apărea un câmp pentru introducerea comenzilor și un buton pentru trimitere. Introduceți alternativ „ 1 " Și " 0 „și urmăriți LED-ul de pe pinul 13, care se va aprinde sau se va stinge.

Exemplul 2. Să conectăm trei LED-uri la Arduino și să încercăm să le controlăm prin modulul Bluetooth HC-06.

Am conectat LED-urile la pinii 9, 11 și 13 dacă folosiți alți pini, trebuie să fie indicați în schiță.

La încărcarea unei schițe, modulul HC-06 trebuie deconectat de la Arduino, deoarece atât computerul, cât și Bluetooth funcționează prin UART. Arduino nu poate funcționa cu mai multe dispozitive pe un singur UART.

Lansăm programul terminal și încercăm schița în acțiune. Semnificația controlului LED este după cum urmează: există trei LED-uri, fiecare dintre acestea putând fi fie pornit, fie oprit. Rezultă 6 echipe. Echipele sunt numerele de la 1 la 6 ( 1, 3, 5 - aprinde LED-urile 1, 2 și 3. 2, 4, 6 - rambursare). Numerele pot fi introduse pe rând sau în combinații. De exemplu: 145 - aprinde primul, stinge al 2-lea, aprinde al 3-lea.

Exemplul 3. Să conectăm modulul releu din articolul „” la Arduino și să încercăm să controlăm o sarcină puternică prin Bluetooth. În esență, vom avea o „priză inteligentă”. Puteți conecta diverse sarcini (becuri, pompe, ventilatoare) la modulele de relee și le puteți controla de la distanță.

O schiță pentru acest exemplu va apărea în curând.

Trebuie să controlați de la distanță placa Arduino și să faceți schimb de date cu alte dispozitive bluetooth? Modulele Bluetooth HC-05, HC06 vă vor ajuta să faceți față acestei sarcini.

În prima parte a articolului vom vorbi despre cum să stabilim o conexiune wireless între Arduino și un computer, iar în a doua parte despre cum să stabilim o conexiune între Arduino și un telefon Android. .

Acest articol va fi o parte integrantă în asamblarea ulterioară a unei mașini cu telecomandă.

Componente pentru repetiție (cumpărați din China):

Modulele HC-05/06 sunt bluetooth goale cu cablare suplimentară.

Și anume: acestea sunt instalate pe un substrat pe care există un stabilizator de la 5 la 3,3 Volți, un LED care indică starea modulului (indiferent dacă se formează sau nu o conexiune) și condensatoare pe liniile de alimentare. Există, de asemenea, un tranzistor mosfet (Q1) instalat pe placă, care, dacă este necesar, poate rupe circuitul de alimentare bluetooth, oprindu-l, dar acesta nu va fi folosit în revizuirea noastră.

Din partea din față modulul arată așa

Conectarea la Arduino

Când modulul este alimentat, LED-ul încorporat începe să clipească.

1) Cu un computer (sistem de operare WIN7)

2) Cu un telefon (OS ANDROID)

În ambele cazuri va trebui să facem 2 actiuni: asociați modulul și dispozitivul, controlați prin intermediul unui terminal.

Partea 1. Conectarea la un computer (WIN7)

Dacă computerul dvs. nu are Bluetooth încorporat, îl puteți utiliza. Găsirea acestuia în magazinele de comunicații sau pe piețele radio nu este dificilă.

După instalarea driverelor pentru Bluetooth, puteți începe să lucrați.

. Acțiunea 1

Accesați panoul de control, faceți clic pe pictograma Bluetooth și selectați „Afișați dispozitivele Bluetooth”

După un timp, computerul va căuta și veți vedea modulul dvs. (modulul dvs. poate avea un nume diferit).

Selectați a doua opțiune - „Introduceți codul de asociere a dispozitivului”

Pentru HC-06, acest cod este 1234

Totul se termină cu această imagine.

Și după aceea mai e altul

Prima etapă de configurare este finalizată

În cazul în care uitați ce port COM ați identificat drept bluetooth, puteți afla întotdeauna urmând acești pași:

Acțiuni

P.S. Sau caută în managerul de dispozitive

. Actul 2

Orice terminal poate fi folosit pentru a transfera date. Am folosit simplu și gratuit „Termite”.

De exemplu, vom schimba starea LED-ului „LED 13” încorporat în placa Arduino. Se va porni la primirea simbolului „W” și se va opri când este primit „S”. Schița de mai jos trebuie să fie încărcată pe placa Arduino. Când turnați în placă, trebuie să deconectați alimentarea de la modulul Bluetooth, după umplere, reconectați.

exemplu de cod de program:

În setări, selectați portul nostru, viteza (9600).

De asemenea, puteți verifica modulul fără Arduino, scurtând pur și simplu pinii TX și RX. Semnele de termite au trimis caractere în albastru și au primit caractere în verde. Aceste. Dacă am trimis cu pinii scurtcircuitați și am primit același lucru, înseamnă că modulul funcționează corect. Acest lucru este demonstrat în fotografia de mai jos.

Partea 2. Conectarea cu telefonul (Android)

Subiectul de testare va fi un telefon Samsung Galaxy Ace 2 care rulează sistemul de operare Android.

. Acțiunea 1

Conectarea la telefon

. Actul 2

Ca terminal, vom alege din nou unul simplu și gratuit, dar de data aceasta „Terminal Bluetooth”

P.S. Dacă nu vă puteți conecta, deconectați alimentarea de la Bluetooth și reconectați.

În prezent, în magazinele străine și interne puteți găsi un număr mare de module seriale Bluetooth diferite pentru dispozitive DIY. Prețul pentru ele nu este foarte mare: 5-10 USD per modul (inclusiv livrare gratuită în orice țară). Acestea pot fi găsite cu ușurință pe binecunoscutul site AliExpress introducând una dintre expresiile în bara de căutare: Bluetooth RS232, Bluetooth Serial, HC-03, HC-04, HC-05, HC-06 sau fă clic pe acest link.

Majoritatea modulelor folosesc cipul BC417 plus memorie Flash. Cipul acceptă specificația Bluetooth v2.0 + EDR, comenzi AT, poate funcționa în modul Master sau Slave (module HC-03/HC-5, poate fi setat prin comandă AT), acceptă rate de transmisie de la 2400 la 1382400.
Tensiunea de alimentare a modulului este de 3,3 V, consumul de curent este de ~50 mA.
Modulele HC-03/HC-05 sunt mai funcționale decât HC-04/HC-06.

Principalele concluzii ale modulelor HC-04/HC-06:
UART_TX (pin 1), UART_RX (pin 2), UART_CTS (pin 3), UART_RTS (pin 4) - pini UART.
3.3V (pin 12) - sursa de alimentare 3.3V.
GND (pin 13) - comun.
PIO1 (pin 24) - indicator mod de funcționare. Dacă conexiunea nu este stabilită, LED-ul clipește, dacă este stabilită, este aprins constant.

Există unele diferențe pentru modulele HC-03/HC-05. UART și liniile de alimentare sunt aceleași, dar:
PIO8 (pin 31) - indicator de mod de funcționare.
PIO9 (pin 32) - starea conexiunii, dacă conexiunea este stabilită, ieșirea va fi ridicată.
PIO11 (pin 34) - intrare pentru a activa modul de comandă AT (trebuie furnizat log. 1).

Pentru documentație mai detaliată, consultați PDF-ul.

Deci, haideți să punem împreună un circuit simplu pentru conectarea modulului Bluetooth HC-06 la placa Arduino Nano V3.

Vă rugăm să rețineți că pinii TX și RX de pe placa Arduino Nano sunt schimbați, spre deosebire de Arduino UNO și altele. Prin urmare, uitați-vă cu atenție la pinout-ul plăcii Arduino.

Pasul dintre pinii din modul este de numai 1,5 mm, așa că va trebui să luați un fier de lipit și să lipiți firele la modul. Un total de 5 fire trebuie lipite, dar nu este necesar să conectați LED-ul, acesta servește pentru a indica starea.

Deci, lipiți firele și conectați modulul Bluetooth după cum urmează:
Ieșire Arduino 3.3V - la pinul 12 al modulului
Ieșire Arduino GND - la pinul 13 al modulului
Ieșire Arduino TX - la pinul 2 al modulului RX
Ieșire Arduino RX - la pinul 1 al modulului TX

Transferarea datelor de la Arduino prin Bluetooth

Int cnt = 0; // contor void setup() ( Serial.begin(9600); // inițializare port ) void loop() ( cnt++; Serial.print("Bună ziua BB de la Arduino! Counter:"); // afișa Serial.println( cnt ); // afișează valoarea contorului și o mutați la o nouă întârziere de linie (1000) // așteptați 1 secundă);

După cum puteți vedea, schița este destul de simplă și bine comentată. În ciclu, o dată pe secundă, variabila cnt este mărită, care este apoi transmisă cu un mesaj text către portul serial de pe modulul Bluetooth. Vă rugăm să rețineți că viteza portului este setată la 9600. Când cumpărați un modul, întrebați la ce valoare este setată rata de transmisie a interfeței seriale. Dar în cele mai multe cazuri este 9600. Dacă este necesar, cursul de schimb poate fi modificat folosind comenzile AT.

Deschideți această schiță în Arduino IDE, compilați și flashați-vă Arduino. Dacă ați conectat LED-ul în modulul Bluetooth, acesta ar trebui să clipească, indicând astfel că modulul așteaptă o conexiune.

Atenţie! Dacă flasherul înjură atunci când clipește placa Arduino, atunci opriți sursa de alimentare de 3,3 V de la modulul Bluetooth.

Pe computer, cel mai ieftin adaptor USB Bluetooth chinezesc a fost folosit ca modul Bluetooth, costând aproximativ 200 de ruble. După ce adaptorul este conectat la computer, instalați driverele necesare (în Windows 7 x64, toate driverele au fost instalate automat).
Apoi faceți clic pe pictograma modulului Bluetooth din tavă și selectați „Adăugați dispozitiv”:

Numele modulului meu este BOLUTEK, cel mai probabil al tău va fi diferit. Faceți clic pe „Următorul” și accesați fereastra în care trebuie să introduceți parola pentru dispozitiv:

Selectați al doilea element: „Introduceți codul de asociere a dispozitivului”. Din fabrică, codul este setat la 1234. Îl introducem. Programul va configura și înregistra porturi COM virtuale în sistem (eu am înregistrat 2, dar poate fi unul):

În viitor, puteți vedea ce port COM este alocat și parametrii acestuia. Pentru a face acest lucru, faceți clic dreapta pe dispozitiv și selectați „Proprietăți” și fila „Hardware”. Acolo puteți vizualiza și modifica parametrii portului COM virtual:

Acum, puteți utiliza orice program terminal pentru a primi și transmite date către portul COM virtual. L-am folosit pe cel gratuit. De fiecare dată când porniți programul, vi se solicită să selectați o conexiune, să comutați caseta de selectare la Serial și să selectați portul COM al modulului Bluetooth. Pentru mine este COM4.

În terminal vedem datele contorului de pe placa Arduino:

După cum puteți vedea, datele sunt transmise cu succes prin conexiunea Bluetooth. Mai jos în articol puteți urmări videoclipul.

Comunicare Bluetooth bidirecțională

Următorul pas este să scrieți un program simplu pentru schimbul de date bidirecțional între Arduino și computer. Am adăugat un LED la circuit conectându-l la pinul 12 al Arduino printr-un rezistor de limitare a curentului. Dar puteți folosi și LED-ul încorporat (de obicei 13 pini).

Char incomingByte; // date primite int LED = 12; // LED-ul este conectat la pinul 12 void setup() ( Serial.begin(9600); // inițializarea portului pinMode(LED, OUTPUT); Serial.println("Apăsați 1 pentru LED-ul ON sau 0 pentru LED-ul OFF... ") ; ) void loop() ( dacă (Serial.available() > 0) ( //dacă au ajuns datele incomingByte = Serial.read(); // citește octetul if(incomingByte == "0") ( digitalWrite( LED, LOW ); // dacă 1, apoi stinge LED-ul Serial.println("LED OFF. Apăsați 1 pentru LED-ul ON!" // și imprimați înapoi mesajul) if(incomingByte == "1") (); digitalWrite(LED, HIGH) ; // dacă este 0, atunci porniți LED-ul Serial.println("LED ON. Apăsați 0 pentru LED-ul OFF!");

Programul funcționează foarte simplu. După pornirea sau resetarea dispozitivului, pe portul serial este afișat un mesaj care vă cere să apăsați 1 sau 0. În funcție de numărul apăsat, LED-ul se va aprinde sau se va stinge. Și, de asemenea, Arduino va afișa un mesaj dacă LED-ul este pornit sau stins.

Și lucrează cu el.

Upgrade scut motor

S-a dovedit că producătorii modulului Motor Shield și-au privat clienții de posibilitatea de a instala un alt modul deasupra produsului lor. Se pare că le place să fie deasupra sau doar strâng panoul de contact normal.

Nuanța asta nu mi se potrivește deloc. De aceea am decis să iau fierul de lipit și să aduc motor Shield într-o formă convenabilă pentru mine.

Am rupt cu grijă prizele de contact originale și le-am aruncat.

Le-am montat pe cele normale in locul lor.

În această formă, modulul a devenit mult mai convenabil de utilizat. Acum pot conecta corect firele Bluetooth la conectori și nu le pot lipi strâns la contactele de pe motor Shield.

Modul Bluetooth JY-MCU pentru Arduino

Modulul Bluetooth JY-MCU în sine este destul de mic. Setul de livrare include un cablu de conectare. Atribuțiile pinului sunt afișate pe verso.

Poate fi alimentat de la o sursă de alimentare de 3,6-6V. Acest lucru ne oferă posibilitatea de a-l conecta direct la Arduino fără a folosi un regulator sau divizor de tensiune.

Cod folosit la conectarea la dispozitiv: 1234.

Conectarea Bluetooth JY-MCU la Arduino Mega 2560

Conexiunea este destul de simplă.

Schema oficială de conectare:

• TXT pe JY-MCU se conectează la RX (0) pe Arduino
• Conectați RXD pe JY-MCU la TX (1) pe Arduino

Cu această opțiune de conectare, va trebui să opriți alimentarea modulului Bluetooth de fiecare dată înainte de a încărca schița. Nu uita de asta.

Nu sunt mulțumit de această opțiune, așa că am decis să folosesc porturi discrete cu suport serial.

Diagrama de conectare neoficială:

• VCC pe JY-MCU este conectat la +5V Arduino
• Conectați GND pe JY-MCU la GND Arduino
• TXT pe JY-MCU conectat la PIN-ul discret 50 pe Arduino
• Conectați RXD pe JY-MCU la PIN-ul discret 51 pe Arduino

Acum puteți încărca schițe fără a opri modulul Bluetooth.

Pentru a asigura Bluetooth-ul, am decis să folosesc o placă Proto Shield și o placă miniaturală fără lipire. Pe viitor voi conecta alte echipamente, comenzi și afișaje la el.

Schiță pentru controlul unui robot pe Arduino prin Bluetooth prin intermediul unui smartphone Android

În schița mea am implementat următoarele funcții:

• Mergând înainte
• Mișcarea înapoi
• Viraj la stânga
• Obligatoriu Dreapta
• Viraj lis la stânga când mergeți înainte
• Rotire lină la dreapta când mergi înainte
• Viraj lis la stânga când vă deplasați înapoi
• Viraj ușor la dreapta atunci când vă deplasați înapoi
• Stop

Setarea vitezei 0%

Setarea vitezei 10%

Setarea vitezei 20%

Setarea vitezei 30%

Setarea vitezei 40%

Setarea vitezei 50%

Setarea vitezei 60%

Setarea vitezei 70%

Setarea vitezei 80%

Setarea vitezei 90%

Setarea vitezei 100%

Am folosit funcții în schiță pentru a nu duplica codul pentru evenimente similare.

#include // Conectați biblioteca de control al motorului
#include // Conectați biblioteca pentru servo
#include // Conectați biblioteca pentru a lucra cu seriale prin porturi discrete

//Creează obiecte pentru motoare
AF_DCMotor motor1(1); //canal M1 pe motor Shield - spate stânga
AF_DCMotor motor2(2); //canal M2 pe motor Shield - spate dreapta
AF_DCMotor motor3(3); //canal M3 pe motor Shield - față stânga
AF_DCMotor motor4(4); //canal M4 pe motor Shield - față dreapta

// Creați un obiect pentru servo
Servo vsservo;

SoftwareSerial BTSerial(50, 51); // RX, TX

// Creați o variabilă pentru comenzile Bluetooth
char vcmd;
// Creați variabile pentru a reține viteza motoarelor
int vspdL, vspdR;
/* Creați o variabilă a cărei valoare va scădea viteza în timpul virajelor netede.
Viteza curentă trebuie să fie mai mare decât această valoare. În caz contrar, motoarele din sensul de rotație pur și simplu nu se vor roti */
int vspd = 200;

void setup() (
// Setați rata de transfer de date Bluetooth
BTSerial.begin(9600);
// Setați viteza de transfer de date prin cablu
Serial.begin(9600);
// Selectați pinul la care este conectat servo-ul
vservo.attach(9); // sau 10, dacă este conectat la conectorul cel mai exterior
// Rotiți servo la 90 de grade de fiecare dată când este pornit
vservo.write(90);
// Setați viteza maximă de rotație a motoarelor
vviteza(255,255);
}

void loop() (
// Dacă există date
dacă (BTSerial.available())
{
// Citiți comenzile și puneți-le într-o variabilă. char convertește codul caracterului de comandă într-un caracter
vcmd = (char)BTSerial.read();
// Trimiteți o comandă către port, astfel încât acestea să poată fi verificate în „Port Monitor”
Serial.println(vcmd);

// Înainte
dacă (vcmd == "F") (
vforward();
}
// Înapoi
dacă (vcmd == "B")
{
vbackward();
}
// Stânga
dacă (vcmd == "L")
{
vleft();
}
// Corect
dacă (vcmd == "R")
{
dreapta();
}
// Drept și stânga
dacă (vcmd == "G")
{
vforwardleft();
}
// Drept și drept
dacă (vcmd == „eu”)
{
vforwardright();
}
// Înapoi și în stânga
dacă (vcmd == "H")
{
vbackwardleft();
}
// În spate și în dreapta
dacă (vcmd == "J")
{
vbackwardright();
}
// Stop
dacă (vcmd == "S")
{
vrelease();
}
// Viteza 0%
dacă (vcmd == "0")
{
vviteza(0,0);
}
// Viteza 10%
dacă (vcmd == "1")
{
vviteza(25,25);
}
// Viteza 20%
dacă (vcmd == "2")
{
vviteza(50,50);
}
// Viteza 30%
dacă (vcmd == "3")
{
vviteza(75,75);
}
// Viteza 40%
dacă (vcmd == "4")
{
vviteza(100.100);
}
// Viteza 50%
dacă (vcmd == "5")
{
vviteza(125,125);
}
// Viteza 60%
dacă (vcmd == "6")
{
vviteza(150,150);
}
// Viteza 70%
dacă (vcmd == "7")
{
vviteza(175,175);
}
// Viteza 80%
dacă (vcmd == "8")
{
vviteza(200.200);
}
// Viteza 90%
dacă (vcmd == "9")
{
vviteza(225,225);
}
// Viteza 100%
dacă (vcmd == "q")
{
vviteza(255,255);
}
}
}

// Înainte
void vforward() (
vspeed(vspdL,vspdR);
vforwardRL();
}

// Redirecționează pentru RL
void vforwardRL() (
motor1.run(ÎNAINTE);
motor2.run(ÎNAINTE);
motor3.run(ÎNAINTE);
motor4.run(ÎNAINTE);
}

// Înapoi
void vbackward() (
vspeed(vspdL,vspdR);
vbackwardRL();
}

// Înapoi la RL
void vbackwardRL() (
motor1.run(ÎNAPOI);
motor2.run(ÎNAPOI);
motor3.run(ÎNAPOI);
motor4.run(ÎNAPOI);
}

// Stânga
void vleft() (
vspeed(vspdL,vspdR);
motor1.run(ÎNAPOI);
motor2.run(ÎNAINTE);
motor3.run(ÎNAPOI);
motor4.run(ÎNAINTE);
}

// Corect
void vright() (
vspeed(vspdL,vspdR);
motor1.run(ÎNAINTE);
motor2.run(ÎNAPOI);
motor3.run(ÎNAINTE);
motor4.run(ÎNAPOI);
}

// Înainte și stânga
void vforwardleft() (
dacă (vspdL > vspd) (
vspeed(vspdL-vspd,vspdR);
}
altfel
{
vspeed(0,vspdR);
}
vforwardRL();
}

// Înainte și dreapta
void vforwardright() (
dacă (vspdR > vspd) (
vspeed(vspdL,vspdR-vspd);
}
altfel
{
vspeed(vspdL,0);
}
vforwardRL();
}

// Înapoi și în stânga
void vbackwardleft() (
dacă (vspdL > vspd) (
vspeed(vspdL-vspd,vspdR);
}
altfel
{
vspeed(0,vspdR);
}
vbackwardRL();
}

// În spate și în dreapta
void vbackwardright() (
dacă (vspdR > vspd) (
vspeed(vspdL,vspdR-vspd);
}
altfel
{
vspeed(vspdL,0);
}
vbackwardRL();
}

// Stop
void vrelease())(
motor1.run(RELEASE);
motor2.run(RELEASE);
motor3.run(RELEASE);
motor4.run(RELEASE);
}

// Schimbați viteza
void vspeed(int spdL,int spdR)(
dacă (spdL == spdR) (
vspdL=spdL;
vspdR=spdR;
}
motor1.setSpeed(spdL);
motor2.setSpeed(spdR);
motor3.setSpeed(spdL);
motor4.setSpeed(spdR);
}

Program Bluetooth RC Car - controlul unei mașini robot de pe un smartphone Android

Am instalat programul Bluetooth RC Car pe smartphone-ul meu. După părerea mea, acesta este cel mai bun software pentru controlul unei mașini robot.

Programul vă permite să transmiteți comenzi atunci când apăsați butoane sau să răspundeți la datele de la accelerometrul din smartphone, să reglați viteza de mișcare cu un glisor, să aprindeți luminile din față și din spate, să porniți și să opriți semnalul sonor, să porniți și să opriți semnalul de urgență.

Programul necesită versiunea Android 2.3.3 sau o versiune ulterioară. Dimensiunea programului este de 3 megaocteți.

Lista comenzilor:

• F – înainte
• B – spate
• L – stânga
• R – corect
• G – drept și stânga
• I – drept și la dreapta
• H – înapoi și stânga
• J – înapoi și dreapta
• S – opriți
• W – farul aprins
• w – farul este stins
• U – farul spate aprins
• u – farul spate este stins
• V – semnalul sonor este pornit
• v – semnalul sonor este oprit
• X – semnalul de urgență este pornit
• x - semnalul de urgență este oprit
• 0 – viteza de miscare 0%
• 1 – viteza de miscare 10%
• 2 – viteza de miscare 20%
• 3 – viteza de miscare 30%
• 4 – viteza de miscare 40%
• 5 – viteza de miscare 50%
• 6 – viteza de miscare 60%
• 7 – viteza de miscare 70%
• 8 – viteza de miscare 80%
• 9 – viteza de miscare 90%
• q – viteza de miscare 100%

După cum puteți vedea, terenul de testare pentru creativitate este destul de bun. De asemenea, aș adăuga și posibilitatea de a aprinde luminile din dreapta și din stânga separat pentru farurile din față și din spate.

Am evidențiat cu aldine comenzile care sunt deja suportate în schiță. Restul îl voi folosi în alt scop.

Principiul transmiterii comenzilor: atunci când apăsați un buton din program, comanda este transmisă prin Bluetooth o dată, iar când butonul este eliberat, comanda S-stop este transmisă imediat.

Demonstrație de muncă

Data viitoare plănuiesc să conectez un telemetru cu ultrasunete la robot și să implementez un algoritm de evitare a obstacolelor.

Dacă vă amintiți, pentru aceasta a trebuit să utilizați un Arduino suplimentar cu un Joystick Shield. Mai mult, tot acest design s-a dovedit a fi destul de greoi și incomod, mai ales având în vedere că joystick-ul trebuie alimentat de la ceva, precum și faptul că NRF24L01 necesită un adaptor suplimentar cu stabilizator de tensiune pentru a funcționa. Prin urmare, astăzi vom analiza o abordare alternativă, care este utilizarea modulului Bluetooth HC-05.

Nota: Există un modul similar HC-06. Spre deosebire de HC-05, care poate fi atât master cât și slave, HC-06 poate fi doar slave. În rest, HC-05 și HC-06 sunt practic la fel. Există și modulele HC-07, HC-08 și HC-09. Puteți citi despre diferențele dintre ele.

HC-05 are șase pini, dar avem nevoie doar de patru dintre ei: VCC, GND, RX și TX. În plus, vom lipi temporar un fir suplimentar la pinul 34 al modulului Bluetooth EGBT-045MS utilizat direct în HC-05 pentru a schimba numele sub care dispozitivul va fi vizibil. Dacă sunteți mulțumit de numele implicit, „HC-05”, atunci nu trebuie să lipiți nimic. Deci, conectăm pinii VCC și GND la pinii 5V și GND ai Arduino, pinul TX al HC-05 la pinul 2 și pinul RX la pinul 3 și, în final, pinul 34 al EGBT-045MS la pinul 4 al Arduino.

Designul rezultat:

Răspunsul la întrebarea unde să căutați acest al 34-lea pin pe EGBT-045MS este conținut în:

Exemplu de cod de firmware:

#include
#include

/* Conectați HC-05 TX la Arduino RX și HC-05 RX la Arduino TX */
Software Serial Bluetooth(2 , 3 ) ;

/* RX, TX */
const int pin34 = 4 ;

bool newline_printed = fals ;
{
void setup()
Serial.println("Arduino este gata");

Bluetooth.begin(9600);
Serial.println("Bluetooth este gata");

PinMode(pin34, IEȘIRE) ;
digitalWrite(pin34, HIGH) ;
Bluetooth.println ("AT+NAME=ARDUINO-BLUETOOTH" );
digitalWrite(pin34, LOW) ;
}

buclă goală ()
{
dacă(Bluetooth.disponibil())
{
char c = Bluetooth.read();
dacă (c == "#" )
{
dacă (!newline_printed)
{
Serial.println("");
newline_printed = adevărat;
}
}
altfel
{
Serial.print(c);
newline_printed = fals ;
}
}

dacă (Serial.available())
{
char c = Serial.read();
Serial.write(c);
bluetooth.write(c) ;
}
}

Interacțiunea cu modulul are loc prin UART. Deoarece nu dorim să pierdem capacitatea de a face schimb de date cu computerul, se folosește clasa SoftwareSerial. Funcționează exact la fel ca deja familiarul Serial, dar, spre deosebire de acesta, poate folosi pini Arduino arbitrari.

Aplicând tensiune înaltă la pinul 34 al EGBT-045MS, îl comutăm în modul de execuție a comenzii AT. O listă completă a comenzilor disponibile poate fi găsită în manualul modulului Bluetooth EGBT-045MS / EGBT-046S deja menționat. În exemplul de mai sus, numele modulului este pur și simplu schimbat. După ce l-a schimbat o dată, firul în exces poate fi dezlipit în siguranță, deoarece modulul își va aminti noul nume în memoria nevolatilă.

Puteți găsi o mare varietate de aplicații Android gata făcute, potrivite pentru trimiterea de comenzi către modulul HC-05. De exemplu, mi-a plăcut foarte mult aplicația Arduino BT Joystick. Are atât o versiune plătită, cât și una gratuită cu publicitate. Interfața aplicației arată cam așa:

Faceți clic pe Conectare, găsiți dispozitivul nostru în listă, introduceți pinul 1234 și puteți trimite comenzi folosind butoane, precum și accelerometrul încorporat în telefon. Cu alte cuvinte, aplicația permite, printre altele, să controlezi Arduino prin simpla rotire a telefonului în mâinile tale b= indică faptul că următorul conține codul butonului, 0 , 1 și așa mai departe sunt codurile butoanelor. Vă rugăm să rețineți că dacă utilizatorul nu face clic pe nimic, aplicația trimite continuu ##b=0##b=0##... . Dacă ați activat utilizarea unui accelerometru în aplicație, atunci pe lângă valorile b, vor fi transmise și valorile x , y și z.

Avantajul utilizării Bluetooth este că nu trebuie să faci un joystick separat. Orice smartphone sau tabletă care rulează Android va funcționa. În plus, EGBT-045MS pare a fi un modul care poate fi dezlipit cu ușurință de la HC-05 și apoi folosit în plăci de casă.

Puteți găsi codul sursă complet pentru această postare pe GitHub. Întrebările și completările, ca întotdeauna, sunt binevenite cu căldură!