Differences

This shows you the differences between two versions of the page.

Link to this comparison view

si:laboratoare:01 [2020/09/26 19:17]
laura.ruse [Networking]
si:laboratoare:01 [2023/10/10 20:54] (current)
florin.stancu
Line 1: Line 1:
-====== Laboratorul 01. Intro & QEMU ====== +===== Laboratorul 01. NuttX Configurare și instalare ​=====
- +
-<note important>​ +
-Atentie! Pentru rezolvarea laboratorului recomandam folosirea sistemului de operare Ubuntu 18.04. Puteti folosi o masina virtuala Ubuntu 18.04 Bionic Beaver download-ata de pe [[https://​www.osboxes.org/​ubuntu/​|osboxes]] si rulata in [[https://​www.virtualbox.org/​|VirtualBox]] sau VmWare. +
-</​note>​ +
- +
-===== Introducere ​=====+
  
 Bine ați venit în laboratorul de Sisteme Embedded! Bine ați venit în laboratorul de Sisteme Embedded!
  
-Laboratorul își propune să vă familiarizeze cu sisteme embedded care rulează Linux, de la dezvoltare ​și configurare,​ până la mentenanță. Vom trata subiecte precum: +Laboratorul își propune să vă familiarizeze cu sisteme embedded care rulează Linux și sisteme de operare RTOS precum NuttX care se pretează mai degrabă microcontrollerelor decât sistemelor de tip desktop.
-  * Rularea/​Compilarea de aplicații pe un sistem embedded +
-  * Bootloadere,​ Kernel, Root FS, Toolchain +
-  * Instalarea și configurarea de servicii +
-  * Construirea unei distribuții Linux pentru sisteme embedded +
-  * Emularea sistemelor+
  
 +În acest laborator veți învăța cum să compilați și să încărcați sistemul de operare NuttX pe plăcile [[https://​github.com/​dantudose/​ESP32-Sparrow-rev2| ESP32 Sparrow]]. Aceste plăci sunt construite pornind de la un modul de ESP32 Wrover la care au fost adăugate:
 +  * un senzor de lumină - LTR308
 +  * un senzor de temperatură,​ umiditate și presiune - BME680
 +  * un display OLED cu rezoluția 128x32 - SSD1306
 +  * un microfon prin I2S
 +  * un cititor de carduri microSD
  
-==== De ce Linux? ====+Pentru a putea fi folosit pe microcontrollere,​ NuttX are un memory-footprint foarte scăzut (de ordinul câtorva sutelor de kilobytes). Un alt feature care îl face potrivit sistemelor low-end este faptul că nu folosește mecanismele de memorie virtuală în mod implicit, acest mod de operare numindu-se flat-mode addressing.
  
-Sistemele Linux oferă o mulțime de avantaje dezvoltatorilor de produse, care micșorează timpul de dezvoltare, lucru care este din ce în ce mai important în zilele noastre: +{{ :si:laboratoare:esp32_sparrow.jpg?600 |}}
-  * **versatilitate**Sistemele Linux nu trebuie să fie single-purpose,​ se pot adăuga multiple funcționalități cu ușurință (chiar și în etapa de post-producție) +
-  * **codebase mare**Sistemele Linux abundă de aplicații user-space, drivere pentru o mulțime de dispozitive,​ suport pentru multe protocoale/​sisteme de fișiere/​etc. +
-  * **securitate**:​ Sistemele care folosesc servicii comune în Linux beneficiază de același nivel de securitate ca pe un sistem desktop sau server+
  
-De-a lungul anilor Linux a devenit cel mai folosit sistem de operare pentru aplicațiile embedded. Îl puteți găsi folosit în orice: +===== Setup =====
-  * telefoane mobile (Android) +
-  * router-e +
-  * DVR, NAS +
-  * quadcoptere +
-  * [[http://​store.steampowered.com/​livingroom/​SteamMachines/​ | console de jocuri]] +
-  * [[http://​www.geek.com/​chips/​this-intelligent-fridge-runs-linux-on-an-arm-chip-1297126/​ |  frigidere ]]+
  
-După cum se poate vedea, sistemele embedded diferă foarte mult în dimensuni și putere de procesare, unele dintre ele apropiindu-se chiar de puterea de procesare a unui calculator obișnuit. De asemenea, aplicațiile pe care acestea le rulează pot fi foarte variate (ex: smartphone),​ amestecând diferențele dintre un calculator obișnuit și un sistem embedded. Un lucru care deosebește însă sistemele embedded este modul de interacțiune cu utilizatorii,​ care foarte rar se face printr-un ecran și o tastatură. Lipsa unui mod tradițional de interacțiune cu utilizatorul este și ceea ce face dezvoltarea unui sistem embedded mai grea, dar și mai interesantă.+==== Linux ====
  
-Cele mai întâlnite două metode de interacțiune cu un sistem ​embedded în timpul dezvoltării sunt: consola serială și conexiunea SSH. Dintre acesteaconexiunea SSH este metoda mai robustă șmai simplu ​de utilizat, însă ea e disponibilă doar pe sistemele care dispun de o interfață de rețea. Consola serială, însă este de obicei prezentă pe orice sistem ​și permite interacțiunea cu sistemul chiar și înainte ca interfața de rețea să fie disponibilă (ex: în bootloader sau înainte de ințializarea driver-ului de rețea).+Dacă rulați pe un sistem ​cu Linux nativcontinuați de la pasul [[01#​compilarea_si_incarcarea_pe_placa|Compilarea ​și încărcarea pe placă]].
  
-Există două concepte importante folosite în dezvoltarea unui sistem embedded: **target** și **host**. //​Target//​-ul este reprezentat de sistemul embedded pe care îl dezvoltăm și la care ne conectăm (ex: RaspberryPi,​ Intel Galileo etc.). //Host//-ul este reprezentat de calculatorul pe care îl folosim pentru dezvoltare și prin care ne conectăm cu sistemul embedded. //Host//-ul beneficiază de obicei de o putere de procesare mult mai mare, care micșorează de exemplu timpul de compilare în comparație cu compilarea pe //​target//​. +==== Windows ​====
-===== RaspberryPi =====+
  
-| {{:si:​lab:​2015:​intro:​raspberry-pi-3-ports.jpg?400|}} | +Pentru a putea rula pe Windows, va trebui să vă configurați o mașină virtuală de Linux prin care să aveți acces la porturile USB ale host-ului - astfel conectarea la placă se va face direct prin USB de pe mașina virtuală. Pentru instalarea Linuxului puteți folosi [[https://​repository.grid.pub.ro/​cs/​so/​linux-2021/so-ubuntu-20-04.ova|mașina virtuală]] de la SO din anul 3 - este suficient să aveți un sistem Linux minimal, doar din linie de comandă. Alternativ, puteți instala orice altă distribuție de Linux (Ubuntu, Linux Mint, etc.).
-^ RaspberryPi Model B ^+
  
-Vom lucra în principal cu RaspberryPi 3un sistem de calcul bazat pe un procesor "​System on Chip" ARM de la Broadcom. Specificațiile complete sunt: +Pentru a instala mașina virtualăeste recomandat să folosiți [[https://vmware.pub.ro/|VMware Workstation 16 pro]]deoarece este foarte ușor de configurat.
-  * procesor: 64-bit quad-core ARM Cortex-A53, 1.2GHz +
-  * 1GB RAM +
-  * 4 porturi USB 2.+
-  * 1 conector Ethernet +
-  * card microSD +
-  * HDMIjack audio, RCA +
-  * Diverse alte periferice: GPIO, UART-uri, I²C, SPI, I²S+
  
 +Dacă nu aveți acces la VMware (nu aveți licență), puteți să folosiți și [[https://​www.virtualbox.org/​|VirtualBox]],​ dar cu niște pași în plus pentru a-l configura.
  
-{{:si:​lab:​2015:​intro:​rasp-hardware.png?400|}} | +În mod normal, o mașină virtuală prin VirtualBox nu este accesibilă direct de pe host. Totuși, pentru a vă putea conecta la mașina virtuală prin SSH (folosind [[https://​mobaxterm.mobatek.net/​|MobaXterm]],​ de exemplu), puteți urmări pașii de mai jos: 
-^ Schema perifericelor RaspberryPi ^+  * intrați în setările mașinii virtuale și adăugați a 2a interfață de rețea. Prima va fi o interfață host-only pentru a permite conectivitatea de la host la guest (ssh), iar a 2a interfață va fi sub un NAT pentru a putea avea acces la internet
 +  * porniți mașina virtuală. Testați cu ''​ping 8.8.8.8''​ că sunteți conectat la Internet. 
 +  * adăugați o adresă IP statică pe a 2a interfață folosind subrețeaua ''​192.168.56.0/​24''​. De exemplu, puteți folosi ''​192.168.56.56/​24''​. Alternativ, puteți configura un client de DHCP.
  
-==== Schema bloc ====+Pentru a putea avea acces la portul USB direct din mașina virtuală, din bara de sus selectați ''​Devices''​ > ''​USB devices''​ > ''​controller-ul UART''​.
  
-Din punct de vedere hardware, RaspberryPi este un dispozitiv simplu, care expune diferitele periferice pe care le oferă SoC-ul Broadcom. Singura excepție o reprezintă Hub-ul USB, care dublează numărul de porturi USB disponibile șatașează șun dispozitiv Ethernet la SoC-ul Broadcom+Momentan WSL-ul nu are suport nativ pentru interacțiunea cu diferite device-uri peste USB. Dacă dorițsă folosițtotusi WSL, puteți folosi acest [[https://​learn.microsoft.com/​en-us/​windows/​wsl/​connect-usb|tool]] open source.
  
-| {{:​si:​lab:​2015:​intro:​raspberrypi_blockdiagram.png?​direct&​600 | }} | +==== MacOS ====
-^ Diagrama bloc ^+
  
-| {{:si:​lab:​2015:​intro:​9512_blockdiagram.png?​direct&​600 ​}} | +Pentru a rula pe MacOS puteți urmări tutorialul de [[https://github.com/​robertalexa2000/​nuttx-esp32-docs/​blob/​si_labs/​bringup/​macos_tutorial.md|aici]].
-^ Diagrama block a chip-ului de USB și Ethernet ^+
  
 +===== Compilarea și încărcarea pe placă =====
  
-===== QEMU =====+Pașii de mai jos trebuie urmați ca utilizator privilegiat (root): 
 +  * instalarea pachetelor (dependințelor) pe Linux 
 +  * descărcarea unui compilator (toolchain),​ deoarece arhitectura target este Xtensa, deci nu putem compila cu gcc-ul default de pe distribuțiile de Linux x86 
 +  * descărcarea repository-urilor de NuttX: nuttx, apps 
 +  * descărcarea tabelei de partiții și a bootloader-ului. Acestea sunt precompilate pentru fiecare release (versiune) de NuttX, însă pot fi compilate și din linie de comandă. 
 +  * compilarea în urma căreia va rezulta un binar 
 +  * încărcarea binarului pe placă
  
-[[http://​qemu.org| QEMU]] este un emulator/​mașină virtuală care permite rularea unui sistem de operare complet ​ca un simplu program în cadrul unui alt sistem. A fost dezvoltat inițial de [[https://en.wikipedia.org/wiki/​Fabrice_BellardFabrice Bellard]] și este disponibil gratuit, sub o licență open source. QEMU poate rula atât pe Linux, cât și pe Windows [[#​referinte| [1]]][[#​referinte| [3]]][[#​referinte| [4]]].+Dacă doriți să continuați ​ca utilizator neprivilegiat,​ puteți consulta tutorialul ​de [[https://blog.espressif.com/getting-started-with-esp32-and-nuttx-fd3e1a3d182c|aici]].
  
-Este o mașină virtuală deoarece poate virtualiza componentele fizice ale unui sistem de calcul, pentru a permite rularea unui sistem de operare, oaspete (//​guest//​),​ în cadrul altui sistem de operare, gazdă (//host//). În acest mod de funcționare,​ atât sistemul //guest//, cât și sistemul //host//, folosesc aceeași arhitectură (ex: x86). QEMU poate folosi un hypervisor (Xen sau KVM) pentru a accelera rularea //​guest//​-ului atunci când există suport pentru virtualizare în hardware. În acest caz QEMU poate atinge o performanță comparabilă cu sistemul nativ, deoarece lasă mare parte din cod să se execute direct pe procesorul //host//. Folosind KVM sunt suportate diferite arhitecturi,​ printre care x86, PowerPC și S390 [[#​referinte| [1]]].+==== Instalarea pachetelor lipsă ====
  
-Este un emulator deoarece poate rula sisteme de operare și programe compilate pentru o platformă (ex: o placă ARM) pe o altă platformă (ex: un PC x86). Acest lucru este făcut prin translatarea dinamică a intrucțiunilor architecturii //guest// în instrucțiuni pentru arhitectura //host//. Ca un emulator, QEMU poate rula în două moduri [[#​referinte| [2]]][[#​referinte| [4]]]: +<​code>​ 
-  * //​[[http://​wiki.qemu.org/​download/​qemu-doc.html#​QEMU-User-space-emulator| User-mode emulation]]//,​ în care un executabil obișnuit (user-space), compilat pentru o arhitectură,​ este rulat pe o altă arhitectură. În acest mod de funcționare instrucțiunile din executabil sunt translatate în instrucțiuni ale arhitecturii //host//, iar argumentele apelurilor de sistem sunt convertite pentru a putea fi pasate sistemului de operare //host//. Sistemele de operare emulate sunt: Linux, Mac OS X și BSD. Principalele utilizări sunt cross-debugging-ul și cross-compilarea, unde rulăm un compilator nativ al arhitecturii //target//, pe arhitectura //host//. +apt-get update 
-  * //​[[http://​wiki.qemu.org/​download/​qemu-doc.html#​QEMU-System-emulator-for-non-PC-targets| System emulation]]//,​ în care este emulat un sistem de calcul complet. QEMU permite emularea unui număr mare de platforme, bazate pe diferite arhitecturi (ex: x86, ARM, PowerPC, MIPS, SPARC, MicroBlaze etc.), împreună cu perifericele lor.  În acest mod de funcționare pot fi rulate sisteme de operare întregi, printre care Windows, Linux, Solaris, BSD și DOS. +apt-get upgrade ​-
- +apt-get install ​-y bison flex gettext texinfo libncurses5-dev libncursesw5-dev gperf automake libtool pkg-config build-essential gperf genromfs libgmp-dev libmpc-dev libmpfr-dev libisl-dev binutils-dev libelf-dev libexpat-dev gcc-multilib g++-multilib picocom u-boot-tools util-linux chrony libusb-dev libusb-1.0.0-dev kconfig-frontends python3-pip
-În dezvoltarea sistemelor embedded, QEMU este folosit deoarece poate emula un sistem de calcul complet, nefiind necesar ca sistemul țintă (//​target//​) pentru care se face dezvoltarea,​ și sistemul //host//, pe care se face dezvoltarea,​ să folosească aceeași arhitectură. Acest lucru permite ca dezvoltarea software-ului pentru un sistem embedded să poată fi făcută în paralel cu proiectarea hardware-ului, lucru crucial pentru obținerea unui timp de dezvoltare scurt. Un alt avantaj pe care il poate avea emularea, mai ales a sistemelor low-end, este o viteză superioară a emulării pe un sistem //host// performant, în comparație cu sistemul //​target//​. +
- +
-==== Instalare ==== +
- +
-Cel mai simplu mod de instalare pe o distribuție Linux este de a folosi //package manager//-ul. În majoritatea distribuțiilor pachetul principal se numește ''​qemu''​ și cuprinde de obicei toate executabilele aferente diferitelor moduri de funcționare ale QEMU. Dacă se dorește doar modul de virtualizare cu KVM poate fi instalat pachetul ''​qemu-kvm'',​ iar dacă se dorește modul de emulare a unui sistem ARM poate fi instalat pachetul ''​qemu-system-arm''​. +
-<​note>​ +
-<code shell Ubuntu 18.04> +
-sudo apt-get update +
-sudo apt-get install qemu +
-sudo apt-get install qemu-kvm +
-sudo apt-get install qemu-system-arm+
 </​code>​ </​code>​
-</​note>​ 
- 
-Dacă distribuția folosită nu oferă un pachet pentru QEMU (ex: Windows) sau pachetul oferit conține o versiune prea veche (ex: Fedora 17), se poate alege instalarea din surse. În acest caz, sursele oficiale pot fi downloadate din [[https://​git.qemu.org/?​p=qemu.git;​a=summary| repository]]-ul de Git, iar pentru instrucțiuni de compilare se poate urmări [[http://​wiki.qemu.org/​download/​qemu-doc.html#​compilation| pagina de manual]]. 
- 
-==== Rulare ==== 
- 
-Pentru rularea unei mașini virtuale cu KVM se folosește comanda ''​qemu-kvm''​ împreună cu imaginea pentru hard disk. În acest caz imaginea hard disk-ului trebuie să conțină un sistem compatibil cu arhitectura //host//, accelerarea oferită de KVM putând fi folosită doar dacă //​guest//​-ul și //host//-ul folosesc arhitecturi compatibile (ex: x86_64). 
  
-Pentru rularea în //user-mode emulation// poate fi folosit unul din executabilele de forma ''​qemu-<​arch>''​ împreună cu executabilul pe care vrem să-l rulăm [[#​referinte| [5]]]. Bineînțeles,​ acest executabil trebuie să fie compatibil cu arhitectura aleasă, ''<​arch>'',​ iar momentan QEMU oferă suport pentru //user-mode emulation// ​ doar pe Linux și BSD. Dintre cele două, suportul pentru BSD nu este însă la fel de complet ca cel pentru Linux [[#​referinte| [6]]]+==== Descărcarea toolchain-ului ====
  
-<​note>​ 
-Exemplu de rulare in **user-mode emulation**:​ 
 <​code>​ <​code>​
-qemu-arm -cpu <​procesor<​executabil>+wget https://​github.com/​espressif/​crosstool-NG/​releases/​download/​esp-12.2.0_20230208/​xtensa-esp32-elf-12.2.0_20230208-x86_64-linux-gnu.tar.xz 
 +tar -xf xtensa-esp32-elf-12.2.0_20230208-x86_64-linux-gnu.tar.xz 
 +mkdir /​opt/​xtensa 
 +mv xtensa-esp32-elf/​ /​opt/​xtensa/​ 
 +echo "​export PATH=\$PATH:/​opt/​xtensa/​xtensa-esp32-elf/​bin" ​>> ​~/.bashrc 
 +source ~/.bashrc
 </​code>​ </​code>​
-</​note>​ 
  
-Pentru rularea în modul //system emulation// se folosește unul din executabilele de forma ''​qemu-system-<​arch>''​ împreună cu imaginea pentru hard disk [[#​referinte| [7]]].+==== Descărcarea repository-urilor ====
  
-<​note>​ 
-Exemplu de rulare in modul **system emulation**:​ 
 <​code>​ <​code>​
-qemu-system-arm -machine <​arhitectura>​ -cpu <​procesor -kernel <​kernel_file>​ -append "root=/dev/sda2" ​-drive file=<​rootfs_file>,​index=0,​media=disk,​format=raw +mkdir ~/nuttxspace && cd ~/nuttxspace 
 +git clone https://​github.com/​apache/​incubator-nuttx.git nuttx 
 +git clone https://​github.com/​apache/​incubator-nuttx-apps.git apps
 </​code>​ </​code>​
-</​note>​ 
  
 +<note tip>
 +NuttX folosește 2 directoare separate:
 +  * nuttx, care conține sistemul de operare: scheduler, drivere, sisteme de fișiere, etc.
 +  * apps, care conține aplicațiile.
  
-==== Configurare ==== +Una din etapele compilării presupune ca sistemul ​de build să creeze ​bibliotecă statică denumită ''​libapps.a''​ care va fi adăugată la binarul ​de NuttX în etapa de linking.
- +
-În modul mașină virtuală sau //system emulation// QEMU simulează un întreg sistem ​de calcul. În lipsa unor alte argumente se folosește însă o configurație implicită de sistem, care este specifică fiecărei arhitecuri în parteQEMU poate însă simula o gamă largă de configurații ​de sistem. În limbajul QEMU acestea se numesc //mașini// și pot fi selectate cu opțiunea ''​-machine''​. +
- +
-<​note>​ +
- +
-<code shell Nokia N800 tablet>​ +
-qemu-system-arm -machine n800 <disk image> +
-</​code>​ +
 </​note>​ </​note>​
  
-QEMU oferă însă și un control mai fin asupra configurației sistemului simulat printr-o serie de alte opțiuni, precum [[#​referinte| [8]]]: +==== Descărcarea tabelei ​de partiții și a bootloader-ului ====
-  * ''​-cpu''​ - specifică tipul de procesor care va fi emulat +
-  * ''​-m''​ - specifică dimensiunea memoriei RAM +
-  * ''​-hda'',​ ''​-hdb''​ etc. - specifică imaginea pentru primul hard disk, respectiv al doilea hard disk, ș.a.m.d +
-  * ''​-fda'',​ ''​-fdb''​ - specifică imaginea pentru primul floppy disk, respectiv al doilea floppy disk +
-  * ''​-cdrom''​ - specifică imaginea folosită de cdrom +
-  * ''​-serial'',​ ''​-parallel''​ - specifică porturile seriale, respectiv, paralele și modul de interacțiune a acestora cu //​host//​-ul +
-Configurații mai avansate pot fi obținute cu opțiunile ''​-device'',​ ''​-drive'',​ ''​-net'',​ ''​-soundhw'',​ ''​-bt''​ care adaugă dispozitive periferice, de stocare, plăci de rețea și de sunet și, respectiv, dispozitive bluetooth [[#​referinte| [8]]]. [[https://​qemu.weilnetz.de/​doc/​4.2/​qemu-doc.html| Documentația]] oferă informații despre toate aceste opțiuni, precum și multe altele. +
- +
-O altă opțiune utilă este ''​-kernel''​. Aceasta permite specificarea imaginii de kernel folosite de sistemul //guest// direct în comanda QEMU. Astfel, QEMU va încărca kernelul dintr-un fișier aflat pe sistemul //host// în loc de a-l cauta în imaginea de hard disk. Acest lucru poate reduce semnificativ timpul de iterație în momentul dezvoltării unui sistem embedded, deoarece nu mai este necesară recrearea imaginii de hard disk pentru fiecare modificare a kernel-ului. +
- +
-<note important>​ +
-Pe unele sisteme emulate este chiar obligatoriu ca opțiunea ''​-kernel''​ să fie prezentă, deoarece emularea sistemului nu include și un bootloader. Fără un bootloader, sistemul nu știe altfel cum să găsească imaginea de kernel. +
-</​note>​ +
- +
-De obicei, împreună cu specificarea imaginii de kernel este nevoie să specificăm și linia de comandă a kernel-ului. Pentru aceasta se folosește opțiunea ''​-append''​ împreună cu string-ul care vrem să fie pasat kernel-ului la bootare. +
- +
-O ultimă opțiune, folositoare mai ales pentru debugging, o reprezintă redirectarea monitorului către consolă. Acest lucru se face cu opțiunea ''​-monitor stdio''​. Monitorul oferă o interfață în linie de comandă care permite un control interactiv al modului în care se face emularea. +
- +
-==== Networking ==== +
- +
-Pentru a emula o interfață de rețea, QEMU se bazează pe două componente: //​device//​-ul prezentat //​guest//​-ului,​ configurat cu opțiunea ''​-device''​ sau ''​-net nic'', ​și //​back-end//​-ul care leagă acest device de //host//, configurat cu opțiunea ''​-netdev''​. Opțiunea ''​-device''​ nu este limitată la emula doar interfețe de rețea, ea putând configura orice dispozitiv suportat de către QEMU însă, unele plăci de rețea sunt suportate doar de opțiunea ''​-net nic''​. +
- +
-Pentru //​back-end//,​ QEMU suporta mai multe moduri, printre care: +
-  * ''​-netdev user''​ - //​user-mode//,​ rulează în user-space și nu necesită privilegii, însă interacțiunea cu rețeaua //host//-ului este complicată +
-  * ''​-netdev tap''​ - //tap//, conectează o interfață TAP a //​host//​-ului la un VLAN emulat, permițând o configurare detaliată a topologiei folosite de //guest//, însă configurarea este mai complicată +
-  * ''​-netdev bridge''​ - //​bridge//, ​ conectează o interfață TAP a //​host//​-ului la un bridge, care permite interacțiunea cu rețeaua fizică a //​host//​-ului +
-  * ''​-netdev socket''​ - //socket//, interconectează VLAN-urile a două sisteme emulate folosind TCP sau UDP. +
- +
-În mod implicit QEMU emulează un sistem cu o interfață de rețea reprezentată de un //device// specificat de //mașina// selectată, în modul //​user-mode//​. Aceasta configurare implicită nu ne oferă însă toată flexibilitatea unui //target// real, conectat la o rețea fizică. Din acest motiv în cadrul laboratorului ne vom folosi de modul //​bridge//​. +
- +
-//​Bridge//​-ul folosit de către //​back-end//​ se configurează cu parametrul ''​br=//<nume bridge>//'',​ iar //​device//​-ul pentru opțiunea ''​-net nic''​ se specifică prin parametrul ''​model=//<​device>//''​. Legatura dintre cele două componente se face prin adăugarea parametrului ''​netdev=//<​id>//''​ la //device// și a parametrului ''​id=//<​id>//''​ la //​back-end//​. Valoarea ''//<​id>//''​ trebuie bineînteles să fie identică pentru ca cele două componente să fie legate. În final, cele două opțiuni arată astfel: ''​-net nic,​model=<​device>,​netdev=<​id>​ -netdev bridge,​br=<​nume bridge>,​id=<​id>''​. +
- +
-<​note>​ +
- ​Înainte de realizarea configurațiilor de rețea, dezactivați conectarea automată din setările sistemului de operare (Settings -> Network -> Wired -> Connect Automatically (off)) +
-</​note>​ +
- +
-Pentru a crea și configura //​bridge//​-uri se folosește utilitarul **brctl** din pachetul **bridge-utils**. Crearea unui //bridge// care să ofere unui //guest// accesul la rețea fizică a //​host//​-ului se face astfel:+
  
 <​code>​ <​code>​
-sudo brctl addbr virbr0 #​ creăm bridge-ul +mkdir esp-bins 
-sudo brctl addif virbr0 <​interfata fizica>​ #​ adăugam interfața fizică a host-ului la bridge +curl -L "​https://​github.com/​espressif/​esp-nuttx-bootloader/​releases/​download/​latest/​bootloader-esp32.bin" ​-o esp-bins/​bootloader-esp32.bin 
-sudo ip address flush dev <​interfata fizica>​  ​               # ștergem adresa IP de pe interfața fizică, doar dacă avem adresă +curl -L "​https://​github.com/​espressif/​esp-nuttx-bootloader/​releases/​download/​latest/​partition-table-esp32.bin"​ -o esp-bins/​partition-table-esp32.bin
-                                                                # IP pe interfațăVa șterge și ruta default automat +
-sudo dhclient virbr0 ​                                           # obținem adresa IP pentru bridge și ruta default prin DHCP+
 </​code>​ </​code>​
  
-Dacă nu merge obținerea adreselor prin DHCP, se poate configura manual adresa ​și ruta default:+==== Compilarea ​și rularea ==== 
 <​code>​ <​code>​
-ip address show #​ notăm ip-ul și prefixul interfeței fizice +pip3 install esptool 
-ip route show #​ notăm ruta implicită +pip3 install pyserial 
-sudo brctl addbr virbr0 #​ creăm bridge-ul +cd ~/​nuttxspace/​nuttx 
-sudo brctl addif virbr0 <​interfata fizica>​ #​ adaugăm interfața fizică a host-ului la bridge +./​tools/​configure.sh ​-l esp32-sparrow-kit:​nsh 
-sudo ip address del <​ip>/<​prefix>​ dev <​interfata fizica>​ #​ mutăm adresa interfeței fizice +make -j4 
-sudo ip address add <ip>/<​prefix> ​dev virbr0 # pe bridge +esptool.py erase_flash 
-sudo ip link set dev virbr0 up +make flash ESPTOOL_PORT=/dev/ttyUSB0 ESPTOOL_BAUD=115200 ESPTOOL_BINDIR=../​esp-bins
-sudo ip route add default via <​gateway>​ #​ readăugam ruta implicită+
 </​code>​ </​code>​
  
-Pentru ca //bridge//-ul să fie acceptat ​de QEMU el trebuie configurat și în fișierul ''/​etc/​qemu/​bridge.conf''​ sub forma:+<​hidden>​Uneori mai sunt push-uite modificari la sistemul ​de build si este nevoie sa iti faci update la cross-compiler,​ de exemplu. Sansele sunt mici sa se fi modificat ceva de saptamana trecuta pana acum, dar just in case eu am testat codul pe v12.2.1, commit-urile: 
 +  - nuttx: dc096f951e482a7c3061288213ff0b3209afffcd 
 +  - apps: a48810f4a58efdae1cc0bb1981825721fdd93d9a  
 +</​hidden>​
  
-<code text bridge.conf> +În functie de tipul de placă pe care rulați, este posibil să fie nevoie să apăsați butonul de ''​BOOT''​ (''​IO0''​) atunci când încărcați NuttXAstfel, placa intră în modul de "​Download"​ - în mod normal, placa este în starea de "​Boot"​. Butonul trebuie apăsat doar atunci când se încearcă stabilirea conexiunii cu firmware-ul de pe ESP32, așa cum se poate vedea mai jos:
-allow virbr0 +
-</​code>​+
  
-===== Exerciții =====+{{ :​si:​laboratoare:​nuttx_download_mode.png |}}
  
-<note important>​ +Pentru ​a vă conecta la placă veți folosi ​''​picocom ​/dev/ttyUSB0 ​-b 115200''​.
-Atenție! ​Pentru ​rezolvarea laboratorului recomandăm folosirea sistemului de operare Ubuntu 18.04. Puteți folosi ​o mașină virtuală Ubuntu 18.04 Bionic Beaver download-ată de pe [[https://www.osboxes.org/​ubuntu/​|osboxes]] și rulată în [[https://​www.virtualbox.org/​|VirtualBox]] sau VmWare. \\ +
-Hint: ca să meargă copy-paste între host și guest pe VirtualBox, trebuie să activați Devices -> Shared Clipboard -> Bidirectional și să instalați Guest Additions (Devices -> Insert Guest Additions CD Image). +
-</​note>​+
  
-În cadrul exercițiilor vom încerca să emulăm un sistem cât mai apropiat de RaspberryPi. Deoarece QEMU nu are suport pentru SoC-ul Broadcom BCM2835 folosit ​de RaspberryPi [[#​referinte| [9]]]vom folosi o placă [[http://​infocenter.arm.com/help/topic/com.arm.doc.dui0225d/​DUI0225D_versatile_application_baseboard_arm926ej_s_ug.pdf| Versatile Platform Baseboard]] ca înlocuitor. Această placă conține un procesor ARM, bazat pe core-ul [[http://​www.arm.com/​products/​processors/​classic/​arm9/​arm926.php| ARM926EJ-S]]asemănător cu cel folosit ​de SoC-ul BCM2835, bazat pe core-ul [[http://​www.arm.com/​products/​processors/​classic/​arm11/​arm1176.php| ARM1176JZ-F]]. Acest ultim procesor implementează setul de instrucțiuni ARMv6 [[#​referinte| [9]]].+În cazul în care sistemul de build nu detectează în mod automat calea către repo-ul de appsaceasta poate fi specificată prin ''​-a <​path>''​Pentru toți parametri disponibili puteți folosi ''​./tools/configure.sh -h''​Alternativcalea către directorul ​de apps poate fi configurată prin ''​CONFIG_APPSDIR''​.
  
-Ca sistem ​de operare vom folosi ​distribuția [[https://​www.raspberrypi.org/downloads/raspbian/| Raspbian Wheezy]]Atât kernelul cât șfișierele distribuției au fost ușor modificate pentru a fi compatibile cu placa //Versatile PB//. +Dacă compilați pentru un alt tip de placă ESP32 - pentru un modul WROOM, ​de exemplu - trebuie să folosiți ''​./tools/configure.sh esp32-devkitc:​nsh''​. De asemenea, deoarece plăcile Sparrow sunt construite peste modulul WROVER, putețsă folosițși ''​./tools/configure.sh esp32-wrover-kit:​nsh''​. Însă în acest caz va trebui să configurați manual NuttX-ul prin ''​make menuconfig''​ astfel încât să aveți acces la componentele hardware adăugate pe Sparrow.
  
-0. Instalați programele ​și utilitarele necesare: +Încărcarea binarului pe placă se poate face și prin ''​esptool.py --chip esp32 --port /dev/​ttyUSB0 ​--baud 921600 write_flash 0x1000 ../esp-bins/bootloader-esp32.bin 0x8000 ​../esp-bins/partition-table-esp32.bin 0x10000 nuttx.bin''​.
-  * Instalați ''​git'',​ ''​vim''​ și ''​bridge-utils''​. +
-<​code>​ +
-sudo apt-get install git +
-sudo apt-get install vim +
-sudo apt-get install bridge-utils +
-</code> +
-  * Instalați toolchain-ul necesar pentru a cross-compila programe pentru RaspberryPi:​ 1) Clonați/download-ați [[https://​github.com/​raspberrypi/​tools|repo-ul]]; 2) Adăugați in ''​$PATH''​ calea către directorul ce conține executabilele necesare +
-<​code>​ +
-git clone --depth=1 https://​github.com/​raspberrypi/​tools.git +
-export PATH="/​home/​osboxes/​tools/arm-bcm2708/arm-linux-gnueabihf/bin:​$PATH"​ +
-</​code>​ +
-  * Instalați QEMU folosind instrucțiunile prezentate în acest [[https://​ocw.cs.pub.ro/​courses/​si/​laboratoare/​01#​instalare|laborator]]. +
-<​code>​ +
-sudo apt-get update +
-sudo apt-get install qemu +
-sudo apt-get install qemu-system-arm +
-</​code>​+
  
 +Dacă nu aveți erori, ar trebui să vă apară un log asemănător cu cel de mai jos:
  
 +{{ :​si:​laboratoare:​nuttx_flash_log.png?​750 |}}
  
-1. Aflați parametrii pentru opțiunile ''​-machine'' ​și ''​-cpu''​ necesari pentru a emula sistemul nostru.+În final, ar trebui să obținețși un log de boot asemănător cu cel din screenshot-ul atașat:
  
-<note tip> +{{ :si:laboratoare:​nuttx_boot_log.png?600 }}
-  * Re-citiți despre modalitățile de [[https://​ocw.cs.pub.ro/​courses/​si/laboratoare/​01?&#​rulare|rulare]]. +
-  * Citiți pagina de manual sau [[https://qemu.weilnetz.de/​doc/​4.2/​qemu-doc.html| documentația]] online pentru cele două opțiuni. +
-  * Hint: +
-<​code>​ +
-qemu-system-arm -machine ? +
-qemu-system-arm -machine <​platforma>​ -cpu ? +
-</​code>​ +
-</​note>​+
  
-2. Creați un program **hello world** pentru RaspberryPi linkat //static//. Aflați setul de instrucțiuni folosit de executabilul generat și apoi rulați-l în QEMU folosind //user-mode emulation// și emulând procesorul ARM1176JZ-F. Salvați comanda folosită pentru emulare.+===== Exerciții =====
  
-  ​Utilizaţi compilatorul ​**arm-linux-gnueabihf-gcc** din toolchain-ul download-at mai sus; +**1.** Folosind sistemul de build al NuttX, activați compilarea aplicației "​Hello,​ World!"​. Codul sursă îl puteți găsi în ''​apps/​examples/​hello''​. ​Odată încărcat pe placărulați ​aplicația din linie de comandă.
-  * Folosiți pentru compilator flag-ul ​''​-static'' ​pentru a obține un executabil linkat //static//. +
-  * Utilitarul **file** oferă informații despre conținutul fișierelor primite ca argument. +
-  * Bonus: Ce se întâmplă dacă rulați ​executabilul direct, fără QEMU? De ce?.+
  
 <note tip> <note tip>
-  * Re-citiți despre modalitățile de [[https://​ocw.cs.pub.ro/​courses/​si/​laboratoare/​01?&#​rulare|rulare]]+  * pentru a putea compila "​Hello,​ World!"​ trebuie să activați config-ul ''​CONFIG_EXAMPLES_HELLO''​ folosind ''​make menuconfig''​. Căutarea unui anume config se poate face la fel ca in VIM, folosind ''/''​ urmat de string-ul dorit
-  * Citiți introducerea acestui [[https://​www.kernel.org/​doc/​Documentation/​admin-guide/​binfmt-misc.rst| kernel feature]]. +  * odată compilat și încărcat NuttX, utilizați comanda ''?''​ pentru a vedea cum se poate rula aplicația.
-  * Veti afla mai multe despre cross-compilare in [[02| laboratorul 2]].+
 </​note>​ </​note>​
  
-3. Rulați distribuția Raspbian folosind QEMU în modul //system emulation//​. Salvați comanda folosită pentru emulare. +**2.** Asemănător exercițiului anterior, compilați și încărcați aplicația "​rgbled"​.
- +
-  ​Kernel-ul modificat pentru a rula pe platforma Versatile PB este disponibil [[https://​drive.google.com/​open?​id=0B0lgiPZNMMyvaEtfN3V4VVBxRjg| aici]]. +
-  ​Imaginea hard disk-ului (//​rootfs//​-ul) modificată pentru a rula pe platforma Versatile PB este disponibilă [[https://​drive.google.com/​open?​id=0B0lgiPZNMMyvOTFMakFuY1N2Q1E| aici]]. +
-  * Folosiți string-ul ''​root=/​dev/​sda2''​ pentru linia de comandă a kernel-ului. +
-  * La prima pornire distribuția Raspbian va rula un utilitar de configurare. Opțiunile implicite sunt suficiente pentru a porni sistemul.+
  
 <note tip> <note tip>
-  * Re-citiți despre modalitățile de [[https://​ocw.cs.pub.ro/​courses/​si/​laboratoare/​01?&#​rulare|rulare]]. +E nevoie de activarea config-ului ''​CONFIG_EXAMPLES_RGBLED''​Pentru a putea vedea cum NuttX compilează selectiv, doar pe baza config-urilor activate, vă puteți uita in fișierele ''​Kconfig''​.
-  * Nu uitați să specificați tipul procesorului ​și al mașinii emulate. +
-  * Revedeți parametrii de [[#​configurare| configurare]] ai QEMU și citiți pagina de manual sau [[https://​qemu.weilnetz.de/​doc/​4.2/​qemu-doc.html| documentația]] acestora.+
 </​note>​ </​note>​
  
-4. Adăugați sistemului emulat o interfață serială redirectată către //stdio//. Ce diferență observați? Salvați comanda folosită pentru emulare. +<note important>​ 
- +Dacă rulați pe plăcuțele verzi, trebuie să schimbați pinii LED-ului: 
-  * Rulați din nou distribuția și așteptați până se ajunge la ecranul de login. +  * CONFIG_ESP32_LEDC_CHANNEL0_PIN=25 
- +  * CONFIG_ESP32_LEDC_CHANNEL1_PIN=26 
-<note tip> +  * CONFIG_ESP32_LEDC_CHANNEL2_PIN=27
-  * Revedeți parametrii de [[#​configurare| configurare]] ai QEMU și citiți pagina de manual sau [[https://​qemu.weilnetz.de/​doc/​4.2/​qemu-doc.html| documentația]] acestora.+
 </​note>​ </​note>​
  
-5. Adăugați string-ul ''​console=ttyAMA0''​ liniei de comandă a kernel-ului. Ce efect are parametrul adăugat? Adăgați și parametrul ''​console=tty1''​ liniei de comandă a kernelului. Ce efect au cei doi parametri combinați? Salvați comanda folosită pentru emulare. +**3Bonus - ** faceți led-ul să clipească o dată pe secundă in roșu, verde, albastru.
- +
-<note tip> +
-  ​Parametrul ''​-append''​ nu poate fi invocat de mai multe ori, în ciuda numeluiDiferitele opțiuni trimise kernel-ului trebuie concatenate într-un singur șir. Folosiți ''<​nowiki>""</​nowiki>''​ pentru a escapa spațiile. +
-</​note>​ +
- +
-6. Configurați și testați accesul //​guest//​-ului la Internet. Salvați comanda folosită pentru emulare. +
- +
-  ​Pe host, creați un bridge, care să ofere guest-ului acces la rețeaua host-ului. +
-  ​Emulați interfața de rețea pentru placa Versatile PB folosind device-ul //​smc91c111//​. +
- +
-<note tip> +
-  * Înainte de realizarea configurațiilor de rețea, dezactivați conectarea automată din setările sistemului de operare (Settings -> Network -> Wired -> Connect Automatically (off)) și puneți placa de rețea a mașinii virtuale Ubuntu in modul de NAT (Devices -> Network -> Network Settings). Dacă folosiți ​rețea wired și nu vă merge cu NAT atunci setați ​pe modul Bridged Adapter. +
-  * Recitiți secțiunea de [[#​networking| configurare a rețelei]] în QEMU. +
-  * Folosiți ''​sudo''​ pentru rularea ''​qemu-system-arm''​. +
-</​note>​ +
- +
-7. Rulați programul compilat la punctul 2 pe //​guest//​. +
- +
-<note tip> +
-* Copiați executabilul folosind utilitarul ''​scp''​ de pe host pe guest. +
-</​note>​+
  
 ===== Resurse ===== ===== Resurse =====
- +  ​* [[https://nuttx.apache.org/docs/latest/|Documentatia oficiala NuttX]] 
-  * {{.:​qemu:​sol:​qemu_sol.zip| Soluție laborator}} (disponibilă în curând) +  * [[https://​en.wikipedia.org/wiki/Cross_compilerWhat is a cross-compiler?]] 
-  ​* [[https://drive.google.com/open?​id=0B0lgiPZNMMyvaEtfN3V4VVBxRjg| Kernel Raspbian compatibil cu QEMU]] +  ​[[https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/tools/idf-tools.html| ​ESP32 toolchain]] 
-  * [[https://drive.google.com/​open?​id=0B0lgiPZNMMyvOTFMakFuY1N2Q1ERootfs Raspbian compatibil cu QEMU]] +  ​[[https://​www.environmentallights.com/library/pwm| PWM and LEDs]]
-  * {{:​si:​lab:​2015:​kernel:​linux-rpi-3.18.y-armv6.patch| Kernel patch pentru activarea arhitecturii ARMv6 pentru placa Versatile PB}} +
-  * {{:​si:​lab:​2015:​kernel:​linux-rpi-3.18.y-qemu.patch| Kernel patch pentru a putea rula configurația implicită a Versatile PB în QEMU}} +
-  * {{:​si:​lab:​2015:​qemu:​2015-05-05-raspbian-wheezy-qemu.patch| Raspbian Wheezy rootfs patch pentru QEMU}} +
- +
- +
-===== Referințe ===== +
-  - [[http://​wiki.qemu.org/​Main_Page| QEMU website]] +
-  - [[https://​qemu.weilnetz.de/​doc/​4.2/​qemu-doc.html#​Introduction| QEMU man page (Introduction)]] +
-  - [[https://​en.wikibooks.org/wiki/QEMUQEMU Wikibooks page]] +
-  ​[[https://​en.wikipedia.org/​wiki/​QEMU| QEMU Wikipedia page]] +
-  ​[[https://qemu.weilnetz.de/doc/4.2/qemu-doc.html#​Linux-User-space-emulator| QEMU man page (Linux User space emulator)]] +
-  - [[https://wiki.freebsd.org/QemuUserModeToDo| QEMU BSD user-mode status page]] +
-  - [[https://​qemu.weilnetz.de/​doc/​4.2/​qemu-doc.html#​ARM-System-emulator| QEMU man page (ARM System emulator)]] +
-  - [[https://qemu.weilnetz.de/​doc/​4.2/​qemu-doc.html#​sec_005finvocationQEMU man page (Invocation)]] +
-  ​- [[http://​elinux.org/​RPi_Hardware| RaspberryPi hardware description]] +
-  - [[https://​www.techrepublic.com/article/how-to-enable-copy-and-paste-in-virtualbox/​|Copy-paste in VirtualBox]]+
si/laboratoare/01.1601137050.txt.gz · Last modified: 2020/09/26 19:17 by laura.ruse
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0