Select a target to build: 1. milkv-duo-musl-riscv64-sd 2. milkv-duo256m-glibc-arm64-sd 3. milkv-duo256m-musl-riscv64-sd 4. milkv-duos-glibc-arm64-emmc 5. milkv-duos-glibc-arm64-sd 6. milkv-duos-musl-riscv64-emmc 7. milkv-duos-musl-riscv64-sd Which would you like:
O Duo USB&Ethernet IOB expande o Milk-V Duo com 4 portas USB, 1 porta de rede RJ45, 1 pinagem de porta serial e 1 conector de entrada de energia Tipo C.
Esta placa de expansão pode melhorar a eficiência de desenvolvimento do Duo e facilitar o acesso dos desenvolvedores a periféricos USB e Ethernet comumente usados.
Observe que ao usar o IO-Board, a rede USB (USB-NCM) não estará disponível. Use a interface Ethernet no IO-Board.
Se você precisar atribuir um endereço MAC fixo à porta Ethernet da placa de E/S, execute o seguinte comando ( substitua o endereço MAC no comando pelo endereço MAC que deseja definir e observe que os endereços MAC de diferentes dispositivos dentro do mesmo segmento de rede não devem ser duplicados ):
Por exemplo, se uma unidade flash USB estiver conectada à porta USB na placa de E/S, você pode usar o comando ls /dev/sd* para verificar se o dispositivo foi detectado.
Para montar a unidade USB e visualizar seu conteúdo no sistema (tomando /dev/sda1 como exemplo):
Antes
Insira Pendrive
mkdir /mnt/udisk mount /dev/sda1 /mnt/udisk
Verifique se o conteúdo do diretório/mnt/udisk corresponde às expectativas:
ls /mnt/udisk
O comando para desmontar uma unidade flash USB:
umount /mnt/udisk
Para restaurar a funcionalidade da rede USB (USB-NCM) quando não estiver usando o IO-Board, você pode seguir estas etapas:
A CPU da série Duo adota um design de núcleo grande e um núcleo pequeno. O firmware do VISUINO é executado no núcleo pequeno, enquanto o núcleo grande é responsável pela comunicação com o IDE do VISUINO. Ele recebe o firmware do Visuino e o carrega no pequeno núcleo para execução. Ao mesmo tempo, o sistema Linux no grande núcleo também funciona normalmente.
O Visuino é o mais recente software inovador da Mitov Software. Um ambiente de programação visual que permite programar suas placas Arduino.
Os componentes encontrados no software Visuino representam seus componentes de hardware e você poderá criar e projetar facilmente seus programas usando arrastar e soltar. Nenhum equipamento ou hardware é necessário para executar o software no modo de design. Depois de ter concluído o design, você pode conectar o upload da placa Arduino e executá-lo.
Para aquelas pessoas que não são sólidos em escrever código, em seguida, projetar, compilar e criar programas Arduino nunca foi tão fácil! Por que perder tempo criando código quando já se faz todo o trabalho duro para você? Você tem sua placa Arduino e um ótimo design de hardware, veja-a rodando em minutos, não em horas!
Thingspeak é uma plataforma de análise IoT (Internet of Things) que permite agregar, visualizar e analisar streams de dados, de uma forma muito simples. Uma das grandes vantagens da plataforma Thingspeak é que nos permite visualizar os dados enviados pelos nossos dispositivos, em tempo real, mas também a possibilidade de analisar os mesmo recorrendo ao poderoso Matlab.
Pretende-se neste exemplo, com ajuda do Núcleo com S.O, enviar o valor lido da entrada A/D (pino 31) do Duo 256 para o ThingSpeak a cada 15 segundos.
O dado lido será multiplicado por 100, visto que o Visuino retorna uma valor no intervalor de 0.0 à 1.0
1. Bootloader
Atualmente, precisa gravar firmware compatívelo sistema de cartão SD do Duo com bootloader do Arduino. Faça download do firmware com o prefixo arduino da versão mais recente do firmware.
Use um cabo USB para conectar o Duo ao computador e o Duo ligará automaticamente.
O firmware padrão do Duo, o sistema Linux de núcleo grande, controlará o piscar do LED integrado. Isto é conseguido através do script de inicialização. Agora vamos usar o Arduino de núcleo pequeno para acender o LED. Precisamos desabilitar o script de LED piscando no Linux de núcleo grande. No terminal Execute in do Duo:
No site oficial do milkV DUO há um exemplo escrito em C para comunicar o núcleo principal do DUO com o núcleo secundário onde um aplicativo VISUINO é executado. Aqui estão as notas desse primeiro contato que tive com a comunicação entre os núcleos através do módulo mailbox do DUO, o aplicativo fornecido é suficiente para entender e escrever seus próprios programas para enviar dados ou comandos do núcleo principal para o núcleo secundário. Mas surgem as seguintes perguntas: como faço para enviar dados do processador secundário para o processador principal? E se, em vez de usar C no processador principal, eu quiser usar Python? Você não encontrará respostas para essas perguntas no site oficial do fabricante ou perguntando diretamente no fórum DUO, pelo menos a partir da data de publicação destas notas.
Nota: Se alguém encontrar as fontes de mailbox.h e mailbox.cpp do exemplo do Arduino, diga-o nos comentários do vídeo.
Solução para o problema
Enquanto o problema com as bibliotecas de caixa de correio não for resolvido, existe uma solução muito simples, mas totalmente funcional, que também é independente da linguagem de programação que usamos nos processadores principal e secundário e que é comunicar os dois processadores através de UART, o milkV DUO tem até 5 UARTs, então não vejo problema em usar este sistema para esse fim.
Como isso é feito?
Primeiro nos conectamos por SSH ao nosso DUO e executamos o seguinte comando:
[ 0.486095] 4140000.serial: ttyS0 at MMIO 0x4140000 (irq = 15, base_baud = 1562500) is a 16550A
[ 0.495226] printk: console [ttyS0] enabled
[ 0.514108] 4150000.serial: ttyS1 at MMIO 0x4150000 (irq = 16, base_baud = 1562500) is a 16550A
[ 0.524062] 4160000.serial: ttyS2 at MMIO 0x4160000 (irq = 17, base_baud = 1562500) is a 16550A
[ 0.534049] 4170000.serial: ttyS3 at MMIO 0x4170000 (irq = 18, base_baud = 1562500) is a 16550A
[ 0.544061] 41c0000.serial: ttyS4 at MMIO 0x41c0000 (irq = 19, base_baud = 1562500) is a 16550A
A partir daqui, podemos concluir que a porta ttyS0 está associada ao console do sistema, além disso, esta porta é mapeada para o UART0 da placa (Tx--> Pin16 e Rx--> Pin17) se você conectar um conversor USB para serial, como o FTDI232 (3.3V) e um cliente como CuteCom, poderemos ver em nosso PC o processo de inicialização do DUO, bem como fazer login e acessar o sistema, bem como do que se fosse uma conexão SSH.
Por outro lado, sabemos de acordo com a documentação do DUO que o UART3 é aquele que é configurado por padrão para o aplicativo VISUINO que roda no núcleo secundário. Portanto, para enviar dados do processador secundário, devemos unir com uma ponte Tx (Pin6) do UART3 com Rx (Pin17) do UART0, mas primeiro devemos "desanexar" o UART0 do console do sistema e deixá-lo livre para os aplicativos do usuário.
Pino 1 é utilizado para Log.
Para fazer isso, executamos o seguinte comando para editar o arquivo inittab encontrado no diretório /etc:
Agora podemos enviar dados do processador secundário (arduino) para o processador principal neste exemplo através de um script em Python, mas seria tão fácil fazer a aplicação em C, aqui está o código do exemplo em Python e Visuino.
Código VISUINO
Basicamente ele envia um comando SHELL
curl -X POST "https://api.thingspeak.com/update" -d "api_key=XXXXXXXXXXXXXXXX -d "field1=XXX.X" a cada 15 segundos.
Este programa manda pela serial UART o comando curl, o qual será processado pelo outro núcleo (SHELL) e então publicar os dados no ThingSpeak.
Aqui as propriedades do componente CharToText
Aqui as propriedades do componente FormattedText
O resultado é enviado por outra serial UART1.
Código Python
importserialimporttimeimportsubprocess# Set up serial connection (adjust settings for your specific device)ser=serial.Serial(port='/dev/ttyS0',# Change this to your serial portbaudrate=57600,parity=serial.PARITY_NONE,stopbits=serial.STOPBITS_ONE,bytesize=serial.EIGHTBITS,timeout=1# 1 second timeout)# Function to execute shell commandsdefexecute_shell_command(command):try:# Run the command and capture outputresult=subprocess.run(command,shell=True,capture_output=True,text=True)returnresult.stdoutifresult.stdoutelseresult.stderrexceptExceptionase:returnstr(e)# Main loop to act as a proxy between serial and shellwhileTrue:# Read from serialifser.in_waiting>0:serial_input=ser.readline().decode('ascii',errors='ignore').strip()#print(f"Received from serial: {serial_input}")# Execute the command received from serialifserial_input:output=execute_shell_command(serial_input)#print(f"Command output: {output}")res_list=(output.rstrip().split('\n'))
# print("\n".join(res_list))# Send result back to serialforelementsinres_list:ser.write(elements.encode('utf-8')+b'\r')print(elements)time.sleep(75/1000)
Este programa aguarda pela serial o comando curl, o qual será processado acionado para ser executado pelo SHELL.
Compilação e Transferência
Execução (Python)
Execução (VISUINO)
Dados recebidos pelo ThingSpeak
Hardware
Criando conta no ThingSpeak (Resumo)
Crie um conta no ThingSpeak
Em Channel Settings crie Field: Field1
Em API keys anote as chaves para escrita e Leitura de dados noThingsSpeak
Tem-se então basicamente duas URLS, uma para escrita e outra para leitura dos Fields, sendo que o Visuino fez uso da escrita. https://api.thingspeak.com/update?api_key=XXXXXXXXXXXXXX&field1=X
