Bare Metal Raspberry Pi 3: LED piscando: 8 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Por moldypizzaFollow Mais do autor:

Sobre: .oO0Oo. Mais sobre moldypizza »

Bem-vindo ao tutorial do LED BARE METAL pi 3 piscando!

Neste tutorial, seguiremos as etapas, do início ao fim, para obter um LED piscando usando um Raspberry PI 3, uma placa de ensaio, um resistor, um led e um cartão SD em branco.

Então, o que é BARE METAL? BARE METAL é uma programação sem frescuras. O metal puro significa que temos controle total sobre o que o computador fará na hora. Portanto, basicamente significa que o código será completamente escrito em assembly, usando o conjunto de instruções Arm. No final, teremos criado um programa que piscará um LED acessando o endereço físico de um dos pinos GPIO do Raspberry Pi e configurando-o para saída e, em seguida, ligando e desligando-o. Tentar este projeto é uma ótima maneira de começar com a programação embarcada e, com sorte, fornecer uma melhor compreensão de como um computador funciona.

O que você precisa?

Hardware

• Framboesa PI 3
• Cartão SD pré-carregado com uma imagem inicializável
• Tábua de pão
• Fios de jumper masculino feminino
• Fios de jumper machos
• CONDUZIU
• Resistor de 220 ohms (não precisa ser exatamente 220 ohms, quase qualquer resistor funcionará)
• mini cartão SD
• mini cartão SD pré-carregado com o sistema operacional raspberry pi (geralmente incluído com o pi)

Programas

• Compilador GCC
• GNU embarcado conjunto de ferramentas
• editor de texto
• formatador de cartão sd

Tudo bem, vamos COMEÇAR!

Etapa 1: CONFIGURANDO AS COISAS / COISAS

Ok, então … o primeiro passo é adquirir o hardware. Você pode comprar as peças separadamente ou existe um kit que vem com peças mais do que suficientes. LIGAÇÃO

Este kit vem com tudo o necessário para configurar o framboesa pi 3 e muito mais! a única coisa que não está incluída neste kit é um cartão mini SD extra. Esperar! Não compre outro ainda. Se você não planeja usar a instalação do Linux pré-carregada no cartão, apenas copie o conteúdo do mini cartão SD incluso para mais tarde e reformate o cartão (mais sobre isso mais tarde). NOTA IMPORTANTE: certifique-se de manter os arquivos no cartão incluso, pois serão NECESSÁRIOS para mais tarde!

Em seguida, é hora de configurar o software. Este tutorial não inclui instruções detalhadas sobre como instalar o software. Existem muitos recursos e tutoriais online sobre como instalá-los:

USUÁRIOS DO WINDOWS:

Baixe e instale o gcc

Em seguida, baixe e instale o conjunto de ferramentas embutido GNU ARM

LINUX / MAC

• Distribuições Linux vêm com gcc pré-instalado
• Baixe e instale o conjunto de ferramentas embutido GNU ARM.

Ok, se tudo correr bem, você deve conseguir abrir o terminal (linux / mac) ou a linha cmd (windows) e tentar digitar

arm-none-eabi-gcc

A saída deve ser semelhante à primeira imagem. Isso é apenas para verificar se ele está instalado corretamente.

Tudo bem, agora que os pré-requisitos estão fora do caminho, é hora de começar com a parte divertida.

Etapa 2: CIRCUITO

Hora do circuito! O circuito para isso é simples. Vamos conectar um led ao GPIO 21 (pino 40) no pi (veja as figuras 2 e 3). Um resistor também é conectado em série para evitar que o led seja danificado. O resistor será conectado à coluna negativa na placa de ensaio que será conectada ao GND (pino 39) no pi. Ao conectar o led certifique-se de conectar a extremidade curta ao lado negativo. Veja a ultima foto

Etapa 3: Mini SD INICIALIZÁVEL

Existem três etapas para fazer com que o seu pi 3 reconheça o seu mini cartão SD em branco. Precisamos localizar e copiar bootcode.bin, start.elf e fixup.dat. Você pode obter esses arquivos no mini cartão SD incluído se você comprou o canakit ou fazer um cartão SD inicializável para o pi 3 com uma distribuição Linux. De qualquer forma, esses arquivos são necessários para permitir que o pi reconheça o cartão SD como um dispositivo inicializável. Em seguida, formate o mini sd para fat32 (a maioria dos cartões mini SD vêm formatados em fat32. Usei um mini cartão SD barato da sandisk), mova bootcode.bin, start.elf, fixup.dat para o cartão SD. E você está feito! Ok mais uma vez e na ordem das fotos os passos são:

1. Encontre bootcode.bin, start.elf, fixup.dat.
2. Certifique-se de que seu cartão SD está formatado para fat32.
3. Mova bootcode.bin, start.elf e fixup.dat para o cartão SD formatado.

Veja como eu descobri isso, link.

Etapa 4: VERIFICAR Mini SD

Tudo bem, temos um mini cartão SD inicializável e, com sorte, você tem um pi 3 neste momento. Portanto, agora devemos testá-lo para ter certeza de que o pi 3 está reconhecendo o cartão mini SD como inicializável.

No pi, perto da porta mini usb, há dois pequenos leds. Um é vermelho. Este é o indicador de energia. Quando o pi está recebendo energia, esta luz deve estar acesa. Portanto, se você conectar seu pi agora, sem cartão mini SD, ele deve acender em vermelho. Ok, agora desconecte seu pi e coloque seu mini cartão SD inicializável que foi criado na etapa anterior e conecte o pi. Você vê outra luz? Deve haver uma luz verde, ao lado da vermelha, que indica que ele está lendo o cartão SD. Este led é denominado led ACT. Ele acenderá quando houver um cartão SD viável inserido. Ele piscará quando estiver acessando seu cartão mini SD.

Ok, então duas coisas deveriam ter acontecido depois que você inseriu o mini cartão SD inicializável e conectou o pi:

1. O led vermelho deve estar aceso indicando recepção de energia
2. O led verde deve estar aceso indicando que foi inicializado no cartão mini SD

Se algo deu errado, tente repetir as etapas anteriores ou clique no link abaixo para obter mais informações.

O link aqui é uma boa referência.

Etapa 5: CODE1

Este projeto foi escrito em linguagem assembly ARM. Um entendimento básico da montagem ARM é assumido neste tutorial, mas aqui estão algumas coisas que você deve saber:

.equ: atribui um valor a um símbolo, ou seja, abc.equ 5 abc agora representa cinco

• ldr: carrega da memória
• str: escreve na memória
• cmp: compara dois valores realizando uma subtração. Define sinalizadores.
• b: ramificar para etiqueta
• add: executa aritmética

Se você não tem experiência com montagem de braço, assista a este vídeo. Isso lhe dará uma boa compreensão da linguagem assembly do Arm.

Ok, agora temos um circuito que está conectado ao nosso raspberry pi 3 e temos um cartão SD que o pi reconhece, então nossa próxima tarefa é descobrir como interagir com o circuito carregando o pi com um programa executável. Em geral, o que precisamos fazer é dizer ao pi para gerar uma tensão de GPIO 21 (pino conectado ao fio vermelho). Em seguida, precisamos de uma maneira de alternar o led para fazê-lo piscar. Para fazer isso, precisamos de mais informações. Neste ponto, não temos ideia de como dizer ao GPIO 21 para produzir e é por isso que devemos ler a ficha técnica. A maioria dos microcontroladores possui planilhas de dados que especificam exatamente como tudo funciona. Infelizmente, o pi 3 não possui documentação oficial! No entanto, existe uma folha de dados não oficial. Aqui estão dois links para ele:

1. github.com/raspberrypi/documentation/files…
2. web.stanford.edu/class/cs140e/docs/BCM2837…

Ok, neste ponto, você deve levar alguns minutos antes de passar para a próxima etapa para olhar a planilha de dados e ver quais informações você pode encontrar.

Etapa 6: CODE2: Turn_Led_ON

O raspberry pi 3 53 registra para controlar os pinos de saída / entrada (periféricos). Os pinos são agrupados e cada grupo é atribuído a um registro. Para GPIO, precisamos ser capazes de acessar os registradores SELECT, SET e CLEAR. Para acessar esses registros, precisamos dos endereços físicos desses registros. Quando você está lendo a folha de dados, você deseja apenas anotar o deslocamento do endereço (lo byte) e adicioná-lo ao endereço base. Você tem que fazer isso porque a folha de dados está listando os endereços virtuais do Linux, que são basicamente valores atribuídos pelos sistemas operacionais. Não estamos usando um sistema operacional, portanto, precisamos acessar esses registros diretamente usando o endereço físico. Para isso, você precisa das seguintes informações:

• Endereço básico de periféricos: 0x3f200000. O pdf (página 6) diz que o endereço base é 0x3f000000, no entanto, este endereço não funcionará. Use 0x3f200000
• O deslocamento de FSEL2 (SELECT) não é o endereço completo do registro. O pdf lista FSEL2 em 0x7E20008, mas este endereço se refere ao endereço virtual do Linux. O deslocamento será o mesmo, é isso que queremos observar. 0x08
• Offset de GPSET0 (SET): 0x1c
• Deslocamento de GPCLR0 (CLEAR): 0x28

Você provavelmente notou que a planilha de dados lista 4 registradores SELECT, 2 registradores SET e 2 registradores CLEAR, então por que escolhi os que escolhi? Isso ocorre porque queremos usar os controles GPIO 21 e FSEL2 GPIO 20-29, SET0 e CLR0 controles GPIO 0-31. Os registradores FSEL atribuem três bits para cada pino GPIO. Como estamos usando FSEL2, isso significa que os bits 0-2 controlam o GPIO 20 e os bits 3-5 controlam o GPIO 21 e assim por diante. Os registradores Set e CLR atribuem um único bit a cada pino. Por exemplo, o bit 0 em SET0 e CLR0 controla GPIO 1. Para controlar GPIO 21, você deve definir o bit 21 em SET0 e CLR0.

Ok, então falamos sobre como acessar esses registros, mas o que significa tudo isso?

• O registro FSEL2 será usado para definir o GPIO 21 para a saída. Para definir um pino para a saída, você precisa definir o bit de ordem inferior dos três bits como 1. Portanto, se os bits 3-5 controlam o GPIO 21, isso significa que precisamos definir o primeiro bit, o bit 3 como 1. Isso dirá ao pi que queremos usar GPIO 21 como uma saída. Portanto, se formos olhar para os 3 bits do GPIO 21, eles devem se parecer com isso depois de configurá-lo para a saída, b001.
• GPSET0 diz ao pi para ligar o pino (saída de uma voltagem). Para fazer isso, basta alternar o bit que corresponde ao pino GPIO que queremos. No nosso caso, o bit 21.
• GPCLR0 diz ao pi para desligar o pino (sem tensão). Para desligar o pino, defina o bit para o pino GPIO correspondente. No nosso caso, o bit 21

Antes de chegarmos a um led piscando, primeiro vamos fazer um programa simples que irá simplesmente ligar o led.

Para começar, precisamos adicionar duas diretivas ao início do nosso código-fonte.

• .section.init diz ao pi onde colocar o código
• .global _start

Em seguida, precisamos fazer o layout de todos os endereços que usaremos. Use.equ para atribuir símbolos legíveis aos valores.

• .equ GPFSEL2, 0x08
• .equ GPSET0, 0x1c
• .equ GPCLR0, 0x28
• .equ BASE, 0x3f200000

Agora vamos criar máscaras para definir os bits que precisamos definir.

• .equ SET_BIT3, 0x08 Isso definirá o bit três 0000_1000
• .equ SET_BIT21, 0x200000

Então, precisamos adicionar nosso rótulo _start

_começar:

Carregar endereço de base no registro

ldr r0, = BASE

Agora precisamos definir bit3 de GPFSEL2

• ldr r1, SET_BIT3
• str r1, [r0, # GPFSEL2] Esta instrução diz para escrever de volta o bit 0x08 para o endereço de GPFSEL2

Finalmente, precisamos ativar o GPIO 21 definindo o bit 21 no registro GPSET0

• ldr r1, = SET_BIT21
• str r1, [r0, # GPSET0]

O produto final deve ser semelhante ao código mostrado.

A próxima etapa é compilar o código e criar um arquivo.img que o pi possa executar.

• Baixe o makefile em anexo e kernel.ld e se você quiser o código-fonte turn_led_on.s.
• Coloque todos os arquivos na mesma pasta.
• Se você estiver usando seu próprio código-fonte, edite o makefile e substitua code = turn_led_on.s por code =.s
• Salve o makefile.
• Use o terminal (linux) ou janela cmd (windows) para navegar até a pasta que contém os arquivos e digite make e pressione Enter
• O arquivo make deve gerar um arquivo chamado kernel.img
• Copie kernel.img em seu mini cartão SD. O conteúdo de seus cartões deve ser como mostrado (foto 3): bootcode.bin, start.elf, fixup.dat e kernel.img.
• Ejete o cartão mini SD e insira-o no pi
• Conecte o pi na fonte de alimentação
• O LED deve acender !!!

NOTA LEVEMENTE IMPORTANTE: Aparentemente o instructables teve um problema com o makefile não tendo uma extensão, então eu o reenviei com uma extensão.txt. Remova a extensão ao baixá-la para que funcione corretamente.