15 novembre
Pannello di controllo

Emulazione di sistemi Linux embedded con QEMU

Emulazione di sistemi Linux embedded con QEMU

 

1. introduzione

Lo sviluppo di software integrato si basa su dispositivi hardware integrati, come schede di sviluppo, dispositivi di moduli esterni, ecc., ma se il lavoro di debug non ha nulla a che fare con le periferiche, solo il debug del kernel può essere simulato utilizzando QEMU senza acquistare hardware.

È disponibile per host Linux e Windows e target PowerPC, ARM, MIPS e SPARC emulati. QEMU adotta l'approccio di fornire un livello di traduzione minimo tra l'host e il processore di destinazione. Il processore host è quello che esegue l'emulatore e il processore di destinazione è ciò che viene emulato.

Quella che segue è un'introduzione dettagliata al processo di configurazione dell'ambiente di sviluppo QEMU.

 

2. Ambiente

2.1 Ambiente utilizzato

* Ubuntu-18.04.1

O:

* PC: Windows 10

* Macchina virtuale：VirtualBox-5.18

* Sistema operativo virtuale：Ubuntu-18.04.1

* Scheda di sviluppo simulata: vexpress

2.2 Strumenti utilizzati durante la configurazione dell'ambiente

*qemu-4.2.0

* linux-4.14.172 (kernel di Linux)

* U-Boot-2017.05

* Busybox-1.31.1

* ARM-LINUX-GNUEABI-GCC

Metti tutti i file correlati in /home/joe/qemu

3. Installa strumenti di compilazione incrociata

# sudo apt install gcc-arm-linux-gnueabi

 

Controlla se l'installazione è andata a buon fine

$ ARM-LINUX-GNUEABI-GCC -V

Utilizzo delle specifiche integrate.

COLLECT_GCC=arm-linux-gnueabi-gcc

COLLECT_LTO_WRAPPER=/usr/lib/gcc-cross/arm-linux-gnueabi/7/lto-wrapper

Obiettivo: arm-linux-gnueabi

Configurato con: ../src/configure -v –with-pkgversion='Ubuntu/Linaro 7.5.0-3ubuntu1~18.04′–with-bugurl=file:///usr

Modello filettatura: posix

gcc versione 7.5.0 (Ubuntu/Linaro 7.5.0-3ubuntu1~18.04)

 

4. Configura e compila il kernel Linux

4.1 Scarica il kernel Linux

Scarica la versione del kernel richiesta da www.kernel.org.

Qui scarico l'ultima versione del kernel supportata a lungo termine linux-4.4.157

wget https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.4.157.tar.xz  nella directory /qemu

4.2 Decomprimere il kernel Linux

# tar xvJf linux-4.4.157.tar.xz

4.3 Compila il kernel Linux

// Inserisci la directory del file sorgente del kernel

# cd linux-4.4.157

make CROSS_COMPILE=arm-linux-gnueabi- ARCH=arm vexpress_defconfig

make CROSS_COMPILE=arm-linux-gnueabi-ARCH=arm menuconfig

Se l'esecuzione di menuconfig mostra che il pacchetto ncurses è mancante, esegui semplicemente il comando seguente per installarlo)

$ sudo apt-get install libncurses5-dev

Entra nella configurazione del menu ed effettua le seguenti impostazioni

Compila con cross toolchain

Dopo aver compilato con successo, Genera un file immagine del kernel nella directory

arch/arm/boot, zImage e dtb possono essere copiati in una cartella separata per un comodo utilizzo

 

5. Installa gli strumenti QEMU

5.1 Installa QEMU

* wget https://download.qemu.org/qemu-4.2.0.tar.xz

* tar xvJf qemu-4.2.0.tar.xz

* cdqemu-4.2.0

5.2 Installa i pacchetti dipendenti prima di configurare QEMU

# apt installa zlib1g-dev
# APT Installa libglib2.0-0 libglib2.0-dev
# APT Installa libsdl1.2-dev
# APT Installa libpixman-1-dev libfdt-dev

Per evitare che i file diventino disordinati dopo la compilazione, creare la directory del builder come percorso di destinazione intermedio per la compilazione.

Configura, compila e installa QEMU.

5.3 Configurare QEMU per supportare tutte le schede sotto l'architettura del braccio

# ../configure –target-list=arm-softmmu –audio-drv-list=

Se pixman non è presente quando viene visualizzato il seguente messaggio,

usa sudo apt-get install libpixman-1-dev per installarlo.

5.4 Visualizza la versione QEMU

5.5 Visualizza le schede di sviluppo supportate da QEMU

5.6 Esegui QEMU

# qemu-system-arm -M vexpress-a9 -m 512M -kernel ./zImage -dtb ./vexpress-v2p-ca9.dtb -nographic -append “console=ttyAMA0”

OR:

$ pwd

/casa/joe/qemu

# qemu-system-arm -M vexpress-a9 -m 512M -kernel linux-.4.157/arch/arm/boot/zImage -dtb linux-4.4.157/arch/arm/boot/dts/vexpress-v2p-ca9. dtb -nographic -append “console=ttyAMA0”

Per testare meglio e avviare qemu, puoi creare lo script di avvio start.sh e dare allo script il permesso di eseguire chmod +x start.sh

 

#! / Bin / bash

 

braccio-sistema-qemu \

-M Vexpress-a9 \

-m 512m \

-kernel /home/joe/jemu/linux-4.4.157/arch/arm/boot/zImage \

-dtb /home/joe/jemu/linux-4.4.157/arch/arm/boot/dts/vexpress-v2p-ca9.dtb \

-nografico \

-aggiungi “console=ttyAMA0”

 

6. Crea un file system root

Usa busybox per creare un semplice file system root.

6.1 Scarica lo strumento busybox

Scarica busybox da https://busybox.net/downloads/

# wget https://busybox.net/downloads/busybox-1.31.1.tar.bz2

# TAR XJVF Busybox-1.31.1.tar.bz2

# CD BusyBox-1.31.1

# fai defconfig

# make cross_compile = arm-linux-gnueabi-

# make Installa Cross_Compile = Arm-Linux-GnueAbi-

Vengono richieste le seguenti informazioni, che indicano che l'installazione è riuscita.

Al termine dell'installazione, il file di destinazione generato viene impostato per impostazione predefinita nella directory ./_install.

 

6.2 Generare il file system di root

6.2.1 compilazione e installazione di busybox

#mkdirrootfs

# sudo cp -r _install/* rootfs/

6.2.2 Aggiungere la libreria glibc, aggiungere il caricatore e la libreria dinamica nel file system di root

# sudo cp -r _install/* rootfs/

# sudo cp -p /usr/arm-linux-gnueabi/lib/* rootfs/lib/

6.2.3 Creare 4 dispositivi terminali tty (c sta per dispositivo a caratteri, 4 è il numero di dispositivo principale e 1~4 sono rispettivamente i numeri di dispositivo secondari)

 

6.3 Crea l'immagine del file system della scheda SD

6.3.1 Generare un'immagine della scheda SD vuota

# dd if=/dev/zero of=rootfs.ext3 bs=1M conteggio=32

6.3.2 Formatta la scheda SD come file system exts

# mkfs.ext3 rootfs.ext3

6.3.3 Masterizza rootfs su scheda SD

# sudo mount -t ext3 rootfs.ext3 /mnt -o loop

# sudo cp -rf rootfs/* /mnt/

# sudo smonta /mnt

 

7. Verifica

7.1 Avvia Qemù

Esegui il seguente comando per testare, controlla se il kernel compilato può essere eseguito correttamente

# sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel ~/qemu/zImage –dtb ~/qemu/vexpress-v2p-ca9.dtb -nographic -append “console=ttyAMA0”

Oppure usando Script:

 

Nel test di cui sopra, il kernel segnalerà il panico, suggerendo che ci manca il file system di root.

Il problema di cui sopra è dovuto allo strumento busybox generato nell'ambiente x86.

Abbiamo usato make install durante l'installazione di busybox, quindi dovresti usare

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-install

 

Lo strumento di compilazione genera lo strumento busybox utilizzato dalla piattaforma braccio

# file rootfs/bin/busybox

rootfs/bin/busybox: eseguibile ELF LSB a 32 bit, ARM, EABI5 versione 1 (SYSV), linkato dinamicamente, interprete /lib/ld-, per GNU/Linux 3.2.0, BuildID[sha1]=cbcd33b8d6c946cb19408a5e8e714de554c87f52, strippato

 

7.2 Verificare di nuovo

Ora, Qemu ha avviato il kernel Linux e montato correttamente il file system e può interagire con il sistema con semplici funzioni tramite il terminale seriale. Il problema di non essere in grado di eseguire /etc/init.d/rcS nel processo di stampa, devi solo aggiungere il file /etc/init.d/rcS. Il contenuto del file può essere un'istruzione prompt.

 

7.3 Esci da QEMU

Due modi per uscire da qemu

* In un altro ingresso terminale: kill all qemu-system-arm

* Nell'input Qemu: Ctrl+ A; X

QEMU: terminato

 

8. Avvia il kernel Linux tramite u-boot

I sistemi embedded di solito includono: u-boot, kernel, rootfs e appfs. La relazione posizionale di queste parti sulla scheda di sviluppo ARM mostrata nella figura seguente

 

Boot loader Parametri di avvio nocciolo rootfs App

 

I rootf possono essere eseguiti su scheda o PC

 

8.1 Preparare l'U-boot

8.1.1 Scarica u-boot

http://ftp.denx.de/pub/u-boot/, usiamo: u-boot-2021.01.tar.bz2

# tar -jxvf u-boot-2018.09.tar.bz2

8.1.2 Compila u-boot

#vim Makefile

CROSS_COMPILE = arm-linux-gnueabi-

# vimconfig.mk

ARCO = braccio

# make vexpress_ca9x4_defconfig, errore

Necessità: sudo apt install bison

sudo apt installa flex

quindi: # make -j4 errore

Necessità: esporta CROSS_COMPILE=arm-linux-gnueabi-

esporta ARCH=braccio

di nuovo: # make vexpress_ca9x4_defconfig

# make -j4

 

 8.1.3 Prova, avvia u-boot

$ sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel u-boot-2021.01/u-boot –nografico

 

8.2 Compilazione della configurazione del kernel

Usa u-boot per avviare l'immagine del kernel:

Necessità di compilare il kernel in formato uImage,

È necessario specificare l'indirizzo di caricamento di uImage in memoria

Specificare durante la compilazione del kernel: make LOADADDR=? uImmagine -j4

 

# cd /home/joe/qemu/linux-4.4.157

# make loadaddr = 0x60003000 uimage -j4

 

Al termine della compilazione di u-boot, verrà generato un file mkimage nella cartella degli strumenti, copiare questo file nella cartella bin nella directory del compilatore incrociato.

$ CD QEMU/Linux-4.4.157

Errore:

$ sudo apt installa u-boots u-boot

Ottieni uImage

9. Impostazioni delle funzioni di rete QEMU

Quando la macchina virtuale Qemu si avvia su u-boot, uImage deve essere caricato nella memoria e uImage può essere scaricato all'indirizzo specificato nella memoria tramite il server TFTP.

9.1 Verificare se il kernel host supporta il modulo tun/tap

// Installa i due strumenti da cui dipende la rete in bridge

# sudo apt install UML-Utilities Bridge-Utils

Crea il file del dispositivo tun: /dev/net/tun (generalmente creato automaticamente)

Modificare /etc/network/interfaces (configurare la rete, riavviare per avere effetto)

# sudo vim/etc/rete/interfacce

auto loiface lo inet loopbackauto enp0s3 // nome della rete virtuale cardauto br0iface br0 inet dhcpbridge_ports enp0s3

 

Non riavviare MAI

# riavvio

Quindi controlla l'ambiente di rete di Qemu

La porta di rete virtuale br0 è la porta di rete per la comunicazione tra la macchina virtuale Qemu e l'host Linux.

 

10. Installa il server TFTP

Crea un server TFTP per scaricare uImage nella memoria all'avvio di uImage per la scheda di sviluppo della simulazione Qemu

 

10.1 Installa lo strumento tftp

 

$ apt-get install tftp-hpa tftpd-hpa xinetd

 

10.2 Modificare il file di configurazione e impostare la directory del server TFTP

# sudo vim /etc/default/tftpd-hpa

......

TFTP_DIRECTORY="/home/joe/tftpboot"

......

10.3 Creare una directory tftp sull'host Linux

# mkdir/home/joe/tftpboot

# chmod 777 /home/joe/tftpboot

 

10.4 Riavviare il servizio tftp

# sudo /etc/init.d/tftpd-hpa riavvio

 

10.5 Impostare i parametri di avvio del kernel in u-boot

copia uImage e cexpress-v2p-ca9.dtb su tftpboot

Avvia Qemu per verificare

 

$ sudo qemu-system-arm -M vexpress-a9 -m 512M -kernel u-boot-2021.01/u-boot –nographic -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 -sd rootfs. ext3

 

Ora, la directory rootfs è un semplice file system root, che può essere trasformato in un file mirror e il file mirror può essere masterizzato sulla scheda di sviluppo, oppure il kernel Linux può essere avviato da u-boot in Qemu e montato sul file speculare. Può anche essere impostato per l'avvio tramite il file system di rete NFS.

 

11. Montare il file system NFS

11.1 Installare e configurare il servizio NFS

11.1.1 Installa

$ sudo apt installa nfs-kernel-server

 

11.1.2 Configurazione

$ sudo mkdir/home/joe/qemu/rootfs

$ sudo chown nessuno:nogroup /home/joe/qemu/rootfs

$ sudo chmod 777/home/joe/qemu/rootfs

$ sudo nano /etc /esportazioni

Aggiungi: /home/joe/qemu/rootfs *(rw,sync,no_root_squash)

 

Riavvia il server nfs:

$ sudo /etc/init.d/nfs-kernel-server restart

Oppure: $systemctl riavvia nfs-kernel-server

 

Controlla se la directory condivisa NFS è stata creata

$ sudo showmount – e

Quando si utilizza il file system di rete NFS, l'host Linux deve chiudere il firewall di sistema, altrimenti si verificheranno anomalie durante l'esecuzione del sistema.

 

Conclusione

Si spera che, con l'aiuto di questo blog, tu sappia di più su QEMU. Tutte le tecniche mostrate sopra sono state utilizzate in varie presentazioni al nostro programma. Non esiste un unico modo fisso per emulare con QEMU. Esplora diverse tecniche e scopri cosa funziona per te. Familiarizza con la conoscenza e rimarrai sorpreso di come può aiutarti in modi inaspettati.

28 ottobre
Pannello di controllo

Introduzione di Lichee Pi

Introduzione di Lichee Pi

Il LicheePi è un delicato computer a scheda singola, in esecuzione sulla piattaforma Allwinner V3S a basso costo che è diventata popolare negli ultimi anni. Può essere utilizzato per i principianti per imparare Linux o per lo sviluppo del prodotto. offre una vasta gamma di periferiche (LCD, ETH, UART, SPI, I2C, PWM, SDIO...) e prestazioni potenti.

 

       

        Lichee Zero Lichee Nano

 

 

 

       

                                 Lichee Pi Zero Lichee Pi Nano 

 

 

Caratteristiche

LIchee Pi Zero

Lichee Pi Nano
SoC Allwinner V3S Vincitore F1C100S
CPU ARM Cortex-A7 ARM9
Freq. 1.2GHz 408MHz
RAM 64MB DDR2 32MB DDR2
Archiviazione SPI Flash/Micro SD SPI Flash/Micro SD

Dsiplay

 

 * FPC LCD RGB 40P universale:

* Risoluzioni supportate: 272×480, 480×800,1024×600

* Chip RTP integrato, supporta un touch screen

 * FPC LCD RGB 40P universale:

* Risoluzioni supportate: 272×480, 480×800,1024×600

* Chip RTP integrato, supporta un touch screen

Interfaccia

 

 * Sdio x2
* SPI X1
* I2c x2
*UARTx3
* 100 M Ether x1 (include EPHY)
* USB OTG x1
* MIPI CSIx1
*PWMx2
* Lradc x1
* Altoparlantex2 + Mic x1		 * Sdio x1
* SPI X2
* Twix x3
*UARTx3
* USB OTG x1
* Uscita TV* PWM x2
* Lradc x1
* Altoparlantex2 + Mic x1

Informazioni elettriche

 

 Micro USB 5V, pin 2.54 mm 3.3V~5V alimentazione; Alimentatore con foro per timbro da 1.27 mm.

1GHz Linux IDLE eseguito 90~100mA; CPU-burn corsa ~180mA

Temperatura di stoccaggio -40 ~ 125

Temperatura di esercizio -20~70

 Micro USB 5V, pin 2.54 mm 3.3V~5V alimentazione; Alimentatore con foro per timbro da 1.27 mm.

408MHz Linux IDLE eseguito 90~54mA; con corrente di funzionamento dello schermo ~250mA

Temperatura di stoccaggio -40 ~ 125

Temperatura di esercizio -20~70

 

La temperatura durante l'esecuzione dello stress test di Linux è solo leggermente superiore alla temperatura corporea.

 

Lichee Pi supporta molti OS come: Linux, RT-Tread, Xboot o nessun sistema operativo.

Come la maggior parte degli MCU, il Lichee Pi può connettersi a diverse interfacce a bassa velocità, come GPIO, UART, PWM, ADC, I2C, SPI e altro. Inoltre, può eseguire altre periferiche ad alta velocità come RGB LCD, EPHY, MIPI CSI, OTG USB e altro. Il Lichee Pi ha un codec integrato che consente il collegamento diretto a una cuffia o un microfono.

 

Connettore display:

L'LCD universale 40P è dotato di retroilluminazione a led e linee a quattro fili, tocco di resistenza elettrica, che è molto adatto per la visualizzazione e l'interazione. A13 supporta anche la funzione di tocco della resistenza a quattro fili, può eseguire il rilevamento del tocco a due punti.

 

Questa interfaccia è compatibile con l'interfaccia di VISUALIZZAZIONE ORIENT quando creo i miei prodotti.

 

RGB a VGA:

 

RGB a HDMI:

 

RGB a GPIO:

 

RGB a DVP CSI:

 

Link Lichee Pi:

http://dl.sipeed.com/
Wiki: maixpy.sipeed.com
Blog：blog.sispeed.com
Gruppo Telegram: https://t.me/sipeed

15 Settembre
Pannello di controllo

Introduzione a Orienta Display Embedded Project

Introduzione a Orienta Display Embedded Project

Orient Display è uno dei display leader al mondo Produttori di display LCD che è stata fondata nel 1996 da dirigenti con più di 25 anni di ricerca e sviluppo e esperienza di produzione. Oltre alla visualizzazione, Orient Display si è concentrato anche sulle tecnologie integrate che includono l'architettura ARM e ha accumulato una ricca esperienza nei prodotti integrati.

Ora i servizi tecnici di Orient Display includono hardware, software e consulenza.

 

Il nostro Team hardware realizzare prototipi in brevissimo tempo secondo le vostre idee e requisiti di design. Siamo specializzati nella progettazione di schede economiche o complesse ad alte prestazioni per soddisfare le vostre esigenze di elevata affidabilità in un breve ciclo di sviluppo.

– Progettazione schematica

– Layout PCB

– Personalizzazione del prodotto industriale

 

Il nostro Team software è specializzato in sistemi basati su Linux Disegni ARM®, Processore PowerPC e x86, solo per citarne alcuni. In qualità di fornitore di soluzioni complete per Linux, Android e WinCE in sistemi embedded, siamo in grado di risolvere i problemi relativi ai sistemi end-to-end dei vostri prodotti.

– Migrazione, ottimizzazione e personalizzazione del sistema

– Promuovere lo sviluppo

– Sartoria del kernel

– Porting di LINUX KERNEL su ARM, PPC o scheda x86

– Sviluppo APP (applicazioni, Linux QT, Linux C/++）

 

Il nostro FAE team fornirvi anche una gamma completa di tecnologie per i vostri prodotti o semilavorati.

– Forniamo consulenza sulle risorse software e hardware dei nostri prodotti;

– Risolviamo i problemi riscontrati durante l'utilizzo dei manuali software e hardware dei nostri prodotti;

– Supporto tecnico post vendita OEM e ODM;

– Manutenzione e aggiornamento dei dati;

– I prodotti Orient Display sono supportati dal nostro LA GARANZIA DEL PREZZO PIU’ BASSO.

 

Sequenza di sviluppo

 

1. Analisi dei requisiti di sistema

* Attività di progettazione, obiettivi, specifiche

– Questo fornito dai nostri clienti

* Requisito funzionale e non funzionale

– Includi prestazioni del sistema, costo, consumo energetico, volume, peso e altri fattori

 

2. Progettazione dell'architettura

Una buona architettura è la chiave del successo del design. In questo passaggio, è spesso necessario eseguire le seguenti operazioni:

  • Seleziona il chip principale:

— ARM Cortex A, R o M, o PowerPc o ColdFire

  • Determinare l'RTOS:

—Linux, uClinux, Vxworks, freeRTOS, WinCE

  • Seleziona Visualizza:

- Pannello TFT, TFT leggibile alla luce del sole, Pannelli in vetro LCD, LCD grafico,  schermo OLED, Toccare Pannelli, Display LCD integrato or Display su misura by Orientare il display

  • Linguaggio di programmazione:

— c/c++, pitone, Java

  • Strumenti di sviluppo:

u-boot, busybox, QT, Ubuntu, stm32CubeIde, studio visivo, studio Android, keil uVision, studio RT-Tread

 

3. Co-progettazione hardware e software

Al fine di abbreviare il ciclo di sviluppo del prodotto:

Hardware:  Di solito iniziamo il progetto dalla scheda di valutazione come orient display AIY-A002M, AIY-A003M e AIY-A005M. in seguito la scheda personalizzata per adattarsi al progetto, scarterà le parti che non sono necessarie.

Sequenza di sviluppo del software:

  • Di solito scegliamo u-boot come Bootloader, esso 1)init cpu allo stato noto 2)init memory 3)init interrupt 4)init clock 5)load kernel all'indirizzo in esecuzione
  • Configura il kernel:

1) configurare il sistema kernel: *gestione della memoria, *file system, *driver di dispositivo, *stack di rete, *sistemi di I/O

2) scrivere il driver del dispositivo I/O *driver del dispositivo char, *driver del dispositivo block, *driver del dispositivo di rete

  • Seleziona Applicazioni:

*Seleziona una libreria utente *Crea applicazione utente *Configura il processo di inizializzazione *Crea root FS

 

4. SIntegrazione del sistema

Integra il software, l'hardware e i dispositivi di esecuzione del sistema, esegui il debug, trova e migliora gli errori nel processo di progettazione dell'unità.

 

5. Test del sistema

Testare il sistema progettato per vedere se soddisfa i requisiti funzionali indicati nelle specifiche. La più grande caratteristica del modello di sviluppo del sistema embedded è lo sviluppo completo di software e hardware.

 

Conclusioni

Orient Display ha un fantastico team di esperti di talento con l'esperienza e le capacità per creare un modulo display integrato dall'ideazione alla produzione.

In caso di domande, contattare i nostri ingegneri all'indirizzo: tech@orientdisplay.com.

14 Settembre
Pannello di controllo

Come selezionare i processori ARM

Come selezionare i processori ARM

Introduzione

La più ampia gamma di microprocessore core per quasi tutti i mercati applicativi. Esplorare ARM. I requisiti di prestazioni, alimentazione e costi per quasi tutti i mercati delle applicazioni, i processori sono cruciali. Le prestazioni del sistema dipendono fortemente dal suo hardware; questo articolo ti guiderà attraverso uno studio del processore ARM e sarà di grande aiuto nel tuo processo decisionale.

 

Una breve introduzione ad ARM

Figura 1. Roadmap dei processori ARM

 

Prima del 2003, esistono processori ARM classici che includono ARM7 (architettura ARMv4), ARM9 (architettura ARMv5) e ARM11 (architettura ARMv6). ARM7 non ha MMU (unità di gestione della memoria), non può eseguire sistemi multi-processo multiutente come Linux e WinCE. Può eseguire solo sistemi come ucOS e ucLinux che non necessitano di MMU. ARM9 e ARM11 sono CPU integrate con MMU, che possono eseguire Linux.

Dopo il 2003, quando si è trattato dell'architettura ARMv7, ha preso il nome da Cortex e diviso in tre serie: Cortex-A, Cortex-R e Cortex-M.

  • Corteccia-A — core del processore dell'applicazione per sistemi ad alta intensità di prestazioni
  • Corteccia-R – core ad alte prestazioni per applicazioni in tempo reale
  • Corteccia-M – core di microcontrollori per un'ampia gamma di applicazioni embedded

In poche parole, Corteccia-A sono adatte per applicazioni che hanno requisiti di elaborazione elevati, eseguono sistemi operativi avanzati e forniscono un'esperienza grafica e multimediale interattiva. Corteccia-R sono adatti per ciò che richiede affidabilità, alta disponibilità, tolleranza ai guasti, manutenibilità e risposta in tempo reale. Corteccia-M serie sono destinate a MCU e applicazioni finali sensibili ai costi e all'alimentazione.

 

Cortex-A VS Cortex-R VS Cortex-M

Corteccia-A

La categoria di processori Cortex-A è dedicata ai dispositivi Linux e Android. Qualsiasi dispositivo – a partire da smartwatch e tablet e proseguendo con le apparecchiature di rete – può essere supportato da processori Cortex-A.

  • I processori Cortex-A (A5, A7, A8, A9, A12, A15 e A17) si basano sull'architettura ARMv7-A
  • Il set di funzionalità comuni per i processori A include un motore di elaborazione multimediale (NEON), uno strumento per scopi di sicurezza (Trustzone) e vari set di istruzioni supportati (ARM, Thumb, DSP ecc.)
  • Le caratteristiche principali dei processori Cortex-A sono le massime prestazioni e la brillante efficienza energetica strettamente raggruppate per fornire agli utenti il ​​miglior servizio possibile

Le principali caratteristiche del processore Cortex-A:

Cortex-A5: Il Cortex A5 è il membro più piccolo e più basso di potenza della serie Cortex A, ma può ancora dimostrare prestazioni multicore, è compatibile con i processori A9 e A15.

Cortex-A7: Il consumo energetico di A7 è quasi lo stesso di A5, ma le prestazioni fornite da A7 sono superiori del 20% rispetto ad A5 e la piena compatibilità architettonica con Cortex-A15 e Cortex-A17. Il Cortex-A7 è la scelta ideale per implementazioni di smartphone e tablet sensibili ai costi.

Contrex-A15: Il Cortex-A15 è il membro più performante di questa serie, fornendo il doppio delle prestazioni rispetto all'A9. A15 trova la sua applicazione in dispositivi di fascia alta, server a bassa potenza e infrastrutture wireless. Questo è il primo supporto del processore per la gestione dei dati e soluzioni di ambiente virtuale.

Contrex-A17: Il Cortex-A17 dimostra prestazioni superiori del 60% rispetto a quello dell'A9. L'obiettivo principale è soddisfare le esigenze dei dispositivi di classe premium.

Contrex-A50: Contrex-A50, l'ultima serie, sono costruiti sull'architettura ARMv8 e portano con sé il supporto per Arch64-bit un sistema ad alta efficienza energetica. Un'ovvia ragione per il passaggio a 64 bit è il supporto di oltre 4 GB di memoria fisica, già raggiunto su Cortex-A15 e Cortex-A7.

 

Corteccia-R

I processori Cortex-R sono destinati ad applicazioni in tempo reale ad alte prestazioni come controller di dischi rigidi, lettori multimediali di apparecchiature di rete e altri dispositivi simili. Inoltre, offrono anche un ottimo supporto per l'industria automobilistica come airbag, sistemi di frenatura e gestione del motore.

Corteccia-R4:  Cortex-R4 è adatto per applicazioni automobilistiche. Può avere un clock fino a 600 MHz, ha una pipeline a 8 stadi con doppio problema, pre-fetch e un sistema di interrupt a bassa latenza che lo rende ideale per i sistemi critici per la sicurezza.

Corteccia-R5: Cortex-R5 estende le funzionalità offerte da R4 e aggiunge maggiore efficienza, affidabilità e migliora la gestione degli errori. L'implementazione dual-core consente di creare sistemi molto potenti e flessibili con risposte in tempo reale.

Corteccia-R7: Il Cortex-R7 estende significativamente le prestazioni. Sono caratterizzati da una pipeline a 11 fasi e consentono sia l'esecuzione fuori ordine che la previsione dei rami di alto livello. Gli strumenti possono essere implementati per il multiprocessing lock-step, simmetrico e asimmetrico. Il controller di interrupt generico è un'altra caratteristica significativa che dovrebbe essere menzionata.

 

Corteccia-M

Cortex-M progettato specificamente per il mercato MCU. La serie Cortex-M è costruita sull'architettura ARMv7-M (utilizzata per Cortex-M3 e Cortex-M4) e la più piccola Cortex-M0+ è costruita sull'architettura ARMv6-M. È sicuro dire che il Cortex-M è diventato per il mondo a 32 bit ciò che l'8051 è per l'8 bit: un core standard del settore fornito da molti fornitori. La serie Cortex-M può essere implementata come soft core in un FPGA, ad esempio, ma è molto più comune trovarli implementati come MCU con memorie, clock e periferiche integrati. Alcuni sono ottimizzati per l'efficienza energetica, alcuni per alte prestazioni e alcuni sono personalizzati per un segmento di mercato specifico come la misurazione intelligente

Per le applicazioni particolarmente sensibili ai costi o che stanno migrando da 8 bit a 32 bit, il membro più piccolo della serie Cortex-M potrebbe essere la scelta migliore.

Corteccia-M0: Il Cortex-M0+ utilizza il set di istruzioni Thumb-2 e dispone di una pipeline a 2 stadi. Caratteristiche significative sono il bus per GPIO a ciclo singolo e il micro buffer di traccia.

Cortex-M3&M4:  Il Cortex-M3 e il Cortex-M4 sono core molto simili. Ciascuno offre una pipeline a 3 fasi, più bus a 32 bit, velocità di clock fino a 200 MHz e opzioni di debug molto efficienti. La differenza significativa è la capacità del core Cortex-M4 per DSP. Cortex-M3 e Cortex-M4 condividono la stessa architettura e set di istruzioni (Thumb-2). Se la tua applicazione richiede la matematica in virgola mobile, lo farai molto più velocemente su un Cortex-M4 rispetto a un Cortex-M3. Detto questo, per un'applicazione che non utilizza le funzionalità DSP o FPU del Cortex-M4, vedrai lo stesso livello di prestazioni e consumo energetico su un Cortex-M3. In altre parole, se hai bisogno della funzionalità DSP, scegli un Cortex-M4. Altrimenti, il Cortex-M3 farà il lavoro.

 

Conclusione

Figura 2. Panoramica sulla corteccia

 

I processori ARM offrono una varietà di funzionalità per scopi diversi. Con un po' di riflessione e di indagine, sarai in grado di trovare il processore giusto che si adatta alle tue esigenze applicative. che si tratti di un tablet di fascia alta o di un nodo sensore wireless a bassissimo costo.

È una sfida fare la scelta giusta del core Cortex e trasformare l'idea in realtà. Ma un team di professionisti esperti può occuparsi di tutti i problemi e implementare concetti di qualsiasi complessità.

Orient Display si è concentrato sulle tecnologie relative ai processori ARM per molti anni e ha accumulato una ricca esperienza nello sviluppo e nell'implementazione di prodotti di architettura ARM. Mentre lancia continuamente piattaforme di sviluppo e core board che soddisfano le esigenze generali del mercato, affronta anche le esigenze di progetto individuali dei clienti. Fornire servizi personalizzati.

Il nostro team hardware è in grado di produrre prototipi nel più breve tempo possibile in base alle tue idee e necessità di progettazione. Il nostro team software può aiutarti a personalizzare tutte le funzioni del livello del driver di taglio.

Contattaci e ti aiuteremo a realizzare i tuoi piani dall'idea iniziale al prodotto finale.

08 Settembre
Pannello di controllo, Displays

Come utilizzare i display LCD grafici con Raspberry Pi?

Come collegare LCD grafico a Raspberry PI?

L'articolo mostra come collegare un 128×64 display LCD grafico ad un Raspberry Pi.

L'LCD utilizzato è un 128×64 con controller LCD di ST7565. Può essere alimentato direttamente dal binario Raspberry Pi 3.3V. Richiede 5 pin GPIO per i dati.

Lo schema è che CS (Chip Select), RST (Reset) e A0 (Register Select) possono essere collegati a qualsiasi 3 pin GPIO. In questo esempio, 8,24 e 25 sono i valori predefiniti. È possibile specificare valori diversi come parametri durante l'istanza della classe Python ST7565. SCLK (Serial Clock) sul GLCD va a GPIO 11, che è l'orologio seriale del Pi. SID (Serial Input Data) sul GLCD va a GPIO 10 sul Pi che è MOSI. GPIO 10 e 11 devono essere utilizzati per SID e SCLK. Vdd è collegato a un pin da 3.3 V sul PI e anche le masse sono collegate.

Il display LCD ha una retroilluminazione RGB. I pin LED possono andare a 16,20 e 21 di GPIO. Per controllare il colore dal Pi, specificando i pin RGB quando si istanzia la classe ST7565. Le resistenze devono essere poste in serie per limitare la corrente per evitare la rottura del LED. La luminosità del LED può essere modificata utilizzando diversi valori di resistori. Sarà meglio regolare la corrente in modo che sia di circa 20 mA, ovviamente, valori diversi risulteranno in un diverso mix di colori. È molto difficile mescolare un colore bianco puro. Si prega di calcolare attentamente il valore del resistore, a 40 mA, la luminosità del LED diminuirà bruscamente con il tempo, con la corrente prossima a 60 mA, il LED potrebbe guastarsi e danneggiarsi in modo permanente.

Come programmare un LCD grafico?

Il display è di 128 pixel in orizzontale per 64 pixel in verticale. Il display LCD può essere suddiviso in 8 pagine orizzontali. Sono numerati da 3 a 0 e da 7 a 4 dall'alto in basso. Ogni pagina include 128 colonne e 8 righe di pixel. Per indirizzare i pixel, specificando il numero di pagina e colonna, e inviare un byte per riempire 8 pixel verticali contemporaneamente.

Il display ha SPI (Interfaccia periferica seriale) per connettersi a Pi. SPI richiede 3 linee MOSI, MISO e Clock. Il Pi è il master e il GLCD è lo slave. In questo esempio, solo in scrittura su GLCD e non pronto, quindi sono necessarie la connessione alle linee MOSI e Clock. MOSI è l'uscita dal Pi al GLCD e il Clock sincronizza i tempi.

  1. Abilita SPI su Raspberry Pi prima di tutto
  2. Dal menu raspi-config, seleziona Opzioni avanzate, quindi SPI. Quindi selezionare Sì per "Vorrebbe abilitare l'interfaccia SPI". Premi OK, riavvia. Selezionare Sì per "il modulo kernel SPI da caricare per impostazione predefinita". Riavvia il Pi dopo aver abilitato SPI. Quindi prova SPI usando IsmodDovrebbe restituire SPI_bcm2708 o spi_bcm2835 a seconda della versione Pi. La libreria python SPI richiede python2.7 dev che può essere installato con apt-get install:
  3. La Libreria SPI Python è chiamato py-spidev. Può essere installato usando git:GLCD La libreria Python per il Pi può essere scaricata dal sito GitHub.
  4. La libreria principale ST7565 (st7565.py) gestisce disegno, testo e bitmap e un modulo font (xglcd_font.py) per caricare i font X-GLCD. Ecco i comandi di disegno di base per creare punti, linee, rettangoli, cerchi, ellissi e poligoni regolari: Per maggiori dettagli, fare riferimento al riferimento di seguito o contatta i nostri ingegneri.
03 Settembre
Pannello di controllo

Iniziare con i progetti basati sulla scheda STM32G071RB utilizzando STM32CubeIDE

Iniziare con i progetti basati sulla scheda STM32G071RB utilizzando STM32CubeIDE

Controlla il nostro Pannello di controllo!

Iniziare con un microcontrollore basato su ARM a 32 bit è sempre un po' scoraggiante. Ci sono troppi microcontrollori, piattaforme, schede di sviluppo, strumenti e software disponibili. Questa nota descrive passo passo come iniziare un progetto LED.

Per iniziare: sulla scheda di sviluppo STM32G071RB

Caratteristiche:

  • Core: CPU Arm® Cortex®-M32+ a 0 bit, frequenza fino a 64 MHz
  • Fino a 128 Kbyte di memoria Flash, 36 Kbyte di SRAM
  • Controller DMA a 7 canali con mappatura flessibile
  • ADC a 12 bit, 0.4 µs (fino a 16 canali esterni)
  • Due DAC a 12 bit, sample-and-hold a bassa potenza
  • Due I2C, quattro USART, un UART a bassa potenza, due SPI

 

Per iniziare: installare STM32CubeIDE

È possibile scaricare STM32CubeIDE dal loro st.com. È gratis. Installa STM32CubeIDE seguendo Guida all'installazione di STM32CubeIDE.

 

Il tuo primo progetto: LED lampeggiante

Prima di poter iniziare a scrivere codice, dobbiamo creare un progetto. È simile alla maggior parte degli altri IDE: i progetti vengono utilizzati per raggruppare tutte le impostazioni, il codice e le definizioni in un'unica raccolta, tutti gestiti dalla stessa applicazione.

 

 

PASSO 1: Avvia un nuovo progetto, dall'icona in alto a sinistra (o dal menu File > Nuovo > Progetto STM32) per iniziare.

 

Passaggio 2: nome del progetto: G0_LED, quindi fare clic sul pulsante Fine.

Dal diagramma schematico che il LED4 è controllato da STM32G071 e la porta è PA5.

Passaggio 3: da System Core > SYS, selezionare Serial Wire, impostare PA5 come GPIO_OUTPUT.

L'impostazione utilizza l'etichetta per PA5 come LED_GREEN come di seguito:

 

Passaggio 4: quindi generare codice.

 

CubeIDE, su cui è sviluppata questa funzionalità, genera file C con cui lavorare in una directory Src e inserisce un HAL (Hardware Abstraction Layer) in una directory Include. Sembra che CubeIDE funzioni esattamente allo stesso modo. Espandi le cartelle a destra sotto la vista del progetto e guarda cosa ha generato per funzionare per te.

 

 

Passaggio 5: aggiungiamo ora un po' di codice C tutto nostro! Dopo l'area Infinite Loop, aggiungeremo il codice per attivare il LED nella sezione 3 come di seguito:

 

 

Compilare il progetto e scaricarlo sulla bacheca

STM32CubeIDE rende effettivamente abbastanza facile compilare il nostro lavoro e inserirlo nel chip STM32. Il primo passo è produrre il .elf compilato (una versione binaria del nostro codice). Per generare il .elf, dobbiamo fare una build. È facile come premere il pulsante di creazione sulla barra degli strumenti.

Ora, le informazioni sulla build sono presentate nella console nella parte inferiore dello schermo.

Ora quello che vogliamo fare è inviare questo binario compilato al microcontrollore STM32.

Colleghiamo il kit di sviluppo:

Il LED di alimentazione rosso (a sinistra dell'interruttore blu) è acceso, così come il LED di comunicazione più grande (tramite il cavo USB). All'interno di STM32CubeIDE, seleziona il pulsante Esegui.

Questo aprirà la finestra di dialogo Esegui (dato che è la prima volta che lo eseguiamo). Le impostazioni che scegliamo ora verranno salvate come configurazione di esecuzione che possiamo riutilizzare o modificare in seguito.

Basta premere Applica e poi OK e il download procederà. La Console ora si riempirà di un testo interessante:

Il LED si accende e si spegne ogni 500 ms. hai tutto pronto.

23 Luglio
Pannello di controllo

STM32 contro Arduino

STM32 contro Arduino

Controlla il nostro Pannello di controllo!

 

Arduino

Arduino è più creativo, indebolisce il funzionamento di hardware specifico, le sue funzioni e la sua sintassi sono molto semplici, ed è molto “stupido”.

La maggior parte del controllo principale di Arduino è il microcontrollore AVR. Il vantaggio di Arduino è che ha un alto incapsulamento del codice e meno frasi, il che riduce la difficoltà dello sviluppo del software.

Arduino è relativamente facile da avviare, se comprendi un po' di hardware e C++, puoi svilupparlo.

La maggior parte delle funzioni di Arduino ha librerie ben costruite, quindi è molto semplice da usare, ma la controllabilità di funzioni leggermente più complicate è scarsa. 

 

STM32

STM32 presta maggiore attenzione alla pratica ingegneristica. In effetti, ci sono molti strumenti semplici in fabbrica, come termoregolatori, normali controller per motori, PLC di fascia bassa e alcuni giocattoli civili, controller di gioco, tastiere e mouse cablati e altre periferiche e così via sono molto pratici.

STM32 viene utilizzato principalmente come prodotti per sviluppatori professionisti, che richiedono determinate conoscenze professionali, ma allo stesso tempo è relativamente complicato scrivere codice per realizzare funzioni. Ad esempio, la porta seriale emette una semplice stringa. Per Arduino può partire da un nuovo progetto e può essere realizzato con 10 righe di codice. Tuttavia, se utilizzi strumenti di sviluppo STM32 come Keil, potrebbero essere necessarie centinaia di righe di codice o più.

In termini di open source: le cose fatte con STM32 possono essere open source se vuoi open source e non puoi pubblicare nulla se non vuoi open source.

 

Conclusione

 

Ecco alcuni suggerimenti per la scelta:

Se sei uno studente ordinario al di sotto del livello universitario che non ha una profonda conoscenza dei linguaggi di programmazione, ti consigliamo di iniziare con Arduino. Se le abilità C sono deboli e ti viene in mente STM32, avrai presto l'idea di arrenderti.

Se studi solo per lavoro, decisamente il microcontrollore STM32.

Se stai imparando solo per divertimento e non sei un esperto in elettronica e non hai fiducia, si consiglia Arduino.

Se hai buone capacità di programmazione, si consiglia STM32. Dopo averlo fatto, puoi dare un'occhiata alle cose fatte dalla comunità open source Arduino e puoi farlo facilmente con STM32.

Naturalmente, se ne hai la capacità, puoi entrare in contatto con entrambi. Generalmente, puoi padroneggiare le funzionalità di base di Arduino in meno di una settimana. Se ne hai bisogno in futuro, puoi trapiantare liberamente il codice Arduino su piattaforme MCU come STM32.

In effetti, i due sono effettivamente rivolti in direzioni leggermente diverse. Arduino è la scelta degli appassionati di elettronica generale e del fai-da-te, mentre STM32 viene spesso utilizzato per lo sviluppo e la produzione di prodotti reali.