VISUINO enviando comandos para o LINUX via UART

ls -l

Introdução

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.
VISUINO
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!

1. Bootloader

Atualmente, precisa gravar firmware compatível o 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.

Consulte Inicialize o Duo para instalar o sistema de cartão SD.

No caso

arduino-milkv-duo256m-sd-v1.1.2-2024-0801.img.zip

Após Boot, LED deve piscar

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:

mv /mnt/system/blink.sh /mnt/system/blink.sh_backup && sync

Ou seja, renomeie o script de LED piscando. Após reiniciar o Duo, o LED não piscará mais:

reboot

Neste momento, haverá um dispositivo serial adicional na “Porta” do “Gerenciador de Dispositivos” do computador.

2. Duo 256 pinos Arduino

Duo256M

SPI PWM I2C UART GPIO NAME PIN PIN NAME GPIO ADC
UART1_TX 1 GP0
1
40
VBUS
UART1_RX 2 GP1
2
39
VSYS
GND
3
38
GND
PWM7 GP2
4
37
3V3_EN
PWM6 GP3
5
36
3V3(OUT)
PWM5 UART3_TX GP4
6
35
PWM6 UART3_RX GP5
7
34
GND
8
33
GND
SPI2_SCK PWM9 I2C3_SDA GP6
9
32
GP27
SPI2_MOSI PWM8 I2C3_SCL GP7
10
31
GP26 ADC1
SPI2_MISO PWM7 I2C1_SDA GP8
11
30
RUN
SPI2_CSn PWM4 I2C1_SCL GP9
12
29
GP22
GND
13
28
GND
PWM10 I2C2_SDA 14 GP10
14
27
GP21 27
PWM11 I2C2_SCL 15 GP11
15
26
GP20 26
PWM4 UART0_TX GP12
16
25
GP19 25
PWM5 UART0_RX GP13
17
24
GP18 24
GND
18
23
GND
19 GP14
19
22
GP17 22
20 GP15
20
21
GP16 21

0
LED

3. Como fazer o VISUINO chamar o SHELL do Linux

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 de caixa de correio e 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:

dmesg|grep -i tty

Obteremos o seguinte:

[ 0.000000] Kernel command line: root=/dev/mmcblk0p2 rootwait rw console=ttyS0,115200 earlycon=sbi riscv.fwsz=0x80000 loglevel=9

[ 0.481564] printk: console [ttyS0] disabled

[ 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:

vi /etc/inittab

Devemos buscar o seguinte parágrafo

# Put a getty on the serial port

#console::respawn:/sbin/getty -L console 0 vt100 # GENERIC_SERIAL

console::respawn:/sbin/getty -L console 115200 vt100 -n -l /usr/local/bin/autologin

E comentar a última linha

# Put a getty on the serial port

#console::respawn:/sbin/getty -L console 0 vt100 # GENERIC_SERIAL

#console::respawn:/sbin/getty -L console 115200 vt100 -n -l /usr/local/bin/autologin

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 ls -l para listar arquivos da pasta root

Este programa implementa pela serial UART o comando ls -l, o qual será processado pelo outro núcleo (SHELL).

Aqui as propriedades do componente CharToText

Aqui as propriedades do componente FormattedText

O resultado é enviado por outra serial UART1.

Código Python

import serial
import time
import subprocess

# Set up serial connection (adjust settings for your specific device)
ser = serial.Serial(
    port='/dev/ttyS0',  # Change this to your serial port
    baudrate=57600,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS,
    timeout=1  # 1 second timeout
)

# Function to execute shell commands
def execute_shell_command(command):
    try:
        # Run the command and capture output
        result = subprocess.run(command, shell=True, capture_output=True, text=True)
        return result.stdout if result.stdout else result.stderr
    except Exception as e:
        return str(e)

# Main loop to act as a proxy between serial and shell
while True:
    # Read from serial
    if ser.in_waiting > 0:
        serial_input = ser.readline().decode('ascii', errors='ignore').strip()
        #print(f"Received from serial: {serial_input}")

        # Execute the command received from serial
        if serial_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 serial
            for elements in res_list:
                ser.write(elements.encode('utf-8') + b'\r')
                print(elements)
                time.sleep(75 / 1000)

Este programa implementa aguarda pela serial o comando ls -l, o qual será processado acionado para ser executado pelo SHELL.

Compilação e Transferência

Execução (Python)

Execução (VISUINO)

Que tal alterar FormattedText para

curl arduino.tips/asciilogo.txt

Curl

Ref:

ChatGPT

python - How do I execute a program or call a system command? - Stack Overflow

Envío de mensajes del núcleo secundario (Arduino) al principal (Python) en la milkV DUO | aquihayapuntes

Serial.readString() - Arduino Reference
Python print array with new line - Stack Overflow
Python | Ways to split strings using newline delimiter - GeeksforGeeks

A SMARTCORE FORNECE CHIPS E MÓDULOS PARA IOT, COMUNICAÇÃO WIRELESS, BIOMETRIA, CONECTIVIDADE, RASTREAMENTO E AUTOMAÇÃO. NOSSO PORTFÓLIO INCLUI MODEM 2G/3G/4G/NB-IOT, SATELITAL, MÓDULOS WIFI, BLUETOOTH, GPS, SIGFOX, LORA, LEITOR DE CARTÃO, LEITOR QR CCODE, MECANISMO DE IMPRESSÃO, MINI-BOARD PC, ANTENA, PIGTAIL, BATERIA, REPETIDOR GPS E SENSORES.

Iot Smartcore

quarta-feira, 30 de outubro de 2024

MILK-V DUO 256 - COMUNICAÇÃO ENTRE NÚCLEOS - SERIAL ENTRE VISUINO e LINUX SHELL CONSOLE: ls

Introdução

1. Bootloader