U-BLOX NINA B40 (OpenCPU) (PROGRAMADO COM MAKECODE) (código compatível com Micro:Bit)
ESCREVENDO EM UMA MATRIZ DE LEDS
BLOG BETA
APRESENTE OUTROS EXEMPLOS QUE POSSAMOS PUBLICAR
BLOG BETA
O objetivo deste BLOG é mostrar como é possível programar o U-BLOX NINA B40 com o MakeCode, habilitando a opção Micro:Bit.
O Microsoft MakeCode, ou Microsoft Block Editor, é um editor de programas 'Low-Code' exclusivo para micro:bit destinado a pessoas mais jovens.
É executado em navegadores da Web. Os usuários podem fazer programas empilhando 'Blocos' em vez de escrever códigos. Os códigos de bloco são traduzidos para códigos JavaScript internamente e incorporados a arquivos HEX.
Na programação você pode alternar para JavaScript ou MicroPython.
Veja o datasheet do u-blox NINA B40:
Pode se adquirido neste Link
Mecanicamente compatível com BREAKOUT
Esquema elétrico Micro:Bit V2
GPIOS do NINA B40 e sua relação com Micro:Bit
Utilizando o U-BLOX NINA B40 com o MakeCode
Diferente do NINA B112, o B40 tem uma USB a qual permite que você possa criar um MSD e copiar os programas, graças ao bootloader do time da Adafruit.
Os módulos da série NINA-B40 incluem uma interface de dispositivo Universal Serial Bus (USB) de velocidade máxima, que é compatível com a versão 2.0 da especificação USB.
As características da interface USB incluem:
• Dispositivo de velocidade total, até 12 Mbit/s velocidade de transferência
• MAC e PHY implementados no hardware
• Configuração do pino:
o VBUS, entrada de fornecimento de 5 V, necessária para usar a interface
o USB_DP, USB_DM, par de dados diferenciados
Ao gravar do Bootloader, você terá uma MSD para transferir o programa .uF2 gerado pelo MakeCode.
Você pode pegá-lo aqui:
bluemicro_nrf52833_bootloader-0.6.4_s140_7.2.0.hex
MakeCode
O MakeCode é um projeto da Microsoft para facilitar o uso de programação na Educação. Toda a programação pode ser vista instantaneamente, o que facilita muito o desenvolvimento da mesma. Segundo a Microsof t, pelo próprio site do MakeCode: “O objetivo principal do MakeCode é apresentar a programação de uma forma que seja acessível e convidativa".
Como transferir o programa do MakeCode para o seu U-BLOX NINA B40 ?
Clicando rapidamente o pino de RESET do Breakout, aparecerá o MSD para a transferência do Programa gerado pelo MakeCode :)
Gravando o Bootloader da Adadruit para o U-BLOX NINA B40
Foi soldado o U-BLOX NINA B40 conforme figura abaixo, utilizando o BREAKOUT basicamente são:
- 2 capacitores de 100nF (desacoplamento);
- 1 resistor de 100nF e 10K para o reset;
- uma chave de Reset;
- um resistor de 330R e um LED para sinalizar que o U-BLOX NINA B40 esta alimentado (3.3V);
- 2 resistores de 33R para USB (device).
O esquema elétrico é este
Algumas características do Kit
-Botão de RESET (2 clicks faz o MSD abrir);
-Botão de Bootloader (W102/W106); (não utilizado)
-Step de 2.54mm;
-Acesso às várias GPIOS;
-72mmX21mm.
Como gravar o Bootloader
Utilize o gravador SEGGER JLINK o módulo U-BLOX NINA B40, conecte nos pinos do SWCLK (pino 7) e SWDIO (pino 9) do SEGGER JLINK nos pinos SWDCLK e SWDIO do Breakout (pinos nas laterais, próximo à antena). Não esquecer de ligar os GND do Breakout no GND do SEGGER JTAG, bem como alimentar o Breakout com 3.3V.
Utilize o gravador SEGGER JLINK o módulo U-BLOX NINA B40, conecte nos pinos do SWCLK (pino 7) e SWDIO (pino 9) do SEGGER JLINK nos pinos SWDCLK e SWDIO do Breakout (pinos nas laterais, próximo à antena). Não esquecer de ligar os GND do Breakout no GND do SEGGER JTAG, bem como alimentar o Breakout com 3.3V.
Ligue os pinos SWD DIO e CLK ...
...nestes pinos da placa BREAKOUT, também ligue USB_DP e USB_DM via resistores de 33R em série na USB do PC, bem como no pino VBUS e GROUND.
Você pode também usar o ST-LINK V2 com Openocd
Este é o Bootloader: bluemicro_nrf52833_bootloader-0.6.4_s140_7.2.0.hex
Uma vez gravado, conecte na USB do seu PC o U-BLOX NINA B40, você verá uma MSD para transferência do programa HEX criado pelo MakeCode.
Matriz de LEDS
Módulo pronto para você usar em seu projeto, seja como letreiro luminoso ou para você experimentar.
Com a ajuda de um max7219 você poderá controlar uma matriz 8X8.
Além disso, este módulo pode ser conectado com outros iguais em cascata com muita facilidade e você não notará a divisão entre um módulo e outro.
Entre suas principais características temos:
Matriz led de 32mm com 8 linhas por 8 colunas.
Velocidade de comando até 10 MHz.
Controle através do I.C. MAX7219 que pode ser facilmente colocado em série.
Comunicação serial que ajuda você a economizar pinos.
A intensidade da tela pode ser controlada por software.
Cada unidade gerencia uma matriz de cátodos comuns 8×8.
MakeCode, criando Projetos
Em New Project, escolha Micro:Bit
Click então Download as File
Será gerado um programa com sufixo HEX, o mesmo deve ser editado (até fazermos um SCRIPT para isto) para que possa então ser convertido para UF2 e então ser gravado no U-BLOX NINA B40.
adafruit/Adafruit_nRF52_Bootloader: USB-enabled bootloaders for the nRF52 BLE SoC chips (github.com)
Foi realizado o Download da pasta acima com com o Software Git com opção Clone, dentro do WSL2 (ambiente Linux dentro do Windows)
Leia com atenção, principalmente o item 13.4 (Programming the Board) sobre que deve-se fazer com o HEX gerado pelo Makecode.
- deve-se remover (a remoção do Código Fonte embarcado) a segunda linha do HEX gerado (o makecode gera um único HEX com código da versão V1 e V2, por isto devem ser isolados)
- procure pela segunda ocorrência de :020000040000FA
- A partir desta linha (incluindo a que tem o :020000040000FA), remova até encontrar a sequência 00000001FF (não removendo a mesma).
- Finalmente remova as linhas no final que começam com :04
:0410140000C0030015
:0400000C42424242E8
Ficará assim
:020000040000FA
:20000000C0070000D1060000D1000000B106000000000000000000000000000000000000BA
:20002000000000000000000000000000510700000000000000000000DB000000E5000000A8
:20004000EF000000F9000000030100000D01000017010000210100002B010000350100000A
:200060003F01000049010000530100005D01000067010000710100007B0100008501000068
.
.
.
:20F7A000000000000000000000000000000000000000000000000000000000000000FFFF4B
:20F7C0000000000032000000000000000000000000000000000000000000000000000000F7
:20F7E000000000000000000000000000000000000000000000000000000000000000000009
:20F80000000000000024F400000000000000000000000000000000000000000000000000D0
:20F820000000000000000000000000000000000000000000000000000000000000000000C8
:20F840000000000000000000000000000000000000000000000000000000000000000000A8
:14F86000000000000000000000000000000000000000000094
:20FC00000100000000000000FE0000000000000000000000000000000000000000000000E5
:020000041000EA
:00000001FF
A boa notícia é que foi criado um Script em Python para automatizar os passos acima.
Script (tem que ser melhorado)
import os, fnmatch
lines = []
#Find the first occurrence of microbit*.hex
#microbit puts the hex on c:\user\usuario\downloads
fileOfDirectory = os.listdir('C:\\Users\\Usuario\\Downloads')
pattern = "microbit*.hex"
for filename in fileOfDirectory:
if fnmatch.fnmatch(filename, pattern):
HexFile = filename
print(HexFile)
break
# read file
with open(HexFile, 'r') as fp:
# read an store all lines into list
lines = fp.readlines()
fp.close
# Write file
with open(r"converted.hex", 'w') as fp:
# iterate each line
for number, line in enumerate(lines):
# note list index starts from 0
# delete second line
if number not in [1]:
fp.write(line)
fp.close
#repeat process to find :0410 text
os.remove(HexFile)
os.rename("converted.hex", HexFile)
word = ':0410'
# read file
with open(HexFile, 'r') as fp:
# read an store all lines into list
lines = fp.readlines()
fp.close
# Write file
with open(r"converted.hex", 'w') as fp:
# iterate each line
for number,line in enumerate(lines):
# note list index starts from 0
# write lines until reach :0410
if line.find(word) != -1:
break
else:
fp.write(line)
fp.close
#repeat process to add :00000001FF at end of file
os.remove(HexFile)
os.rename("converted.hex", HexFile)
word = ':00000001FF'
# read file
with open(HexFile, 'a') as fp:
fp.write(word + "\n")
fp.close
# Rename to use with uf2conv script
os.rename(HexFile,"firmware.hex")
print("Converting to UF2")
os.system("C:\\Users\\Usuario\\AppData\\Local\\Programs\\Python\\Python38-32\\python.exe uf2conv.py firmware.hex -c -f 0x621E937A")
#E: could be other for you!
os.system("copy flash.uf2 E:\\")
os.remove("firmware.hex")
Para utilizar o Script acima:
- Instale Python em sua máquina
- Copie uf2conv.py que se encontra em /home/ubuntu/Adafruit_nRF52_Bootloader/lib/uf2/utils para a pasta c:\\user\usuario\downloads
- crie uma arquivo convert.py em c:\user\usuario\downloads e cole o script acima
- crie uma arquivo convert.bat em c:\user\usuario\downloads e cole o script abaixo:
- Copie o SCRIPT em python
@echo off
"C:\Users\Usuario\AppData\Local\Programs\Python\Python38-32\python.exe" "C:\Users\Usuario\Downloads\convert.py"
pause
- crie um arquivo qualquer com sufixo .HEX na pasta c:\user\usuario\downloads
- com o botão da direita, sobre este arquivo .HEX, escolha a opção "Abrir com", "Escolher outro aplicativo", "Marcar Habilitar sempre este aplicativo para "executar", aponte ao arquivo convert.bat, desta forma, ao clicar no HEX, o mesmo será transferido para o U-BLOX NINA B40 (via MSD)
Após pressionar rapidamente o botão de Reseta do U-BLOX NINA B40 duas vezes (intervalo curto), você pode fazer o Drag e Drop para o MSD, apenas clicando no HEX gerado pelo Makecode.
os.system("copy flash.uf2 E:\\")
Mas como funciona o "programa" do projeto ?
- HÁ UM SETUP PARA CONFIGURAR UART PARA 115200, PINOS DA MATRIZ DE LEDS E ENTÃO ZERAR UM CONTADOR
- HÁ UM LOOP INFINITO
- DENTRO DO LOOP INFINITO:
- É MANDADO UM "Hello from B40 - Microbit" pela UART
- É FORCADO P2,P5 PARA ALTO
- UMA PAUSA É REALIZADA
- É FORCADO P2, P5 PARA BAIXO
- UMA PAUSA É REALIZADA:
- NUM TOTAL DE 10x
- NOVA PAUSE GERADA
- O VALOR DO CONTADOR É TRANFORMADO EM TEXTO E ENTÃO ENVIADO PARA A MATRIZ DE LEDS
- VALOR DO CONTADOR É INCREMENTADO
- VOLTA A REPETIR (LOOP INFINITO)
Baseado na especificação abaixo, identifica-se quais GPIOS do NRF52, P0.01, P0.17 correspondem à P2,P5 do Micro:Bit, no caso do U-blox NINA B40 correspondem aos GPIOS (módulo/breakout) IO3, IO5.
Na Matrix de LEDS são utilizados os pinos P13 (SCK), P15 (MOSI) e P16 (CS), que correspondem no U-BLOX NINA B40: IO21, IO44 e IO4.
Para UART, foram utilizados P0 (TxD) e P1 (RxD)
P0 (Micro:Bit) = P0.03 (NRF52) = IO16 (u-blox NINA B40)
P1 (Micro:Bit) = P0.02 (NRF52) = IO18 (u-blox NINA B40)
O exemplo acima faz LEDS piscarem 10 vezes por segundo (100ms), também envia um texto pela UART
Simule antes
Extensões do Makecode
Downloads
Questões: suporte@smartcore.com.br
FONTES:
adafruit/Adafruit_nRF52_Bootloader: USB-enabled bootloaders for the nRF52 BLE SoC chips (github.com)
Sobre a SMARTCORE
A SmartCore fornece módulos para comunicação wireless, biometria, conectividade, rastreamento e automação.
Nosso portfólio inclui modem 2G/3G/4G/NB-IoT/Cat.M, satelital, módulos WiFi, Bluetooth, GNSS / GPS, Sigfox, LoRa, leitor de cartão, leitor QR code, mecanismo de impressão, mini-board PC, antena, pigtail, LCD, bateria, repetidor GPS e sensores.
Mais detalhes em www.smartcore.com.br
