15 Nov
Painel de controle

Emulando sistemas Linux embarcados com QEMU

Emulando sistemas Linux embarcados com QEMU

 

1. Introdução

O desenvolvimento de software embarcado depende de dispositivos de hardware embarcados, como placas de desenvolvimento, dispositivos de módulos externos, etc., mas se o trabalho de depuração não tem nada a ver com periféricos, apenas a depuração do kernel pode ser simulada usando o QEMU sem a compra de hardware.

Está disponível para hosts Linux e Windows e destinos PowerPC, ARM, MIPS e SPARC emulados. O QEMU adota a abordagem de fornecer uma camada de tradução mínima entre o host e o processador de destino. O processador host é aquele que executa o emulador e o processador de destino é o que está sendo emulado.

A seguir, uma introdução detalhada ao processo de configuração do ambiente de desenvolvimento QEMU.

 

2. Ambiente

2.1 Ambiente usado

* Ubuntu-18.04.1

OU:

* PC: Windows10

* Máquina Virtual：VirtualBox-5.18

* SO Virtual：Ubuntu-18.04.1

* Placa de desenvolvimento simulado: vexpres

2.2 Ferramentas usadas na configuração do ambiente

* qemu-4.2.0

* linux-4.14.172 (Kernel Linux)

*u-boot-2017.05

* caixa ocupada-1.31.1

* braço-linux-gnueabi-gcc

Coloque todos os arquivos relacionados em /home/joe/qemu

3. Instale ferramentas de compilação cruzada

# sudo apt instalar gcc-brafrin-linux-gnueabi

 

Verifique se a instalação foi bem sucedida

$ arm-linux-gnueabi-gcc -v

Usando built-inspecs.

COLLECT_GCC=arm-linux-gnueabi-gcc

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

Alvo: arm-linux-gnueabi

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

Modelo de rosca: posix

gcc versão 7.5.0 (Ubuntu/Linaro 7.5.0-3ubuntu1~18.04)

 

4. Configurar e compilar o kernel do Linux

4.1 Baixe o Kernel Linux

Baixe a versão do kernel necessária em www.kernel.org.

Aqui eu baixo a versão relativamente mais recente do kernel com suporte de longo prazo linux-4.4.157

wget https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.4.157.tar.xz  para o diretório /qemu

4.2 Descompacte o kernel do Linux

# tar xvJf linux-4.4.157.tar.xz

4.3 Compilar Kernel Linux

// Digite o diretório do arquivo de origem do 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 a execução do menuconfig mostrar que o pacote ncurses está ausente, basta executar o seguinte comando para instalá-lo)

$ sudo apt-get install libncurses5-dev

Entre na configuração do menu e faça as seguintes configurações

Compilar com cadeia de ferramentas cruzada

Após a compilação bem-sucedida, gere um arquivo de imagem do kernel no diretório

arch/arm/boot, zImage e dtb podem ser copiados em uma pasta separada para uso conveniente

 

5. Instale as Ferramentas QEMU

5.1 Instalar o QEMU

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

* tar xvJf qemu-4.2.0.tar.xz

*cd qemu-4.2.0

5.2 Instale pacotes dependentes antes de configurar o QEMU

# apt instala zlib1g-dev
# apt instalar libglib2.0-0 libglib2.0-dev
# apt instalar libsdl1.2-dev
# apto instalar libpixman-1-dev libfdt-dev

Para evitar que os arquivos fiquem confusos após a compilação, crie o diretório do construtor como o caminho de destino intermediário para a compilação.

Configure, compile e instale o QEMU.

5.3 Configure o QEMU para suportar todas as placas sob a arquitetura do braço

# ../configure -tart-list = braço-softmmu -Audio-drv-list =

Se o pixman estiver ausente quando o prompt a seguir for exibido,

use sudo apt-get install libpixman-1-dev para instalá-lo.

5.4 Ver versão do QEMU

5.5 Ver placas de desenvolvimento suportadas pelo QEMU

5.6 Executar QEMU

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

OU:

$ pwd

/home/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”

Para testar melhor e iniciar o qemu, você pode criar o script de inicialização start.sh e dar permissão ao script para executar chmod +x start.sh

 

#! / Bin / bash

 

braço do 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 \

-nográfico \

-acrescentar “console=ttyAMA0”

 

6. Crie um sistema de arquivos raiz

Use o busybox para criar um sistema de arquivos raiz simples.

6.1 Baixe a ferramenta busybox

Baixe o busybox em 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

# faz defconfig

# make CROSS_COMPILE=arm-linux-gnueabi-

# make install CROSS_COMPILE=arm-linux-gnueabi-

As informações a seguir são solicitadas, indicando que a instalação foi bem-sucedida.

Após a conclusão da instalação, o arquivo de destino gerado assume como padrão o diretório ./_install.

 

6.2 Gerar sistema de arquivos raiz

6.2.1 compilar e instalar o busybox

#mkdir rootfs

# sudo cp -r _install/* rootfs/

6.2.2 Adicionar biblioteca glibc, adicionar carregador e biblioteca dinâmica no sistema de arquivos raiz

# sudo cp -r _install/* rootfs/

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

6.2.3 Crie 4 dispositivos terminais tty (c significa dispositivo de caractere, 4 é o número do dispositivo principal e 1~4 são os números do dispositivo secundário, respectivamente)

 

6.3 Faça a imagem do sistema de arquivos do cartão SD

6.3.1 Gerar uma imagem de cartão SD vazia

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

6.3.2 Formatar cartão SD como sistema de arquivos exts

#mkfs.ext3 rootfs.ext3

6.3.3 Gravar rootfs no cartão SD

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

# sudo cp -rf rootfs/* /mnt/

# sudoumount /mnt

 

7. Verifique

7.1 Iniciar Qemu

Execute o seguinte comando para testar, verifique se o kernel compilado pode ser executado com sucesso

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

Ou usando o script:

 

No teste acima, o kernel reportará pânico, sugerindo que não temos o sistema de arquivos raiz.

O problema acima é devido à ferramenta busybox gerada no ambiente x86.

Usamos make install ao instalar o busybox, então você deve usar

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

 

A ferramenta de compilação gera a ferramenta busybox usada pela plataforma arm

# arquivo rootfs/bin/busybox

rootfs/bin/busybox: executável LSB de 32 bits ELF, ARM, EABI5 versão 1 (SYSV), vinculado dinamicamente, interpretador /lib/ld-, para GNU/Linux 3.2.0, BuildID[sha1]=cbcd33b8d6c946cb19408a5e8e714de554c87f52, removido

 

7.2 Verifique novamente

Agora, o Qemu iniciou o kernel Linux e montou o sistema de arquivos com sucesso, podendo interagir com o sistema com funções simples através do terminal serial. O problema de não poder rodar /etc/init.d/rcS no processo de impressão, você só precisa adicionar o arquivo /etc/init.d/rcS. O conteúdo do arquivo pode ser uma instrução de prompt.

 

7.3 Sair do QEMU

Duas maneiras de sair do qemu

* Em outra entrada de terminal: mate todos os qemu-system-arm

* Na entrada do Qemu: Ctrl+A; X

QEMU: Terminado

 

8. Inicie o kernel Linux através do u-boot

Os sistemas embarcados geralmente incluem: u-boot, kernel, rootfs e appfs. A relação posicional dessas peças na placa de desenvolvimento ARM mostrada na figura abaixo

 

Carregador de inicialização Parâmetros de inicialização Núcleo rootfs Aplicativos

 

Rootfs pode ser executado em placa ou PC

 

8.1 Preparar o U-boot

8.1.1 Baixar u-boot

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

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

8.1.2 Compilar u-boot

# vim Makefile

CROSS_COMPILE = arm-linux-gnueabi-

#vimconfig.mk

ARCO = braço

# make vexpress_ca9x4_defconfig, erro

Necessidade: sudo apt install bison

sudo apt instalar flex

então: # make -j4 error

Necessário: export CROSS_COMPILE=arm-linux-gnueabi-

exportar ARCH = arm

novamente: # make vexpress_ca9x4_defconfig

# make -j4

 

 8.1.3 Teste, inicie o u-boot

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

 

8.2 Compilação da configuração do kernel

Use u-boot para inicializar a imagem do kernel:

Precisa compilar o kernel no formato uImage,

Precisa especificar o endereço de carregamento de uImage na memória

Especifique ao compilar o kernel: make LOADADDR=? uImagem -j4

 

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

#faça LOADADDR=0x60003000 uImage -j4

 

Após a conclusão da compilação do u-boot, um arquivo mkimage será gerado na pasta de ferramentas, copie este arquivo para a pasta bin no diretório do compilador cruzado.

$cdqemu/linux-4.4.157

Erro:

$ sudo apt instalar u-boot-tools

Obter uImage

9. Configurações de função de rede QEMU

Quando a máquina virtual Qemu inicia no u-boot, o uImage precisa ser carregado na memória e o uImage pode ser baixado para o endereço especificado na memória através do servidor TFTP.

9.1 Verifique se o kernel do host suporta o módulo tun/tap

// Instala as duas ferramentas das quais a rede em ponte depende

# sudo apt install uml-utilities bridge-utils

Criar arquivo de dispositivo tun: /dev/net/tun (geralmente criado automaticamente)

Modifique o /etc/network/interfaces (configure a rede, reinicie para entrar em vigor)

# sudo vim /etc/network/interfaces

auto loiface lo inet loopbackauto enp0s3 // nome da placa de rede virtualauto br0iface br0 inet dhcpbridge_ports enp0s3

 

NUNCA Reinicie

# reinicializar

Em seguida, verifique o ambiente de rede do Qemu

A porta de rede virtual br0 é a porta de rede para a comunicação entre a máquina virtual Qemu e o host Linux.

 

10. Instale o servidor TFTP

Crie um servidor TFTP para baixar o uImage para a memória ao iniciar o uImage para a placa de desenvolvimento de simulação Qemu

 

10.1 Instale a ferramenta tftp

 

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

 

10.2 Modifique o arquivo de configuração e defina o diretório do servidor TFTP

# sudo vim /etc/default/tftpd-hpa

......

TFTP_DIRECTORY =”/home/joe/tftpboot”

......

10.3 Crie um diretório tftp no host Linux

# mkdir /home/joe/tftpboot

#chmod 777 /home/joe/tftpboot

 

10.4 Reinicie o serviço tftp

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

 

10.5 Definir parâmetros de inicialização do kernel no u-boot

copie uImage e cexpress-v2p-ca9.dtb para tftpboot

Inicie o Qemu para verificar

 

$ 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. ramal3

 

Agora, o diretório rootfs é um sistema de arquivos raiz simples, que pode ser transformado em um arquivo espelho, e o arquivo espelho pode ser gravado na placa de desenvolvimento, ou o kernel Linux pode ser iniciado pelo u-boot no Qemu e montado no arquivo espelho. Ele também pode ser configurado para inicializar via sistema de arquivos de rede NFS.

 

11. Monte o sistema de arquivos NFS

11.1 Instalar e configurar o serviço NFS

NUNCA instale

$ sudo apt instalar servidor nfs-kernel

 

11.1.2 Configuração

$ sudo mkdir /home/joe/qemu/rootfs

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

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

$ sudo nano /etc/exportações

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

 

Reinicie o servidor nfs:

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

Ou: $systemctl restart nfs-kernel-server

 

Verifique se o diretório compartilhado NFS foi criado

$ sudo showmount –e

Ao usar o sistema de arquivos de rede NFS, o host Linux precisa fechar o firewall do sistema, caso contrário, ocorrerão anormalidades quando o sistema estiver em execução.

 

Conclusão

Espero que, com a ajuda deste blog, você saiba mais sobre o QEMU. Todas as técnicas demonstradas acima foram usadas em várias submissões ao nosso programa. Não há uma maneira única e fixa de emular com o QEMU. Explore diferentes técnicas e veja o que funciona para você. Familiarize-se com o conhecimento e você ficará surpreso em como ele pode ajudá-lo de maneiras inesperadas.

28 Out
Painel de controle

Introdução de Lichee Pi

Introdução de Lichee Pi

O LicheePi é um computador delicado de placa única, rodando na plataforma Allwinner V3S de baixo custo, que é popular nos últimos anos. Ele pode ser usado para iniciantes aprenderem Linux ou para desenvolvimento de produtos. oferece uma grande variedade de periféricos (LCD, ETH, UART, SPI, I2C, PWM, SDIO…) e desempenho poderoso.

 

       

        Lichia Zero Lichia Nano

 

 

 

       

                                 Lichia Pi Zero Lichia Pi Nano 

 

 

Funcionalidades

LICHEE PI ZERO

LICHEE PI NANO
SoC Allwinner V3S Vencedor F1C100S
CPU A ARM9
Freq. Operacional 1.2GHz 408MHz
RAM 64MB DDR2 32MB DDR2
Armazenamento SPI Flash/Micro SD SPI Flash/Micro SD

Ecrã

 

 * FPC LCD Universal 40P RGB:

* Resoluções suportadas: 272×480, 480×800,1024×600

* Chip RTP integrado, suporta tela sensível ao toque

 * FPC LCD Universal 40P RGB:

* Resoluções suportadas: 272×480, 480×800,1024×600

* Chip RTP integrado, suporta tela sensível ao toque

Interface

 

 *SDIO x2
* Spi x1.
* I2C x2
* UARTX3.
* 100M Éter x1 (inclui EPHY)
* USB OTG x1
*MIPI CSI x1
*PWMx2
* LRADC x1
* Alto-falante x 2 + Microfone x 1		 *SDIO x1
* Spi x2.
* TWIXx3
*UART x3
* USB OTG x1
* Saída de TV * PWM x2
* LRADC x1
* Alto-falante x 2 + Microfone x 1

Informação Elétrica

 

 Micro USB 5V, pinos de 2.54mm 3.3V~5V fonte de alimentação; Fonte de alimentação de furo de carimbo de 1.27 mm.

1GHz linux IDLE roda 90~100mA; execução de queima de CPU ~ 180mA

Temperatura de armazenamento -40 ~ 125

Temperatura operacional -20 ~ 70

 Micro USB 5V, pinos de 2.54mm 3.3V~5V fonte de alimentação; Fonte de alimentação de furo de carimbo de 1.27 mm.

408MHz linux IDLE roda 90~54mA; com corrente de operação da tela ~250mA

Temperatura de armazenamento -40 ~ 125

Temperatura operacional -20 ~ 70

 

A temperatura ao executar o teste de estresse do Linux é apenas um pouco mais alta que a temperatura do corpo.

 

O Lichee Pi suporta muitos sistemas operacionais, como: Linux, RT-Tread, Xboot ou nenhum sistema operacional.

Como a maioria dos MCU, o Lichee Pi pode se conectar a várias interfaces de baixa velocidade, como GPIO, UART, PWM, ADC, I2C, SPI e muito mais. Além disso, ele pode executar outros periféricos de alta velocidade, como RGB LCD, EPHY, MIPI CSI, OTG USB e muito mais. O Lichee Pi possui um codec integrado que permite conexão direta a um fone de ouvido ou microfone.

 

Conector de tela:

O LCD universal 40P vem com luz de fundo led e linhas de quatro fios, resistência elétrica ao toque, o que é muito adequado para exibição e interação. A13 também suporta a função de toque de resistência de quatro fios, pode realizar a detecção de toque de dois pontos.

 

Esta interface é compatível com a interface de MOSTRADOR ORIENTE produtos.

 

RGB para VGA:

 

RGB para HDMI:

 

RGB para GPIO:

 

RGB para DVP CSI:

 

Liche Pi Link:

http://dl.sipeed.com/
Wiki: maixpy.sipeed.com
Blog: blog.sipeed.com
Grupo do Telegram: https://t.me/sipeed

15 Set
Painel de controle

Introdução ao projeto integrado de exibição oriental

Introdução ao projeto integrado de exibição oriental

Orient Display é um dos principais monitores do mundo Fabricantes de monitores LCD que foi fundada em 1996 por executivos com mais de 25 anos de experiência em P&D e produção. Além da exibição, a Orient Display também se concentrou em tecnologias embarcadas que incluem arquitetura ARM e acumulou uma rica experiência em produtos incorporados.

Agora os Serviços Técnicos da Orient Display incluem hardware, software e consultoria.

 

NOSSO Equipe de hardware faça protótipos no menor tempo possível de acordo com suas ideias e requisitos de design. Nós nos especializamos no projeto de placas econômicas ou complexas de alto desempenho para atender às suas necessidades de alta confiabilidade em um curto ciclo de desenvolvimento.

– Projeto Esquemático

– Disposição da placa de circuito impresso

– Personalização de produtos da indústria

 

NOSSO Equipe de software é especialista em Linux Designs ARM®, Processador PowerPC e x86, para citar alguns. Como fornecedor de soluções completas para Linux, Android e WinCE em sistemas embarcados, podemos resolver os problemas relacionados ao sistema de ponta a ponta de seus produtos.

– Migração, otimização e customização do sistema

– Impulsionar o desenvolvimento

– Adaptação do Kernel

- Portando LINUX KERNEL para ARM, PPC ou placa x86

– Desenvolvimento de APP (aplicativo, Linux QT, Linux C/++）

 

NOSSO FAE Profissionais também oferece uma gama completa de tecnologias para seus produtos ou produtos semiacabados.

– Prestamos consultoria sobre recursos de software e hardware de nossos produtos;

– Resolvemos problemas encontrados durante o uso de manuais de software e hardware de nossos produtos;

– Suporte técnico pós-venda OEM e ODM;

- Manutenção e atualização de dados;

– Os produtos Orient Display são apoiados por nossos Garantia de preço mais baixo.

 

Sequência de Desenvolvimento

 

1. Análise de Requisitos do Sistema

* Tarefas de design, objetivos, especificações

– Isso fornecido por nossos clientes

*Requisito funcional e não funcional

– Incluir desempenho do sistema, custo, consumo de energia, volume, peso e outros fatores

 

2. Projeto de Arquitetura

Uma boa arquitetura é a chave para o sucesso do projeto. Nesta etapa, muitas vezes é necessário fazer as seguintes coisas:

  • Selecione o chip principal:

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

  • Determine o RTOS:

- Linux, uClinux, Vxworks, freeRTOS, WinCE

  • Selecione Exibir:

- Painel TFT, TFT legível à luz solar, Painéis de vidro LCD, LCD gráfico,  Tela OLED, Painéis de toque, Visor LCD embutido or Exibição feita sob encomenda by Orientar exibição

  • Linguagem de programação:

- c/c++, python, Java

  • Ferramentas de desenvolvimento:

u-boot, busybox, QT, Ubuntu, stm32CubeIde, visual studio, android studio, keil uVision, RT-Tread studio

 

3. Co-design de Hardware e Software

Para encurtar o ciclo de desenvolvimento do produto:

Hardware:  Normalmente começamos o projeto a partir da placa de avaliação, como a tela do oriente AIY-A002M, AIY-A003M e AIY-A005M. mais tarde vai a placa customizada para caber no projeto, descarte as peças que não precisa.

Sequência de Desenvolvimento de Software:

  • Normalmente escolhemos o u-boot como Bootloader, ele 1) init cpu para o estado conhecido 2) init memória 3) init interrupt 4) init clock 5) carregar kernel para o endereço de execução
  • Configure o kernel:

1) configurar o sistema do kernel: * gerenciamento de memória, * sistemas de arquivos, * driver de dispositivo, * pilha de rede, * Sistemas de E / S

2) escrever driver de dispositivo de E/S *driver de dispositivo char, *driver de dispositivo de bloco, *driver de dispositivo de rede

  • Selecione os aplicativos:

* Selecione uma biblioteca de usuário * Construa um aplicativo de usuário * Configure o processo de inicialização * Construa FS raiz

 

4. SIntegração do sistema

Integre o software do sistema, hardware e dispositivos de execução juntos, depure, encontre e melhore os erros no processo de projeto da unidade.

 

5. Teste do Sistema

Teste o sistema projetado para ver se ele atende aos requisitos funcionais fornecidos na especificação. A maior característica do modelo de desenvolvimento de sistema embarcado é o desenvolvimento abrangente de software e hardware.

 

Conclusão

A Orient Display tem uma equipe incrível de especialistas talentosos com experiência e recursos para criar um módulo de exibição integrado desde o conceito até a produção.

Se você tiver alguma dúvida, entre em contato com nossos engenheiros em: tech@orientdisplay. com.

14 Set
Painel de controle

Como selecionar processadores ARM

Como selecionar processadores ARM

Introdução

A mais ampla gama de microprocessador núcleos para quase todos os mercados de aplicativos. Explorar ARM. Requisitos de desempenho, energia e custo para quase todos os mercados de aplicativos e processadores são cruciais. O desempenho do sistema depende muito de seu hardware; este artigo irá guiá-lo no estudo do processador ARM e será de grande ajuda na sua tomada de decisão.

 

Uma breve introdução ao ARM

Figura 1. Roteiro dos processadores ARM

 

Antes de 2003, havia processadores ARM clássicos, incluindo ARM7 (Arquitetura ARMv4), ARM9 (Arquitetura ARMv5), ARM11 (Arquitetura ARMv6). ARM7 não tem MMU (unidade de gerenciamento de memória), não pode executar sistemas multiusuário e multiprocessos, como Linux e WinCE. Só pode executar sistemas como ucOS e ucLinux que não precisam de MMU. ARM9 e ARM11 são CPUs embutidas com MMU, que podem rodar Linux.

Depois de 2003, quando se tratava da arquitetura ARMv7, ela recebeu o nome de Cortex e foi dividida em três séries: Cortex-A, Cortex-R e Cortex-M.

  • Cortex-A — núcleos de processador de aplicativos para sistemas de alto desempenho
  • Córtex-R - núcleos de alto desempenho para aplicativos em tempo real
  • Córtex-M - núcleos de microcontroladores para uma ampla gama de aplicativos incorporados

Simplificando, Cortex-A As séries são adequadas para aplicativos que possuem altos requisitos de computação, executam sistemas operacionais sofisticados e fornecem mídia interativa e experiência gráfica. Córtex-R são adequados para que exigem confiabilidade, alta disponibilidade, tolerância a falhas, manutenibilidade e resposta em tempo real. Córtex-M series destinam-se a MCUs sensíveis ao custo e à energia e aplicações finais.

 

Cortex-A versus Cortex-R versus Cortex-M

Cortex-A

A categoria de processadores Cortex-A é dedicada a dispositivos Linux e Android. Quaisquer dispositivos – a partir de smartwatches e tablets e continuando com equipamentos de rede – podem ser suportados por processadores Cortex-A.

  • Processadores Cortex-A (A5, A7, A8, A9, A12, A15 e A17) é baseado na arquitetura ARMv7-A
  • O conjunto de recursos comuns para processadores A inclui um mecanismo de processamento de mídia (NEON), uma ferramenta para fins de segurança (Trustzone) e vários conjuntos de instruções compatíveis (ARM, Thumb, DSP etc.)
  • Os principais recursos dos processadores Cortex-A são desempenho superior e eficiência de energia brilhante, agrupados para fornecer aos usuários o melhor serviço possível

As principais características do processador Cortex-A:

Cortex-A5: O Cortex A5 é o membro menor e de menor potência da série Cortex A, mas ainda pode demonstrar desempenho multicore, é compatível com os processadores A9 e A15.

Cortex-A7: O consumo de energia do A7 é quase o mesmo do A5, mas o desempenho fornecido pelo A7 é 20% superior ao do A5, bem como compatibilidade arquitetônica total com Cortex-A15 e Cortex-A17. O Cortex-A7 é a escolha ideal para implementações de smartphones e tablets sensíveis ao custo.

Contrex-A15: O Cortex-A15 é o membro de maior desempenho desta série, oferecendo o dobro do desempenho do A9. O A15 encontra sua aplicação em dispositivos de última geração, servidores de baixo consumo de energia e infraestrutura sem fio. Este é o primeiro suporte de processador para soluções de gerenciamento de dados e ambiente virtual.

Contrex-A17: O Cortex-A17 demonstra um desempenho 60% superior ao do A9. O objetivo principal é satisfazer as necessidades dos dispositivos de classe premium.

Contrex-A50: Contrex-A50, série mais recente, é construído na arquitetura ARMv8 e traz suporte para Arch64-bit, um sistema com eficiência energética. Uma razão óbvia para a mudança para 64 bits é o suporte de mais de 4 GB de memória física, que já é alcançado no Cortex-A15 e Cortex-A7.

 

Córtex-R

Os processadores Cortex-R visam aplicações em tempo real de alto desempenho, como controladores de disco rígido, reprodutores de mídia de equipamentos de rede e outros dispositivos semelhantes.

Córtex-R4:  Cortex-R4 é adequado para aplicações automotivas. Ele pode ter clock de até 600 MHz, possui um pipeline de 8 estágios com emissão dupla, pré-busca e um sistema de interrupção de baixa latência, tornando-o ideal para sistemas críticos de segurança.

Córtex-R5: O Cortex-R5 estende os recursos oferecidos pelo R4 e adiciona maior eficiência, confiabilidade e melhora o gerenciamento de erros. A implementação dual-core torna possível construir sistemas muito poderosos e flexíveis com respostas em tempo real.

Córtex-R7: O Cortex-R7 aumenta significativamente o desempenho. Eles apresentam um pipeline de 11 estágios e permitem a execução fora de ordem e a previsão de ramificação de alto nível. As ferramentas podem ser implementadas para multiprocessamento de passo de bloqueio, simétrico e assimétrico. O controlador de interrupção genérico é outro recurso significativo que deve ser mencionado.

 

Córtex-M

Cortex-M projetado especificamente para atingir o mercado de MCU. A série Cortex-M é construída na arquitetura ARMv7-M (usada para Cortex-M3 e Cortex-M4), e a menor Cortex-M0+ é construída na arquitetura ARMv6-M. É seguro dizer que o Cortex-M se tornou para o mundo de 32 bits o que o 8051 é para o de 8 bits – um núcleo padrão da indústria fornecido por muitos fornecedores. A série Cortex-M pode ser implementada como soft core em um FPGA, por exemplo, mas é muito mais comum encontrá-las implementadas como MCU com memórias, clocks e periféricos integrados. Alguns são otimizados para eficiência energética, alguns para alto desempenho e alguns são adaptados a um segmento de mercado específico, como medição inteligente

Para aplicativos que são particularmente sensíveis ao custo ou estão migrando de 8 bits para 32 bits, o menor membro da série Cortex-M pode ser a melhor escolha.

Córtex-M0: O Cortex-M0+ usa o conjunto de instruções Thumb-2 e possui um pipeline de 2 estágios. Recursos significativos são o barramento para GPIO de ciclo único e o buffer de micro trace.

Cortex-M3 e M4:  O Cortex-M3 e o Cortex-M4 são núcleos muito semelhantes. Cada um oferece um pipeline de 3 estágios, vários barramentos de 32 bits, velocidades de clock de até 200 MHz e opções de depuração muito eficientes. A diferença significativa é a capacidade do núcleo Cortex-M4 para DSP. O Cortex-M3 e o Cortex-M4 compartilham a mesma arquitetura e conjunto de instruções (Thumb-2). Se sua aplicação requer matemática de ponto flutuante, você fará isso consideravelmente mais rápido em um Cortex-M4 do que em um Cortex-M3. Dito isso, para um aplicativo que não está usando os recursos DSP ou FPU do Cortex-M4, você verá o mesmo nível de desempenho e consumo de energia em um Cortex-M3. Em outras palavras, se você precisa da funcionalidade DSP, escolha um Cortex-M4. Caso contrário, o Cortex-M3 fará o trabalho.

 

Conclusão

Figura 2. Visão geral do Cortex

 

Os processadores ARM oferecem uma variedade de recursos para diferentes propósitos. Com um pouco de reflexão e investigação, você poderá encontrar o processador certo que atende às necessidades de sua aplicação. seja para um tablet de última geração ou um nó de sensor sem fio de custo ultrabaixo.

É um desafio fazer a escolha certa do núcleo Cortex e transformar a ideia em realidade. Mas uma equipe de profissionais experientes pode cuidar de todas as questões e implementar conceitos de qualquer complexidade.

A Orient Display se concentrou em tecnologias relacionadas ao processador ARM por muitos anos e acumulou uma rica experiência no desenvolvimento e implementação de produtos de arquitetura ARM. Ao mesmo tempo em que lança continuamente plataformas de desenvolvimento e placas principais que atendem às necessidades gerais do mercado, também atende às necessidades de projetos individuais dos clientes. Fornecer serviços personalizados.

Nossa equipe de hardware pode produzir protótipos no menor tempo possível de acordo com suas idéias e necessidades de design. Nossa equipe de software pode ajudá-lo a personalizar todas as funções da camada do driver de corte.

Para entrar em contato conosco: e ajudaremos a fazer seus planos desde a ideia inicial até o produto final.

08 Set
Painel de controle, Displays

Como usar monitores LCD gráficos com Raspberry Pi?

Como conectar o LCD gráfico ao Raspberry PI?

O artigo mostra como ligar um 128 × 64 display LCD gráfico para uma Raspberry Pi.

O LCD usado é 128 × 64 com controlador de LCD ST7565. Pode ser alimentado diretamente do trilho Raspberry Pi 3.3V. Requer 5 pinos GPIO para dados.

O esquema é, CS (Chip Select), RST (Reset) e A0 (Register Select) podem ser conectados a quaisquer 3 pinos GPIO. Neste exemplo, 8,24 e 25 são valores padrão. Valores diferentes podem ser especificados como parâmetros ao instanciar a classe ST7565 Python. SCLK (Serial Clock) no GLCD vai para GPIO 11 que é o clock serial do Pi. SID (Serial Input Data) no GLCD vai para GPIO 10 no Pi que é MOSI. GPIO 10 e 11 devem ser usados ​​para SID e SCLK. O Vdd está conectado a um pino de 3.3 V no PI e os aterramentos também estão conectados.

O LCD tem uma luz de fundo RGB. Os pinos do LED podem ir para os GPIO's 16,20 e 21. Para controlar a cor do Pi, especificando os pinos RGB ao instanciar a classe ST7565. Os resistores devem ser colocados em série para limitar a corrente e evitar a quebra do LED. O brilho do LED pode ser alterado usando diferentes valores de resistores. Será melhor ajustar a corrente para cerca de 20mA, claro, valores diferentes resultarão em uma mistura diferente de cores. É muito difícil misturar uma cor branca pura. Calcule o valor do resistor com cuidado, em 40mA, o brilho do LED diminuirá drasticamente com o tempo, com a corrente de perto de 60mA, o LED pode quebrar e ficar permanentemente danificado.

Como programar um LCD gráfico?

A tela é de 128 pixels na horizontal por 64 pixels na vertical. O LCD pode ser dividido em 8 páginas horizontais. Eles são numerados de 3 a 0 e de 7 a 4 de cima para baixo. Cada página inclui 128 colunas e 8 linhas de pixels. Para endereçar os pixels, especificando o número da página e da coluna, e enviar um byte para preencher 8 pixels verticais de uma só vez.

A tela tem SPI (Interface Periférica Serial) para se conectar ao Pi. O SPI requer 3 linhas MOSI, MISO e Clock. O Pi é o mestre e o GLCD é o escravo. Neste exemplo, apenas gravando no GLCD e não está pronto, portanto, a conexão com as linhas MOSI e Clock é necessária. MOSI é a saída do Pi para o GLCD e o Relógio sincroniza o tempo.

  1. Ativar SPI no Raspberry Pi primeiro
  2. No menu raspi-config, selecione Opções avançadas e, em seguida, SPI. Em seguida, selecione Sim para “Gostaria que a interface SPI fosse habilitada”. Clique em OK, reinicie. Selecione Sim para “o módulo do kernel SPI a ser carregado por padrão”. Reinicialize o Pi após habilitar o SPI. Em seguida, teste o SPI usando IsmodEle deve retornar SPI_bcm2708 ou spi_bcm2835 dependendo da versão Pi. A biblioteca python SPI requer python2.7 dev, que pode ser instalada com apt-get install:
  3. A Biblioteca Python SPI é chamado py-aranha. Ele pode ser instalado usando git: GLCD A biblioteca Python para o Pi pode ser baixada do site GitHub.
  4. A biblioteca ST7565 principal (st7565.py) lida com desenho, texto e bitmaps e um módulo de fonte (xglcd_font.py) para carregar fontes X-GLCD. Aqui estão os comandos básicos de desenho para criar pontos, linhas, retângulos, círculos, elipses e polígonos regulares: Para obter mais detalhes, consulte a referência abaixo ou entre em contato com nossos engenheiros.
03 Set
Painel de controle

Introdução a projetos baseados na placa STM32G071RB usando STM32CubeIDE

Introdução a projetos baseados na placa STM32G071RB usando STM32CubeIDE

Confira nosso Painel de controle!

Começar com um microcontrolador baseado em ARM de 32 bits é sempre um pouco assustador. Existem muitos microcontroladores, plataformas, placas de desenvolvimento, ferramentas e software disponíveis. Esta nota descreve passo a passo como iniciar um projeto de LED.

Introdução: sobre a placa de desenvolvimento STM32G071RB

Características:

  • Núcleo: CPU Cortex®-M32+ de 0 bits Arm®, frequência de até 64 MHz
  • Até 128 Kbytes de memória Flash, 36 Kbytes de SRAM
  • Controlador DMA de 7 canais com mapeamento flexível
  • ADC de 12 bits, 0.4 µs (até 16 canais externos)
  • Dois DACs de 12 bits, sample-and-hold de baixa potência
  • Dois I2C, quatro USARTs, um UART de baixa potência, dois SPIs

 

Primeiros passos: Instale STM32CubeIDE

Você pode baixar STM32CubeIDE de seu st.com. É grátis. Instale STM32CubeIDE a seguir Guia de instalação STM32CubeIDE.

 

Seu primeiro projeto: piscar LED

Antes de começarmos a escrever código, precisamos criar um projeto. Isso é semelhante à maioria dos outros IDEs - os projetos são usados ​​para agrupar todas as suas configurações, código e definições em uma única coleção, todos gerenciados a partir do mesmo aplicativo.

 

 

PASSO 1: Inicie um novo projeto, no ícone superior esquerdo (ou no menu Arquivo> Novo> Projeto STM32) para começar.

 

Etapa 2: Nome do projeto: G0_LED e clique no botão Concluir.

Do diagrama esquemático que o LED4 é controlado pelo STM32G071 e a porta é PA5.

Etapa 3: Em System Core> SYS, selecione Serial Wire, configure PA5 como GPIO_OUTPUT.

Configure o rótulo de uso para PA5 como LED_GREEN conforme abaixo:

 

Passo 4: Em seguida, gere o código.

 

CubeIDE, sobre o qual essa funcionalidade é desenvolvida, gera arquivos C para trabalhar em um diretório Src e coloca um HAL (Hardware Abstraction Layer) em um diretório Includes. Parece que o CubeIDE funciona exatamente da mesma maneira. Expanda as pastas à direita sob a visualização do projeto e veja o que ele gerou para funcionar para você.

 

 

Etapa 5: Vamos adicionar um pouco do nosso próprio código C agora! Após a área do Infinite Loop, vamos adicionar o código para alternar o LED na seção 3 conforme abaixo:

 

 

Compilando o projeto e baixando-o para o quadro

STM32CubeIDE realmente torna muito fácil compilar nosso trabalho e colocá-lo no chip STM32. O primeiro passo é produzir o .elf compilado (uma versão binária do nosso código). Para gerar o .elf, precisamos fazer um build. Isso é tão fácil quanto pressionar o botão de construção na barra de ferramentas.

Agora, as informações de compilação são apresentadas no console na parte inferior da tela.

Agora o que queremos fazer é enviar este binário compilado para o microcontrolador STM32.

Vamos conectar o kit de desenvolvimento:

O LED de energia vermelho (à esquerda do interruptor azul) está aceso, assim como o LED de comunicação maior (pelo cabo USB). Dentro do STM32CubeIDE, selecione o botão de execução.

Isso abrirá a caixa de diálogo Executar (já que é a primeira vez que a executamos). As configurações que escolhemos agora serão salvas como uma configuração de execução que podemos reutilizar ou editar mais tarde.

Basta pressionar Aplicar e, em seguida, OK e o download continuará. O console agora será preenchido com algum texto interessante:

O LED acende e apaga a cada 500 ms. você tem tudo configurado.

23 Jul
Painel de controle

STM32 versus Arduino

STM32 versus Arduino

Confira nosso Painel de controle!

 

Arduino

O Arduino é mais criativo, enfraquece o funcionamento de hardware específico, suas funções e sintaxe são muito simples, e é muito “burro”.

A maior parte do controle principal do Arduino é o microcontrolador AVR. A vantagem do Arduino é que ele possui alto encapsulamento de código e menos sentenças, o que reduz a dificuldade de desenvolvimento de software.

O Arduino é relativamente fácil de começar, desde que você entenda um pouco de hardware e C++, você pode desenvolver.

A maioria das funções do Arduino possui bibliotecas bem construídas, por isso é muito simples de usar, mas a controlabilidade de funções um pouco mais complicadas é ruim. 

 

STM32

O STM32 presta mais atenção à prática de engenharia. Na verdade, existem muitos instrumentos simples na fábrica, como controladores de temperatura, controladores de motores comuns, PLCs de baixo custo e alguns brinquedos civis, controladores de jogos, teclados e mouses com fio e outros periféricos e assim por diante são muito práticos.

O STM32 é usado principalmente como produtos para desenvolvedores profissionais, o que requer certo conhecimento profissional, mas, ao mesmo tempo, é relativamente complicado escrever código para realizar funções. Por exemplo, a porta serial gera uma string simples. Para Arduino, pode começar a partir de um novo projeto e pode ser realizado com 10 linhas de código. No entanto, se você usar ferramentas de desenvolvimento STM32, como Keil, pode exigir centenas de linhas de código ou mais.

Em termos de código aberto: coisas feitas com STM32 podem ser de código aberto se você quiser código aberto, e você não pode publicar nada se não quiser código aberto.

 

Conclusão

 

Aqui estão algumas sugestões para a escolha:

Se você é um estudante comum abaixo do nível universitário que não possui uma compreensão profunda das linguagens de programação, é recomendável começar com o Arduino. Se as habilidades C forem fracas e chegarem ao STM32, você logo terá a ideia de desistir.

Se você estuda apenas para o emprego, decididamente o microcontrolador STM32.

Se você está aprendendo apenas por diversão e não é especialista em eletrônica e não tem confiança, o Arduino é recomendado.

Se você tiver boas habilidades de programação, o STM32 é recomendado. Depois de fazer isso, você pode dar uma olhada nas coisas feitas pela comunidade de código aberto do Arduino e pode fazê-lo facilmente com o STM32.

Claro, se você tiver habilidade, poderá fazer contato com ambos. Geralmente, você pode dominar os recursos básicos do Arduino em menos de uma semana. Se você precisar no futuro, poderá transplantar livremente o código do Arduino para plataformas MCU, como STM32.

Na verdade, os dois são realmente voltados para direções ligeiramente diferentes. O Arduino é a escolha dos amadores de eletrônica geral e DIY, enquanto o STM32 é frequentemente usado para o desenvolvimento e fabricação de produtos reais.