Circuitul Power-On Reset (POR) asigură că microcontrolerul pornește numai atunci când tensiunea Vcc atinge un nivel sigur. După cum se arată în Fig. 24, temporizatorul încorporat, tactat de generatorul de watchdog încorporat, menține pornirea MCU un timp după atingerea tensiunii de prag de pornire Vpot, independent de rata de creștere a tensiunii Vcc (vezi Fig. 26) .

Tabelul 6 prezintă setările biților SUT1 și SUT0 utilizați pentru a seta durata perioadei de întârziere a procedurii de pornire. Utilizatorului i se oferă posibilitatea de a selecta o întârziere pentru ora de începere. Setarea SUT 1/0 = 00, care face ca MCU să pornească în 5 cicluri de ceas, este utilizată prin utilizarea unui semnal de ceas extern aplicat pinului XTAL1. Această configurare permite pornirea rapidă din modurile de oprire sau de economisire a energiei, cu condiția să existe un semnal de ceas în aceste moduri. Detalii in sectiunea Programare.

Dacă întârzierea de pornire încorporată este suficientă, atunci RESET poate fi conectat la Vcc direct sau printr-un rezistor de sarcină extern. Menținând pinul scăzut în timp ce tensiunea este aplicată, perioada de resetare la pornire poate fi prelungită. Un exemplu de astfel de sincronizare este dat în. Orez. 27.

Orez. 25. Pornirea inițială a MCU. PIN RESET conectat la Vcc, creștere rapidă a Vcc

Orez. 26. Pornirea inițială a MCU. PIN RESET conectat la Vcc, creștere lentă a Vcc

12

Rezistoarele conectabile (atât interne cât și externe) sunt necesare numai pentru pinii MCU INPUT? În schimb, un pin MCU configurat ca OUTPUT „știe la ce nivel se află” deoarece controlează - un pin MCU OUTPUT „plutitor” legat de o intrare a altui circuit nu are nicio semnificație, deoarece starea pinului MCU poate fi doar ridicată sau scăzută. .. am dreptate? Acum, când un MCU pornește sau se blochează, poate fi avantajos ca linia „MCU output to IC input” să fie mapată la acel canal pentru a se asigura că intrarea către orice IC nu plutește niciodată.

Poate tocmai mi-am răspuns aici la întrebarea mea... rezistențele de tip pull-up/down pot fi folosite atât pe pinii de intrare, cât și pe cei de ieșire, în funcție de aplicație?

• 5 răspunsuri

Triere:

Activitate

16

Pull and pop sunt de obicei folosite pentru a se asigura că o linie are o anumită stare, mai degrabă decât să fie activă. Ele sunt utilizate pe intrări pentru a preveni liniile plutitoare, comuta rapid între regiunea înaltă și scăzută și medie „nedefinită”. De obicei, ieșirile nu sunt necesare.

Dar majoritatea pinilor mcu sunt GPIO și uneori sunt definiți ca intrări în loc de ieșiri la pornire. După cum ați spus deja, uneori nu doriți ca intrarea pinului IC să plutească la pornire, mai ales ca pinul de resetare pe care îl utilizați de obicei cu GPIO al microcontrolerului.

Acesta este momentul în care utilizați Slab Tragerea sau oprirea liniei. Deoarece sunt slabe și selectați starea implicită, ele nu interferează cu circuitul dvs. (dacă semnalul de intrare se presupune că este întotdeauna scăzut și apoi este tras la sus, selectați slab off și invers), dar atrag puțin actual. De aceea alegi un rezistor destul de slab (mai mare, mai slab) pentru treaba.

O altă configurație normală de ieșire care utilizează trageri (sau push-up, mai rar) este Canal deschis sau colector deschis conexiuni. Rezultă doar o conexiune scăzută sau eliberează linia, lăsând-o plutitoare. Pull-up-urile sunt folosite pentru a aduce linia într-o stare logică înaltă.

0

Ai menționat conexiunile Open Drain și Open Collector, nu se aplică la microcontrolere, nu-i așa? Sunt Mossets pur și simplu folosite pentru a seta nivelul logic? Am vrut să clarific dacă microcontrolerul poate conduce o linie cu rezistență mare la împingere. - genericpurpleturtle 16 oct 17 2017-10-16 12:00:41

7

Ai acest drept; De obicei nu aveți nevoie de tracțiuni la ieșiri, dar pot fi utile pentru siguranță în timpul încărcării etc.

Un alt motiv pentru a utiliza output pull-up: dacă fiecare conexiune are mai multe ieșiri conectate la mai multe MPU-uri ale altuia, tu într-adevăr nu vreau să conducă un VCC și altul să conducă 0V pe același fir! Deci fie selectați ieșirea la 0V, fie dezactivați ieșirea (poate setând-o ca intrare). Când toate ieșirile sunt dezactivate, firul este tras la „1” (Vcc). Acesta se numește semnal „ȘI fir”. (Puteți face același condus „1” sau oprit, cu R-ul scăzut, apoi se numește SAU cu fir).

Acest model are mai multe utilizări, inclusiv permiterea oricărui MPU să semnaleze o eroare sau să pornească un LED sau să le permită să își transmită pe rând mesaje unul altuia printr-un singur fir.

2

Răspuns: Depinde de familia de microcontrolere și care este poziția implicită de resetare la pornire. Dacă un microcontroler poate fi configurat doar să fie fie „ieșire” fie „intrare” la un pin, aceasta înseamnă de obicei că pentru ieșire este utilizat un driver totem-pole, ceea ce înseamnă că este în esență o ieșire de poartă CMOS, caz în care ieșirea este întotdeauna condusă la șină, deci nu există niciun motiv pentru a o influența pasiv. Singurul moment în care are sens să folosiți pull-up-uri/pull-down-urile pe ieșire este atunci când este configurat ca o topologie Open Collector/Open Drain. Mult mai des întâlniți sunt parametrii interni pull-up/pull-down, care sunt aplicabili numai atunci când pinul este configurat ca intrare. Dacă poți garanta că intrarea sistemului tău este întotdeauna condusă de ceva, asta necesită puțină putere.

3

După cum ați afirmat, utilizarea rezistențelor de tragere/pulldown pe pinii care se așteaptă să fie scos la ieșire poate fi acolo pentru a asigura starea de intrare.

Acest lucru este pentru a reduce blițul/eșecul MCU, dar va funcționa numai pentru a proteja împotriva condițiilor de impedanță ridicată (în principiu, pinul este configurat ca intrare accidentală).

SPI (Serial Peripheral Interface) este un standard de transmisie de date sincronă în serie în modul full duplex, dezvoltat de Motorola pentru a oferi interfațare simplă și ieftină a microcontrolerelor și perifericelor. SPI mai este denumit uneori o interfață cu patru fire SPI este un protocol sincron în care fiecare transmisie este sincronizată cu un semnal de ceas comun generat de dispozitivul gazdă (procesor). Perifericul de recepție (slave) sincronizează recepția secvenței de biți cu semnalul de ceas. Mai multe cipuri pot fi conectate la o interfață periferică serială a unui cip master. Maestrul selectează slave pentru a transmite activând semnalul de selectare a cipului pe cipul slave. Perifericele care nu sunt selectate de procesor nu participă la transmisia SPI.
SPI utilizează patru semnale digitale:

• MOSI sau SI – ieșire master, intrare slave (în engleză: Master Out Slave In). Servește pentru a transfera date de la dispozitivul master la slave;
• MISO sau SO – intrare master, ieșire slave (în engleză: Master In Slave Out). Servește pentru a transfera date de la un dispozitiv slave la un dispozitiv principal.
• SCK sau SCLK – semnal de ceas serial (serial Clock în engleză). Servește la transmiterea unui semnal de ceas pentru dispozitivele slave.
• C.S. sau SS – selecție cip, selecție slave (în engleză: Chip Select, Slave Select, de regulă, selecția unui cip se face la un nivel logic scăzut).

În funcție de combinațiile de polaritate și faza de ceas, sunt posibile patru moduri de funcționare SPI.

Modul SPI	Diagrama de timp
Modul SPI0
Modul SPI1 Nivelul impulsului activ este ridicat.
Modul SPI2 Mai întâi făcând clic, apoi glisând.
Modul SPI3 Nivelul impulsului activ este scăzut. Mai întâi schimbă, apoi snap.

Tabelul presupune:

• MSB - cel mai semnificativ bit;
• LSB - bitul cel mai puțin semnificativ.

Masterul trebuie să se adapteze la modul folosit de slave.
La schimbul de date prin interfața SPI, microcontrolerul poate funcționa ca master (modul Master) sau ca slave (modul Slave). În acest caz, utilizatorul poate seta următorii parametri:

• modul de funcționare conform tabelului;
• viteza de transmisie;
• format de transmisie (de la bitul cel mai puțin semnificativ la bitul cel mai semnificativ sau invers).

Conectarea a două microcontrolere într-o structură master-slave prin interfața SPI se realizează conform următoarei scheme.

Pinii SCK, CS pentru microcontrolerul master sunt ieșiri, iar pentru microcontrolerul slave sunt intrări.

Transferul de date se efectuează după cum urmează. Când scrieți în registrul de date SPI al microcontrolerului principal, generatorul de ceas al modulului SPI este pornit și datele încep să fie transmise bit cu bit către pinul MOSI și, în consecință, către pinul MOSI al microcontrolerului slave. După emiterea ultimului bit al octetului curent, generatorul de semnal de ceas se oprește în timp ce setează simultan indicatorul „Sfârșitul transmisiei” la „1”. Dacă întreruperile din modulul SPI sunt acceptate și activate, este generată o solicitare de întrerupere. După aceasta, microcontrolerul master poate începe să transmită următorul octet sau, prin aplicarea unui nivel de tensiune de „1” logic la intrarea SS a slave, îl poate pune în starea de așteptare.

Concomitent cu transferul datelor de la master la slave, transmisia are loc și în sens opus, cu condiția ca la intrarea SS a slave să fie prezentă o tensiune de nivel scăzut. Astfel, în fiecare ciclu de schimb, se fac schimb de date între dispozitive. La sfârșitul fiecărui ciclu, indicatorul de întrerupere este setat la „1” atât în ​​microcontrolerul master, cât și în cel slave. Octeții recepționați sunt stocați în buffer-uri de primire pentru utilizare ulterioară.

La primirea datelor, octetul primit trebuie citit din registrul de date SPI înainte ca ultimul bit al următorului octet să ajungă în registrul de deplasare. În caz contrar, primul octet se va pierde.

Pinul SS este destinat să selecteze dispozitivul slave activ și este întotdeauna o intrare în modul Slave. De fiecare dată când pinul SS este aplicat la logica 1, modulul SPI este resetat. Dacă apare o modificare a stării acestui pin în timpul transmiterii datelor, atât trimiterea, cât și recepția se vor opri imediat, iar octeții transmisi și primiți se vor pierde.

Dacă microcontrolerul este în modul Master, direcția transferului de date prin pinul SS este definită de utilizator. Dacă pinul este configurat ca ieșire, acesta acționează ca un pin de uz general și nu afectează funcționarea modulului SPI. De regulă, în acest caz este folosit pentru a controla pinul SS al unui microcontroler care funcționează în modul Slave.

Dacă un pin este configurat ca intrare, acesta trebuie să fie condus în sus pentru o funcționare corectă a modulului SPI. Aplicarea unei tensiuni de nivel scăzut la această intrare de la orice circuit extern va fi percepută de modulul SPI ca selectând microcontrolerul ca slave (și datele vor începe să fie transferate către acesta).

Un exemplu de utilizare a interfeței SPI pentru microcontrolere STM32 este bine descris în

Un alt proiect interesant și chiar util pe NodeMCU este un ticker controlat prin WiFi. Cu siguranță, toți vedem astfel de dispozitive în fiecare zi pe străzile orașului. De exemplu, ticker-ul este utilizat pe scară largă în transport pentru a afișa numărul rutei, următoarea oprire și publicitate intruzivă pentru tot felul de lucruri. Un ticker tipic este o matrice LED cu un circuit de control al scanării și un microcontroler la bord. Textul care se accesează cu crawlere de-a lungul acestei matrice poate fi stocat local sau actualizat dinamic prin WiFi sau GSM. Desigur, având o platformă atât de puternică precum NodeMCU (sau orice alt ESP8266), un ticker poate fi făcut acasă. Este logic să-l instalați undeva într-un loc public, cum ar fi o școală. Printr-un astfel de panou informativ va fi convenabil să raportați știrile interne ale școlii, temperatura din afara ferestrei sau chiar numele elevilor excelenți! În laboratorul nostru, am instalat un ticker într-o fereastră de la primul etaj. Cu ajutorul acestui dispozitiv IoT, le-am urat tuturor trecătorilor un An Nou fericit și Crăciun :)

1. Conectarea matricei LED la NodeMCU

• două contacte pentru alimentare: masă GND și +5V;
• trei contacte pentru magistrala SPI: CS, DIN, CLK;

2. Program pentru controlul MAX7219 pe NodeMCU

#include #include Max72xxPanel matrice = Max72xxPanel(D8, 4, 1); ticker lung nesemnat_next; Bandă șir = „Bună ziua de la RobotClass!”; int spacer = 1; int lățime = 5 + spacer; void setup(void)( matrix.setIntensity(7); ) void handleTicker())( pentru (int i = 0; i< width * tape.length() + matrix.width() - 1 - spacer; i++) { matrix.fillScreen(LOW); int letter = i / width; int x = (matrix.width() - 1) - i % width; int y = (matrix.height() - 8) / 2; while (x + width - spacer >= 0 && litera >= 0) (dacă (litera< tape.length()) { matrix.drawChar(x, y, tape, HIGH, LOW, 1); } letter--; x -= width; } matrix.write(); delay(50); } } void loop(void){ handleTicker(); } Подаем питание и на матрице начинает двигаться бегущая строка с текстом «Hello from RobotClass!»

3. Server web pe NodeMCU pentru a controla matricea LED

Acum să adăugăm un server web la program, care va afișa o singură pagină HTML cu un câmp pentru introducerea textului târâtor și un buton. #include #include #include #include #include #include const char* ssid = "ESP"; //pornire punct WiFi ESP ESP8266WebServer server(80); // porniți serverul pe portul 80 Max72xxPanel matrice = Max72xxPanel(D8, 4, 1); ticker lung nesemnat_next; Bandă șir = „RobotClass”; int spacer = 1; int lățime = 5 + spacer; // Pagina HTML index.html const char page = " " "" "" "

" "" "" "

" "" ""; // funcția este apelată când clientul apasă butonul void handleSubmit())( tape = server.arg("text"); server.send(200, "text/html", page); ) void handleRoot( ) ( if ( server.hasArg("text")) ( handleSubmit(); ) else ( server.send(200, "text/html", pagina); ) ) void setup(void)( delay(1000); WiFi .softAP(ssid ); server.on("/", handleRoot.begin(); void handleTicker();< width * tape.length() + matrix.width() - 1 - spacer; i++) { matrix.fillScreen(LOW); int letter = i / width; int x = (matrix.width() - 1) - i % width; int y = (matrix.height() - 8) / 2; // центровка по вертикали while (x + width - spacer >= 0 && litera >= 0) (dacă (litera< tape.length()) { matrix.drawChar(x, y, tape, HIGH, LOW, 1); server.handleClient(); } letter--; x -= width; } matrix.write(); delay(50); } } void loop(void){ server.handleClient(); handleTicker(); } Загружаем программу на Node MCU и подаем питание. По-умолчанию, бегущая строка будет крутить текст «RobotClass». Чтобы его изменить, необходимо подключиться к WiFi точке «ESP» и зайти через браузер по адресу: http://127.0.0.1/ В ответ появится страница с полем для ввода текста бегущей строки и кнопкой «Set text». Вводим в поле новый текст, жмем кнопку и смотрим на бегущую строку! Your browser does not support the video tag.

4. Ticker în rusă

În forma sa actuală, dispozitivul nostru nu acceptă limba rusă. Dacă încercați să introduceți text în rusă, codurile utf8 vor apărea pe matrice în loc de litere. Pentru a remedia acest lucru avem nevoie de o funcție suplimentară utf2rus. În plus, vom adăuga în program o parolă pentru punctul WiFi. #include #include #include #include #include #include const char* ssid = "ESP"; const char* pwd = "makemyday"; // parola pentru punctul WiFi ESP8266WebServer server(80); Max72xxPanel matrice = Max72xxPanel(D8, 4, 1); ticker lung nesemnat_next; Bandă șir = „RobotClass.ru”; int spacer = 1; int lățime = 5 + spacer; const char page = " " "" "" "" "" "

" "" "" "

" "" ""; String utf8rus(String source)( int i,k; String target; unsigned char n; char m = ( "0", "\0" ); k = source.length(); i = 0; while (i< k) { n = source[i]; i++; if (n >= 0xC0) ( comutator (n) ( cazul 0xD0: ( n = sursa[i]; i++; dacă (n == 0x81) ( n = 0xA8; pauză; ) dacă (n >= 0x90 && n<= 0xBF) n = n + 0x2F; break; } case 0xD1: { n = source[i]; i++; if (n == 0x91) { n = 0xB7; break; } if (n >= 0x80 && n<= 0x8F) n = n + 0x6F; break; } } } // switch m = n; target = target + String(m); } return target; } void handleSubmit(){ tape = utf8rus(server.arg("text")); server.send(200, "text/html", page); } void handleRoot() { if (server.hasArg("text")) { handleSubmit(); } else { server..softAP(ssid, pwd); server.on("/", handleRoot); server.begin(); matrix.setIntensity(7); } void handleTicker(){ for (int i = 0 ; i < width * tape.length() + matrix.width() - 1 - spacer; i++) { matrix.fillScreen(LOW); int letter = i / width; int x = (matrix.width() - 1) - i % width; int y = (matrix.height() - 8) / 2; while (x + width - spacer >= 0 && litera >= 0) (dacă (litera< tape.length()) { matrix.drawChar(x, y, tape, HIGH, LOW, 1); server.handleClient(); } letter--; x -= width; } matrix.write(); delay(50); } } void loop(void){ server.handleClient(); handleTicker(); } Готово! Теперь устройство готово к непрерывной эксплуатации. Осталось сделать крепление для матрицы и поставить бегущую строку на видное место. Чертежи подходящего крепления можно найти тут:

Pe baza postărilor anterioare și a unora după citirea specificațiilor, probabil a apărut întrebarea - ce este acest al doilea procesor MCU misterios care rulează la 100 MHz? De ce este nevoie? Cum să-l folosească?
Între timp, rolul MCU este extrem de important în unele cazuri. Cei care au încercat să folosească Edison pentru a lucra cu diverși senzori ar putea să fi observat deja că Intel Edison nu oferă răspuns în timp real la citirile lor atunci când lucrează de pe Linux. Și aici este locul în care MCU vine în ajutor. Este timpul să vorbim puțin despre acest microcontroler încorporat, arhitectura lui, aplicații și să luăm în considerare un exemplu practic.

Începând cu versiunea 2.1, software-ul pentru Intel Edison a adăugat posibilitatea de a utiliza un microcontroler încorporat.

Luați în considerare sistemul de pe un cip utilizat în modulul de calcul Intel Edison:

Sistemul pe cip utilizat în modulul de calcul Intel Edison include două procesoare:

1. Procesor Intel Atom dual-core care rulează la 500 MHz. Desemnat ca CPU gazdă.
2. Microcontroler cu arhitectură Minute IA, care funcționează la 100 MHz. Etichetat ca MCU.

Să aruncăm o privire mai atentă la microcontroler. Nucleul de calcul Minute IA este o arhitectură eficientă din punct de vedere energetic, bazată pe 486, cu instrucțiuni suplimentare pentru compatibilitatea Pentium. Pe lângă nucleul de calcul, microcontrolerul conține un subsistem de intrare/ieșire (GPIO, I2C, High Speed ​​UART, DMA) și SRAM. Microcontrolerul are acces la toate porturile GPIO din modulul de calcul Edison. Volumul total SRAM pentru cod și date este de 192 kB. Microcontrolerul rulează sistemul de operare în timp real Viper OS de la WindRiver.

Aplicația de microcontroler rulează deasupra nucleului Viper și controlează perifericele conectate la MCU, independent de procesorul Intel Atom. De exemplu, poate controla porturile GPIO, poate interacționa cu senzorii prin protocolul I2C sau UART și poate comunica cu un procesor Intel Atom.

De ce este nevoie de un microcontroler în Intel Edison?

Aș evidenția două domenii în care poate fi utilizat un microcontroler încorporat:

1. Lucrul cu porturi I/O și interfețe cu răspuns în timp real.
2. Eficienta energetica.

Procesorul Intel Atom și distribuția standard Yocto Linux nu permit implementarea de aplicații cu răspuns în timp real din cutie. Aplicația poate fi anticipată de planificatorul de activități, rezultând o latență inacceptabilă și imprevizibilă. Microcontrolerul rulează o singură aplicație și un sistem de operare în timp real, astfel încât este posibil să ofere răspuns în timp real. Acest lucru este necesar pentru mulți senzori în care protocolul de comunicare depinde de respectarea strictă a intervalelor scurte de timp. Pentru a le conecta fără un microcontroler încorporat, ar trebui să utilizați un microcontroler separat pe care să implementați toate funcționalitățile pentru lucrul cu astfel de senzori. Un exemplu de soluție pentru Intel Edison cu un microcontroler extern este SparkFun Block pentru Intel Edison - placa de expansiune Arduino.

Puteți crește eficiența energetică folosind un microcontroler în aplicațiile în care procesorul principal poate fi într-o stare de repaus și microcontrolerul așteaptă un anumit eveniment (de exemplu, depășirea valorilor de prag de la un senzor).
Dacă este necesar, microcontrolerul trezește procesorul principal. Un exemplu de implementare este dat în articolul Utilizarea MCU SDK și API: Exemple de cod.

Ca exemplu de lucru cu microcontrolerul Intel Edison, să luăm în considerare conectarea senzorului de distanță ultrasonic HC-SR04. Vom afișa distanța măsurată pe ecranul cu caractere Grove LCD RGB Backlight.

Senzorul are 4 iesiri:

• Vcc- 5V.
• Trig- Semnal de declanșare către senzor. Microcontrolerul furnizează un impuls de 10 microsecunde senzorului. Senzorul inițiază procesul de măsurare.
• Ecou- Semnal ecou de la senzor la microcontroler. Durata impulsului este proporțională cu distanța măsurată.
• Gnd- Pământ.

Iată cum arată procesul de lucru cu senzorul pe ecranul osciloscopului:

• 1 canal- Trig
• Canalul 2- Ecou

Microcontrolerul trimite un impuls către Trig. După aceasta, senzorul răspunde cu un impuls la Ecou.
Durata pulsului este proporțională cu distanța măsurată.
Distanța măsurată este calculată folosind formula (luată din specificația senzorului):
distanta(cm) = Durata impulsului ecou (microsecunde) / 58
Conform specificației, senzorul poate măsura distanțe de la 2 la 400 cm.
Măsurarea duratei pulsului cu o eroare prezisă fără timp real va fi problematică.
Procesul de măsurare poate fi, de exemplu, anticipat de programator, iar rezultatul măsurării va fi incorect.

Conectarea HC-SR04 la microcontrolerul Intel Edison

Componente folosite:

• Modulul de calcul Edison
• Placa Edison Arduino
• Grove Basic Shield
• Ecran de caractere Grove LCD RGB Iluminare de fundal
• Senzor de distanta cu ultrasunete HC-SR04
• Tabla de paine

În primul rând, conectăm modulul de calcul Edison la placa Edison Arduino. Apoi conectăm placa de expansiune Grove Basic Shield la placa Edison Arduino. Iluminarea de fundal Grove LCD RGB se conectează la antetul I2C de pe Grove Basic Shield.

Senzorul de proximitate cu ultrasunete HC-SR04 se conectează la Grove Basic Shield după cum urmează:

• Vcc la +5V.
• Trig la pinul #3.
• Ecou la pinul #4.
• Gnd la Gnd.

Pinii 3, 4 sunt selectați aleatoriu, alții pot fi folosiți în schimb.

Actualizare firmware Intel Edison

Suportul pentru microcontroler este disponibil în versiunea 2.1 și ulterioară a software-ului Intel Edison® Board Firmware. Dacă firmware-ul dvs. este mai vechi, atunci trebuie să fie actualizat.

Puteți afla versiunea curentă de firmware cu comanda:
# configure_edison --version
Acest exemplu a fost creat pe versiunea de firmware 146.

Procesul de actualizare a firmware-ului este descris în detaliu în articolul Flashing Intel Edison. Personal, folosesc de obicei metoda descrisă în secțiune Metodă alternativă de intermitent.
Citiți cu atenție instrucțiunile înainte de a instala firmware-ul.

Conectarea Intel Edison prin Ethernet-over-USB

Pentru a lucra cu Edison din mediul MCU SDK, trebuie să creați o conexiune de rețea.
Pentru a face acest lucru, trebuie, de exemplu, să conectați un cablu USB la portul micro-USB din mijloc (comutatorul ar trebui să fie setat spre porturile micro-USB).
Pe Linux, rețeaua este configurată cu comanda:
# ifconfig usb0 192.168.2.2
Adresă IP Intel Edison: 192.168.2.15
Procesul de conectare este descris mai detaliat în articolul Conectarea la placa Intel® Edison folosind Ethernet prin USB.

MCU SDK

Pentru a crea aplicații care vor rula pe un microcontroler încorporat, a fost lansat un mediu de dezvoltare multiplatformă, MCU SDK, bazat pe Eclipse. Procesul de instalare este discutat în detaliu în articolul Instalarea SDK-ului MCU.
SDK-ul MCU vă permite să creați, să compilați, să descărcați și să depanați aplicații de microcontroler.

Interacțiunea cu MCU

Sunt disponibile mai multe interfețe pentru a interacționa cu microcontrolerul de la Linux:
/dev/ttymcu0 - Canal pentru schimbul de date. Din Linux puteți lucra utilizând operațiuni standard de fișiere. Din programul de pe microcontroler, schimbul se realizează folosind funcțiile host_send și host_receive.
/dev/ttymcu1 - Canalul prin care microcontrolerul trimite mesaje de depanare cu funcția debug_print.
/sys/devices/platform/intel_mcu/log_level - Vă permite să setați nivelul mesajelor de depanare (fatal, error, warning, info, debug).

Program pentru Linux

Un mic script Python care va primi date de la microcontrolerul încorporat și le va afișa pe un afișaj cu caractere. Pentru a lucra cu un afișaj de caractere, vom folosi modulul Jhd1313m1 din biblioteca UPM.

scriptul show_distance.py:

timp de import import pyupm_i2clcd RET_ERROR = -1 if __name__ == "__main__": lcd = pyupm_i2clcd.Jhd1313m1(6, 0x3E, 0x62) with open("/dev/ttymcu0", "w+t"): as f:while True f.write("get_distance\n") # Trimite comanda către MCU f.flush() line = f.readline() # Citiți răspunsul de la MCU, -1 = EROARE valoare = int(line.strip("\n\r \t ")) lcd.clear() if value == RET_ERROR: lcd.setColor(255, 0, 0) # RED lcd.write("ERROR") else: lcd.setColor(0, 255, 0) # VERDE lcd.write("%d cm" % (valoare,)) time.sleep(1)

Program pentru microcontroler

Programul de pe microcontroler trebuie, la primirea comenzii get_distance de la gazdă, să măsoare distanța și să trimită rezultatul către gazdă (distanță în centimetri, sau -1 în caz de eroare).
Configurarea porturilor pe placa Edison Arduino:
./init_DIG.sh -o 3 -d ieșire ./init_DIG.sh -o 4 -d intrare
Permiteți-mi să vă reamintesc că microcontrolerul funcționează cu porturi GPIO de pe modulul de calcul Edison, care diferă de numerotarea de pe placa Edison Arduino. Tabelul de corespondență este dat, de exemplu, la sfârșitul articolului Intermiterea unui LED folosind MCU.

Program pentru microcontroler în MCU SDK:

#include "mcu_api.h" #include "mcu_errno.h" // PIN de extensie Arduino = 3 #define TRIG 12 // PIN de extensie Arduino = 4 #define ECHO 129 // Din foaia de date HC-SR04 #define MIN_DISTANCE 2 #define MAX_DISTANCE 400 #define MAX_WAIT 10000 #define RET_ERROR -1 int get_distance() ( // Trimite semnal Trig către HC-SR04 gpio_write(TRIG, 1); mcu_delay(10); gpio_write(TRIG, 0); // Citiți semnalul Echo de la HC -SR04 int i; i = 0; while ((gpio_read(ECHO) == 0) && (i< MAX_WAIT)) { mcu_delay(1); i++; } unsigned long t0 = time_us(); if (gpio_read(ECHO) == 0 || i == MAX_WAIT) { return RET_ERROR; } i = 0; while ((gpio_read(ECHO) == 1) && (i < MAX_WAIT)) { mcu_delay(1); i++; } unsigned long t1 = time_us(); if (gpio_read(ECHO) == 1 || i == MAX_WAIT) { return RET_ERROR; } unsigned long distance = (t1 - t0) / 58; if (MIN_DISTANCE < distance && distance < MAX_DISTANCE) { return distance; } else { return RET_ERROR; } } #define MAX_BUF 255 unsigned char buf; void mcu_main() { // Setup Trig as OUTPUT gpio_setup(TRIG, 1); // Initially set Trig to LOW gpio_write(TRIG, 0); // Setup Echo as INPUT gpio_setup(ECHO, 0); while (1) { unsigned int len; len = host_receive(buf, MAX_BUF); if ((len >= 12) && (strncmp(buf, "get_distance", 12) == 0)) (unsigned int distanta; distanta = get_distance(); len = mcu_snprintf(buf, MAX_BUF, "%d\n", distanta); host_send (buf, len);