Un exemplu de conectare a unui modul giroscop accelerometru pentru arduino. Arduino și MPU6050 pentru a determina unghiul de înclinare

ADXL335 este un accelerometru analogic cu trei axe, adică un senzor cu care puteți obține unghiul de abatere relativă. De fapt, acestea sunt trei accelerometre diferite într-o singură carcasă, fiecare dintre ele fiind responsabil pentru propria sa axă X, Y sau Z.

În general, un accelerometru este un dispozitiv pentru măsurarea accelerației. Totuși, din cursul general de fizică școlară știm că accelerația este de două tipuri: dinamicŞi static. Cu accelerația dinamică, totul ar trebui să fie clar - au împins senzorul, i-au dat accelerație, ar trebui să-l înregistreze. Accelerația statică este efectul gravitației asupra senzorului nostru. Cert este că, chiar și în stare de repaus complet, senzorului i se aplică o accelerație statică egală cu g (accelerație gravitațională).

Senzorul ADXL335 poate detecta ambele aceste accelerații. Și cunoscând proiecțiile vectorului său, putem calcula cu ușurință unghiul cu care senzorul nostru a deviat față de o anumită valoare zero.

Imaginea arată care vor fi citirile pentru diferite poziții ale senzorului. Poziția relativă a senzorului trebuie monitorizată de un mic semn cerc alb.

Mai întâi, să ne uităm la partea dreaptă a imaginii, unde Zout (axa Z) își schimbă valoarea. Conform acestei imagini, dacă plasăm senzorul nostru cu contactele în jos, atunci valoarea de-a lungul axei Z va fi egală cu unu (mai precis, un g). Această valoare, după cum sa spus, este proiecția vectorului de accelerație statică pe axa senzorului nostru. Din moment ce în în acest caz, vectorul coincide cu axa Z, iar acceleratia gravitatiei este egala cu g, avem valoarea Zout = 1g.
Dacă întoarcem senzorul cu susul în jos, valoarea Zout se va schimba în invers. Este de remarcat faptul că toate celelalte accelerații sunt egale cu zero, acest lucru se datorează coincidenței deja menționate a vectorului de accelerație statică cu axa Z, precum și stării de repaus a întregului senzor.
Toate celelalte perechi pot fi considerate similar. Singura diferență este că senzorul va fi amplasat pe margine sau lateral.

Cu toate acestea, vectorul nu va coincide întotdeauna cu oricare dintre axe. Cel mai adesea, acest vector va fi distribuit într-un fel de-a lungul tuturor celor trei axe - deoarece spatiu tridimensional.

Despre senzorul ADXL335

• Tensiunea maximă permisă pentru ADXL335 este de 3,6 volți
• Senzorul face față accelerațiilor de până la 3g. Aceasta poate fi folosită, de exemplu, pentru a determina dacă întreaga structură este în mișcare și chiar în ce direcție se mișcă. Puteți măsura accelerația la începutul mișcării și astfel o puteți face mai lină, fără smucituri bruște.

Schema de conectare a accelerometrului

• Atenţie! Pentru alimentare, ieșirea este 3v3 Arduino, nu 5v
• Conectați ieșirile X, Y, Z ale senzorului la intrările ANALOG IN 0, 1, 2

Exemplu de cod - programare accelerometru

#define ADC_ref 5.0 #define analog_resolution 1024.0 unsigned int value_x; unsigned int valoare_y; unsigned int value_z; void setup() ( Serial.begin(9600); ) void loop() ( value_x = analogRead(0); value_y = analogRead(1); value_z = analogRead(2); Serial.print(value_x/analog_resolution*ADC_ref, 5) ); Serial.print(" ");

#define ADC_ref 5.0 #define analog_resolution 1024.0 unsigned int value_x ; unsigned int value_y ; unsigned int value_z ; void setup() ( Serial. începe(9600); ) void loop() ( valoare_x = analogRead(0); valoare_y = analogRead(1); valoare_z = analogRead(2); Serial. imprimare (value_x / analog_resolution * ADC_ref , 5 ) ; Serial. print (" " ) ; (500 ) ; }

Să notăm câteva constante. ADC_ref este valoarea maximă în volți pe care o poate elimina intrarea analogică. analog_resolution este rezoluția intrării noastre analogice. Pe arduino este 210 sau 1024.
După declararea constantelor, există câteva variabile în care vom stoca citirile luate de la senzorul nostru și vom inițializa portul serial astfel încât să putem primi câteva date pe computer.
În funcția de buclă, primim mai întâi date de la cei trei pini analogi ai noștri, la care este conectat senzorul nostru, iar după aceea recalculăm numărul rezultat în volți și le trimitem la portul serial. Să încărcăm acest firmware pe Arduino UNO, să deschidem monitorul serial (ctrl+shift+m) și să colectăm câteva date.

Pe monitorul serial pornit puteți vedea:

În cazul în care prima coloană este citirile de-a lungul axei X, a doua este Y, a treia este Z

Astăzi pe piață puteți găsi număr mare module de senzori ieftine pe care le puteți utiliza în proiectele dvs. conectându-le mai întâi la un microcontroler. Unul dintre aceste module este o placă cu un cip MMA7361, care este un accelerometru cu trei axe.

Acest senzor poate măsura accelerația statică (gravitația) sau dinamică în toate cele trei axe. Poate fi folosit în diverse aplicații și pe baza acestuia pot fi create multe aplicații. Accelerometrul măsoară nivelul de accelerație al obiectului pe care este instalat, ceea ce vă permite să obțineți informații despre accelerația/decelerația acestui obiect, precum și înclinarea acestuia față de axa pământului.

Acest senzor permite, de asemenea, detectarea căderii libere (ieșire 0G). Din punct de vedere tehnic, MMA7361LC este un accelerometru micromecanic capacitiv de putere redusă, cu procesare a semnalului, filtru trece-jos cu 1 pol, compensare de temperatură, autodiagnosticare și sensibilitate selectabilă. MMA7361LC poate intra în modul de repaus, ceea ce îl face ideal pentru dispozitivele portabile alimentate cu baterie. Modulul poate fi alimentat de la o sursă de 5 V sau 3,3 V.

Acum, folosind exemplul unei combinații a modulului MMA7361 și a plăcii Arduino UNO, vom arăta principiul de lucru cu acest senzor. Din fericire, conexiunea nu necesită niciun element suplimentar, ai nevoie doar de un Arduino, un modul cu accelerometru și fire. Circuitul și pinout sunt prezentate mai jos:

Mai jos este o schiță pentru lucrul simplu cu modulul. Folosind acest program, puteți citi valorile de ieșire de pe axele X, Y și Z folosind un monitor serial.

int x; // variabilă de ieșire de-a lungul axei x int y; // variabilă de ieșire de-a lungul axei y int z; // variabilă de ieșire de-a lungul axei z void setup() ( Serial.begin(9600); // deschide portul, rata de transfer de date este de 9600 bps ) void loop() ( x = analogRead(5); // citește intrarea A5 y = analogRead (4); // citește intrarea A4 z = analogRead(3); // citește intrarea A3 Serial.print("X = "); "); // scoateți valoarea cu y Serial.println(y); Serial.print("Z = "); // scoateți valoarea cu z Serial.println(z); delay(100); )

ADXL337 și ADXL377 sunt accelerometre compacte, subțiri, cu putere redusă, cu 3 axe, care produc volți analogici.

Principala diferență dintre aceste accelerometre este domeniul de măsurare. ADXL337 măsoară accelerațiile pe o gamă de ±3 g, iar ADXL377 funcționează pe o gamă de ±200 g și poate fi folosit pentru a măsura schimbări mai bruște în mișcarea unui obiect monitorizat și poate fi folosit pentru a evalua vibrațiile.

Acest articol vă va ajuta să înțelegeți caracteristicile utilizării datelor accelerometrului. Vor fi abordate probleme legate de conectarea accelerometrelor la Arduino. Drept urmare, le puteți integra ușor și natural în oricare dintre proiectele dvs.

Fotografia de mai jos prezintă plăci cu accelerometre instalate:

Prezentare generală și specificații tehnice ale accelerometrelor ADXL337 și ADXL377

Accelerometrele ADXL337 și ADXL377 pot (și sunt recomandate!) să fie achiziționate deja integrate într-un modul separat. Modulul are cablarea minimă necesară și contacte gata făcute pentru conectarea la Arduino sau la un alt microcontroler.

După cum puteți vedea, ambele module au același număr de pini. Tabelul de mai jos arată informaţii scurte despre fiecare dintre contactele de pe module:

Alimentare pentru accelerometrele ADXL337 și ADXL377

Aici trebuie să fii extrem de atent. ADXL337 și ADXL377 trebuie să fie alimentate ambele cu o tensiune maximă de 3,6 V! Această tensiune este aplicată pinului de alimentare și pinului de autotestare. Puteți folosi Arduino 5 V sau 3,3 V pentru a citi valorile de pe axele individuale ale accelerometrului și puteți alimenta senzorul de accelerație în sine de la 3,3 V. Dar nu uitați că valorile pe care le obțineți de la senzor după analog -conversia digitală va fi diferită la 5 V și la 3,3 IN! Prin urmare, este necesar să se clarifice intervalele în funcție de semnalul de conversie.

Unul dintre avantajele accelerometrelor ADXL337 și ADXL377 este că consumă puțin curent pentru a funcționa. Aceasta este de obicei în jur de 300 mA.

Explicații esențiale pentru utilizarea ADXL337 și ADXL377

Dacă alimentați ADXL337 sau ADXL377 la 3,3 V, o valoare de 1,65 V pe pinul axei X va corespunde unei accelerații de 0 g. Dacă pe pinul X aveți o tensiune de 3,3 V, atunci pe ADXL337 aceasta înseamnă că puterea este de 3g. În timp ce o citire de 3,3 V pe ADXL377 înseamnă că sarcina este de 200 g. În esență, ambele cipuri sunt utilizate și conectate în același mod, dar citirile vor fi diferite, deoarece depind de maximul valori acceptabile, care sunt citite de accelerometru.

Modulul ADXL377 are 4 orificii de montare deoarece acest senzor de accelerație este proiectat pentru mai mult conditii extremeîncărcături

Ambele module au condensatori de 0,01 µF lângă ieșirile de pe axele X, Y și Z, adică frecvența maximă în care puteți evalua accelerația este de 500 Hz.

Exemplu de conectare la Arduino

Cablaj

Înainte de a instala accelerometrul pe placa și de a-l conecta la Arduino, trebuie să lipiți pinii. Acestea pot fi șine separate sau doar fire. Ce anume să lipiți depinde numai de locul în care intenționați să utilizați senzorul de accelerație în viitor.

Dacă intenționați să utilizați o placă de breadboard sau o placă de circuite cu o distanță de 0,1 inchi între pini, vă recomandăm să lipiți o șină cu pini drept cu o ieșire tată. Dacă intenționați să conectați accelerometrul direct la controler, fără plăci de breadboard sau plăci de circuite, utilizați fire.

Conectarea accelerometrului la Arduino

În acest exemplu, vom vedea cum puteți utiliza controlerul Arduino Uno pentru a colecta și procesa date de la un modul de accelerometru ADXL337 sau ADXL377. Deoarece semnalul de ieșire de la senzor este analog, trebuie să conectăm trei pini de la axe de coordonate separate la pinii „Analog In” de pe Arduino. Figura de mai jos prezintă schema de conectare pentru modulul ADXL337. ADXL377 se conectează în același mod.

Puteți alimenta accelerometrul folosind pinul de 3,3 V și GND de pe Arduino. Contactele axelor X, Y și Z de la senzor sunt conectate la pinii ADC (A0, A1 și A2 în acest exemplu). Pinul de autotestare (ST) nu trebuie conectat, dar poate fi conectat la masă (GND). Dacă doriți să utilizați pinul ST pentru a verifica de două ori funcționarea senzorului, conectați-l la 3,3 V. Informații suplimentareÎn acest sens, vă puteți familiariza cu fișele de date ale senzorilor: ADXL377 și ADXL377.

Program pentru Arduino

După ce ați conectat accelerometrul la Arduino, puteți trece la programare. Puteți descărca schița completă de pe Github. Link pentru ADXL337 și pentru ADXL377. Singura diferență dintre aceste schițe este valoarea variabilei de scară.

Primele două linii de cod din schiță sunt folosite pentru a configura parametrii pentru modulul senzorului de accelerație:

scala int = 3; boolean micro_is_5V = adevărat;

Valoarea variabilei scalei este setată egală cu valoarea maximă a forței măsurate g. Pentru ADXL337, această valoare este setată la 3, iar pentru ADXL377, variabila ia valoarea 200, deoarece senzorii oferă intervale de măsurare de ±3g, respectiv ±200g. Variabila micro_is_5V este setată la adevărat dacă utilizați un controler de 5V (de exemplu, Arduino Uno) și la fals dacă utilizați un controler de 3,3 V (de exemplu, Arduino Pro Mini). Acesta este un parametru important care afectează direct interpretarea ulterioară a datelor de la senzor.

După aceasta, folosim funcția setup() pentru a inițializa conexiunea serială. Datorită acestui fapt, vom putea afișa citirile în fereastra monitorului serial Arduino IDE.

void setup() ( // stabilește comunicarea prin protocol serial cu o rată de transfer de date de 115200 baud

Serial.begin(115200); )

În cadrul funcției loop(), colectăm date de la senzor, le scalam pentru a fi afișate în unități de forță g și afișăm datele originale și convertite în fereastra monitorului serial. Mai întâi, să aruncăm o privire la modul în care sunt citite datele de la senzorul de accelerație.

void loop() ( // obține date de la accelerometru pentru fiecare axă de coordonate individuală

int rawX = analogRead(A0);

int rawY = analogRead(A1);

int rawZ = analogRead(A2);

Pentru a primi valoare numericăîn intervalul de la 0 la 1023, care corespund tensiunii la intrările Arduino, folosim intrările analogice A0, A1 și A2 și mai multe valori citite. Aceste valori de tensiune reflectă ultima valoare de accelerație măsurată de la senzor. De exemplu, dacă ADXL337 arată 3,3V pe pinul X, aceasta înseamnă că accelerația de-a lungul axei X este acum +3g. În plus, depinde de modelul controlerului tău. Dacă utilizați un microcontroler de 3,3 V, valorile analogice citite vor returna 1023 și vor fi stocate în variabila rawX. Dacă utilizați un microcontroler de 5V, valorile analogice returnate vor fi 675. Vor fi stocate în aceeași variabilă. De aceea este important să configuram corect variabila micro_is_5V, astfel încât să știm cum să interpretăm corect citirile curente.

Cunoscând tensiunea plăcii Arduino, putem scala valorile int rezultate și obținem citirile de măsurare în g unități. Mai jos este o bucată în care o folosim pentru a converti citirile obținute în unitățile de măsură necesare:

float scaledX, scaledY, scaledZ; // valori scalate pentru fiecare axă

if (micro_is_5V) // microcontrolerul funcționează cu 5 V

( scaledX = mapf(rawX, 0, 675, -scale, scale); // 3,3/5 * 1023 =~ 675

) else // microcontroler 3,3 V

( scaledX = mapf(rawX, 0, 1023, -scale, scale); )

Valorile scalate sunt stocate ca tip de date float. După aceea, verificăm ce controler avem (3,3 V sau 5 V) folosind variabila booleană micro_is_5V. Pe baza rezultatelor testului, scalam valoarea întreagă x - rawX și o transformăm într-o valoare zecimală care corespunde forței g. Variabila pentru stocarea noilor valori se numește scaledX. Facem același lucru pentru axele Y și Z Nu vom lua în considerare aceste axe în detaliu, deoarece procesul de conversie este complet identic. Este important să ne amintim că pe un Arduino de 5V obținem 675 la o tensiune de pin de 3,3V, iar un Arduino de 3,3V interpretează măsurătorile care corespund la 3,3V ca o valoare de 1023.

Funcția mapf() utilizată în schiță funcționează la fel ca și funcția standard Arduino map(). Principalul motiv pentru care este utilizat mapf() este că poate funcționa cu valori zecimale, în timp ce funcția standard funcționează doar cu int.

După conversie, afișăm datele curente și cele convertite în fereastra monitorului serial. Probabil că veți fi interesat doar de valorile de accelerație convertite, scalate, dar datele de streaming sunt incluse în mod special, astfel încât să le puteți compara cu rezultatul și să înțelegeți mai bine cum funcționează accelerometrul. Partea de cod care este responsabilă pentru ieșirea datelor pentru fiecare dintre axele de sensibilitate ale accelerometrului ADXL337 sau ADXL377 este prezentată mai jos:

// afișează citirile curente ale accelerometrului de-a lungul axelor de sensibilitate X, Y, Z în fereastra monitorului serial

Serial.print("X: ");

Serial.println(rawX); // afișează citirile convertite de la accelerometru prin axele X,Y,Z

Serial.print("X: ");

Serial.print(scaledX);

Serial.println("g");

Acest lucru ne permite să vedem datele în două vizualizări.

Înainte de a face noi citiri, facem o întârziere:

În exemplu, întârzierea este setată la 2 secunde (2000 milisecunde), deoarece pur și simplu afișăm citirile senzorului în fereastra monitorului serial pentru a ne familiariza cu accelerometrul. În proiectele din lumea reală, este posibil să citiți datele senzorului la 500 Hz. Adică, valoarea întârzierii poate fi redusă la 2 milisecunde.

După aceasta, ne întoarcem la începutul buclei noastre loop().

Sperăm că acest articol te va ajuta să stăpânești funcționarea accelerometrelor împreună cu Arduino și că vei folosi cunoștințele acumulate în proiectele tale personale. Apropo, cu ajutorul unui accelerometru puteți determina nu numai accelerația, ci și mișcarea pe care o face un obiect. Articol detaliat despre determinarea deplasărilor unghiulare folosind un accelerometru și un giroscop: Arduino și MPU6050 pentru determinarea unghiului de înclinare.

Lasă-ți comentariile, întrebările și împărtășește-ți experiențele personale mai jos. Noi idei și proiecte se nasc adesea în discuții!

Pentru a implementa planul nostru vom avea nevoie de următoarele componente:

Partea cea mai necesară pentru instalarea noastră este accelerometrul. Există multe oferte pe Internet pentru Arduino în materie de accelerometre, iar cel mai accesibil este accelerometrul cu trei axe MMA7260. Este deja disponibil spre vânzare pe o placă care are deja un stabilizator de 3,3V 800mA pentru alimentare. Filtrele sub formă de lanțuri RC sunt conectate la ieșirile axelor X, Y, Z și are, de asemenea, un filtru trece-jos (ceea ce nu este foarte vizibil la prima cunoaștere).

În conformitate cu documentația pentru dispozitiv, este posibil să selectați sensibilitatea (4 moduri), precum și să activați și să dezactivați modul de repaus. Sensibilitatea senzorului este reglată utilizând intrările G1 și G2. Nivel maxim de sensibilitate 1,5g (00), minim 6g (11).

Schema de conectare

Accelerometrul este conectat la placa Arduino conform diagramei prezentate mai jos:


Pentru ca accelerometrul să producă întotdeauna valori, acesta trebuie să iasă din modul de repaus prin simpla aplicare a puterii la ieșirea SL (Repaus). Modul de sensibilitate este selectat folosind jumperii J1 și J2.

Inițial, acest circuit poate fi asamblat pe o placă, după care firele lungi pot fi dezlipite. Jumperele sunt plasate pe un pad de contact 3x2, unde cele două contacte din stânga sunt de 3,3 V, cele centrale sunt G1 și respectiv G2, iar contactele din dreapta sunt împământate.

Rezultatul după asamblare este următorul design:

Platforma în trei etape este conectată la Arduino prin trei ieșiri cu suport PWM și intrări de la senzorul de poziție la trei intrări analogice A0...A2. Un exemplu de conectare a nodurilor la Arduino:

Programare

Testarea și verificarea performanței accelerometrului se efectuează folosind următorul program:

1. int x, y, z;
2. // Calibrarea senzorului
3. int dx=357;
4. int dy=385;
5. int dz=178;
6. void setup()
7. Serial.begin(9600);
8. buclă goală ()
9. // Valorile axelor de la senzor
10. x = analogRead(A0) - dx;
11. y = analogRead(A1) - dy;
12. z = analogRead(A2) - dz;
13. // Ieșire pe monitorul serial
14. Serial.print("X: ");
15. Serial.print(x);
16. Serial.print("Y:" );
17. Serial.print(y);
18. Serial.print("Z:" );
19. Serial.println(z);
20. //Perioada de sondaj
21. întârziere (100);

Testare

Înainte de a începe lucrul, este necesar să calibrați senzorul folosind următoarea metodă:
1) Setați valorile de calibrare în firmware-ul controlerului la zero, scrieți firmware-ul în controler;
2) Fixați senzorul în poziție orizontală;
3) Luați citiri de la senzor timp de 3 secunde;
4) Calculați valorile medii în poziție orizontală și corectați valorile de calibrare.

Aceste măsurători trebuie făcute la sensibilitatea minimă sau aproape de aceasta pentru a exclude citirile inutile din cauza impactului de oțel sau a oricăror alte influențe.

Înainte de calibrare, senzorul a produs următoarele valori:

Graficul arată că filtrele trece-jos uscate funcționează destul de ciudat, deoarece axele fac mult zgomot. Pentru a suprima zgomotul, trebuie fie să vă scrieți propriul filtru trece-jos, fie să normalizați scala de măsurare la una mai mică (în cazul servo-urilor, zgomotul este parțial suprimat prin această metodă).

În urma măsurătorilor obținute s-au obținut următoarele corecții:

• dx = 357
• dy = 385
• dz = 178

După calibrare, citirile senzorului au început să arate imaginea reală:

În acest formular, puteți utiliza deja citirile senzorului în proiectele dvs.

Rezultat

UPD. Filtrarea software a semnalului se realizează conform algoritmului prezentat pe Wikipedia:

funcție lowpass (real x, real dt, real RC)
var real y
var real α:= dt / (RC + dt)
y := x
pentru i de la 1 la n
y[i] := α * x[i] + (1-α) * y
întoarce y

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

deși îmi place mai mult a doua variantă:

pentru i de la 1 la n
y[i] := y + α * (x[i] - y)

* Acest cod sursă a fost evidențiat cu Sursa de evidențiere a codului.

Am cumpărat acest accelerometru cu un scop foarte specific - am vrut să fac un dispozitiv care să mă împiedice să dorm pe spate mai mult decât un timp specificat. De obicei, totul a funcționat, dar accelerometrul are câteva caracteristici interesante.

De fapt, vreau să le menționez.

În primul rând, trebuie să înțelegeți că accelerometrele vin cu interfețe digitale și analogice. Primele sunt bune, deoarece sunt mai puțin susceptibile la interferențe și vă permit să conectați multe dispozitive periferice la o singură magistrală - o economisire clară a pinii controlerului. Dezavantajul este că, pentru a lucra cu astfel de periferice, trebuie să implementați un protocol de schimb în cod, iar acest lucru irosește o altă resursă valoroasă - memoria.

Cu toate acestea, atunci când conectați un singur senzor, nu va fi posibilă salvarea ieșirilor controlerului folosind un protocol digital, deoarece în ceea ce privește numărul de linii necesare, atât digitale, cât și analogice sunt identice.

Am lipit deja pieptene, da

De aceea am ales accelerometrul analog ADXL335 (pentru curiosi). La urma urmei, cu el puteți economisi memorie și puteți comunica mult mai ușor - banalul analogRead() este suficient.

Aceste. Cel mai simplu cod pentru citirea citirilor este într-adevăr la fel de simplu ca o ameba:

Unsigned int x, y, z; void setup() ( pinMode(A0, INPUT); pinMode(A1, INPUT); pinMode(A2, INPUT); Serial.begin(9600); ) void loop() ( x = analogRead(A0); y = analogRead() A1); z = analogRead(A2); Serial.print("xxxx | zzzz"; Serial.print(z, DEC);

În cele din urmă, am primit exact ceea ce este în imagine și am început cu entuziasm să prototipez, mai întâi pe o placă de dimensiuni mari Arduino Mega 2560 Și am fost foarte surprins, deoarece comportamentul accelerometrului nu se potrivea cu adevărat bunul simț. Ei bine, cel puțin până când bunul simț a spus ceva de genul „bine, nu am citit fișa de date, dar să presupunem că așa funcționează accelerometrul”.

Iată unul mai mare, dacă nu crezi că este un ADXL335

Cu alte cuvinte, mă așteptam să văd valori la ieșirile accelerometrului în intervalul de la 0V până la limita superioară de putere, adică. 3,3 V sau 5 V, deoarece accelerometrul funcționează cu ambele, dar mai multe despre asta mai târziu.

În schimb, ieșirea către monitor a arătat ceva de genul acesta. Aproximativ - pentru că nu aveam un stand cu verticale și orizontale ideale. Toate cu aceste mâini.

Valori maxime pe axa X:
X 405 Y 331 Z 344

Valori minime pe axa X:
X 268 Y 333 Z 344

Valori maxime de-a lungul axei Y:
Y 400 X 338 Z 346

Valori minime pe axa Y:
Y 264 X 334 Z 346

Valori maxime de-a lungul axei Z:
Z 410 X 337 Y 329

Valori minime de-a lungul axei Z:
Z 275 X 335 Y 331

Aceste citiri sunt identice atât pentru 3V, cât și pentru 5V.

Acesta este primul lucru pe care trebuie să-l țineți cont atunci când utilizați acest accelerometru în ferma dvs.

Al doilea este dualismul menționat mai sus în sensul alimentației. Concluzia este că ADXL335 este proiectat pentru un interval de tensiune de la 1,8 V la 3,6 V. Și au ajuns la 5B foarte într-un mod simplu- a instalat un stabilizator de 3,3 V la intrarea de alimentare.

Soluția este oarecum barbară, deoarece indiferent de tensiunea de intrare, chiar dacă este în limitele admisibile de 1,8-3,6V pentru accelerometru, curentul va curge prin stabilizator. Și acest lucru este destul de critic dacă vă propuneți să faceți cel mai economic dispozitiv posibil.

Pentru acest caz, după cum sa dovedit, există candidați mai potriviți. Și anume: plăci de dezvoltare alimentate de 3.3V sau hibride, unde 5V trece prin stabilizator, iar 3.3V merge direct la cip. În orice caz, la cumpărare, vă recomand să studiați cu atenție ceea ce intenționați să cumpărați și să comparați ceea ce vedeți cu ceea ce doriți.

În ceea ce mă privește, am rezolvat problema cu stabilizatorul simplu. Deoarece am plănuit să-l alimentez de la 3V, am conectat linia de alimentare imediat după stabilizator și am închis problema.

Legat de acest punct

Ei bine, până la urmă am venit cu un dispozitiv cu numele de cod „Pozitioner”, care folosește un semnal de vibrație pentru a avertiza despre somnul nedorit la spate, postură incorectă sau mobilitate scăzută.

Nu pare foarte prezentabil, deoarece cazurile sunt ceva ce nu am fost niciodată în stare să fac.

Baterie - pentru cantar

.

E în regulă, voi coase o carcasă în curând și va fi mai bine.

Și așa funcționează aspectul, unde puteți vedea clar accelerometrul care funcționează:

Pe baza rezultatelor comunicării cu accelerometrul (în special în această modificare), aș dori să raportez următoarele. Lucrul, după părerea mea, este foarte bun pentru începători din mai multe motive:

1) Sigur pentru plăci de dezvoltare cu tensiuni de 3,3V și 5V, deoarece există o singură intrare de alimentare și este protejată de un stabilizator;

2) Stabilitatea citirilor;

3) Ușor de utilizat datorită interfeței analogice - analogRead() și fără magie neagră.

În ceea ce privește minusurile, acestea decurg din plusuri:

1) Pentru a economisi energie, va trebui să lucrați cu mâinile - lipiți direct la cip;

2) Este posibil să se detecteze interferențe pe o linie analogică.

Raportul este terminat. În curând voi scrie despre pantaloni scurți și pantaloni.

Plănuiesc să cumpăr +21 Adăugați la favorite Mi-a placut recenzia +22 +39