U-BLOX NINA B302 e RUST
O objetivo deste BLOG é demonstrar como é possível utilizar a liguagem de programação RUST para programar o módulo U-BLOX NINA B302. O NINA B302 foi montado no BREAKOUT da Smartcore.
Sobre o Rust
Rust é uma nova linguagem de programação patrocinada pela Mozilla. Rust 1.0, a primeira versão estável, foi lançado em 15 de maio de 2015. Ele se concentra na segurança, simultaneidade e velocidade, ao mesmo tempo que fornece controle de baixo nível. Isso o torna adequado para desenvolvimento embarcado. Rust tem muitas semelhanças com C, mas também leva inspiração em linguagens funcionais como Haskell. Além disso, também tem muitas ferramentas inspiradas nas ferramentas de linguagens dinâmicas como Ruby, Python e JavaScript.
O Rust visa fornecer segurança à memória sem coleta de lixo. Esta segurança é alcançado usando dois conceitos chamados propriedade e tempo de vida. Quando um novo variável é criada, ela está ligada a um nome. Então dizemos que esse nome "possui" a variável. Mais tarde, a variável pode ser associada a um novo nome, e a propriedade é passada. O rastreamento de propriedade permite que RUST saiba quando uma variável não é mais necessário. Isso ocorre porque quando o proprietário sai do escopo, a variável não está mais vinculado a nenhum nome e, portanto, não pode ser acessado pelo código não mais. A variável pode, portanto, ser descartada com segurança e sua memória liberada. Se quisermos que outra pessoa use a variável por um tempo, por exemplo, uma função, nós pode deixar a função tomar emprestada a variável, dando-lhe uma referência à variável.
No entanto, para evitar condições de corrida, podemos distribuir vários referências que não podem alterar a variável, ou podemos apenas distribuir um único referência mutável. Dessa forma, o Rust é capaz de evitar leituras simultâneas e grava em uma variável, garantindo que ela sempre esteja em um estado consistente, além do mais para isso, rastreando o tempo de vida das ligações e empréstimos, ou seja, o tempo que um variável é emprestada, ou o escopo em que a vinculação ou empréstimo existe, Rust pode garantir que não haja vinculações a uma variável eliminada.
Como o Rust deve ser usado em todos os lugares, C é usado hoje; também tem mecanismos para trabalhar com bibliotecas escritas em C. Para chamar uma função escrito em C do Rust, há algumas coisas que precisam ser feitas: a função deve ser declarada como uma função externa usando o C ABI, e a biblioteca onde a função é definida deve ser vinculada. Se a função usar quaisquer tipos compostos, como structs ou enums, esses tipos também devem ser definidos em Rust. Além disso, como o compilador Rust não pode verificar se a função C mantém garantias de segurança da RUST, quando chamamos a função, ela deve estar dentro de um local inseguro. Ao fazer uma função Rust para chamar de C, também precisamos marcar que a função deve usar o C ABI. Além disso, precisamos dizer ao compilador Rust para não estragar o nome da função. Um exemplo de uso do a interface de função estrangeira é mostrada na listagens abaixo:
// File: library.c
struct c_struct {
int a,
int b
}
// We must tell the C compiler what the Rust function looks like
extern int rust_function(int a);
int c_function(struct c_struct arg) {
return rust_function(arg.a);
}
// File: main.rs
// We need to tell the Rust compiler to pack the C
// struct in the same way that the C compiler would.
#[repr(C)]
struct c_struct {
a: i32,
8 b: i32,
}
#[no_mangle]
pub extern "C" fn rust_function(a: i32) -> i32 {
a + 1
}
// Inside this block we can define external functions
// that must be called using the C ABI.
extern "C" {
fn c_function(arg: c_struct) -> i32;
}
fn main() {
let foo = c_struct{a: 1, b: 2};
unsafe {
println!("foo.a + 1: {}", c_function(foo));
}
}
Às vezes, as garantias de segurança de Rust são um pouco estritas demais, ou Rust pode ser incapaz para provar que algo é seguro e, portanto, não o permitirá, mesmo que o o programador pode saber que a operação é segura. Nestes casos, Rust fornece a palavra-chave unsafe. Dentro de um bloco de código marcado como unsafe, Rust nos permite
fazer algumas coisas normalmente não permitidas:
• Cancelar a referência de um ponteiro bruto
• Acessar ou modificar uma variável estática mutável
• Chame uma função ou método unsafe
• Implementar um traço unsafe
Chamar funções estrangeiras se enquadra na categoria “Chamar uma função ou método unsafe” ponto. Variáveis estáticas em Rust são variáveis que têm uma vida útil estática, ou seja, eles duram por todo o programa. Além disso, seu escopo é global (para o módulo onde estão definidos). Isso significa que eles, em teoria, podem ser acessado por vários threads. Portanto, se a variável estática for mutável, não é seguro acessá-lo, pois outro thread pode estar modificando-o ao mesmo tempo. Como parte da análise da vida útil do Rust, ele é capaz de impedir a leitura de memória não inicializada. Esse acesso à memória é considerado inseguro, pois a memória pode conter qualquer valor. A razão para este ser um problema torna-se clara se consideramos uma variável não inicializada do tipo bool. A memória que o bool é feito de só pode ter dois valores válidos: 0 e 1. No entanto, o não inicializado pedaço de memória pode ter qualquer valor, o que leva a um problema se tentarmos ler o valor do bool. Em código seguro (código que não está dentro de um bloco unsafe) isso não pode acontecer, pois Rust pode detectar que a variável não foi inicializada, e é impossível obter referências a variáveis não inicializadas. No entanto, Rust também
suporta ponteiros brutos (ponteiros C padrão). Como esses ponteiros podem ser definidos para apontam para qualquer endereço, Rust não pode garantir que eles sempre apontem para
memória inicializada válida. Portanto, desreferenciar um ponteiro bruto é considerado inseguro, e deve ser feito dentro de um bloco inseguro.
Conjunto de ferramentas Rust e outras ferramentas úteis
O compilador "rustc" do Rust é baseado no back-end do compilador LLVM. O projeto LLVM consiste em vários subprojetos; os mais relevantes são o LLVM Core, Clang, compiler-rt e LLD. LLVM Core é um conjunto de bibliotecas que fornecem um otimizador independente de origem e destino e suporte à geração de código para muitos CPUs diferentes. Clang é um compilador C que usa LLVM como backend. Clang faz isso produzindo uma representação intermediária LLVM (LLVM IR), que é fornecido ao LLVM Core, que então gera o código binário final. Clang também pode ser usado como uma plataforma para fazer ferramentas de nível de origem. O LLVM IR contém alguns operações de alto nível que não são suportadas em todas as plataformas. Para essas plataformas, o compilador-rt fornece rotinas de implementos para essas operações. LLD é um novo linker, que pode ser usado como um substituto dos linkers do sistema. Tem sido usado como o vinculador padrão em alvos ARM Cortex-M desde 28 de agosto de 2018. Para ajudar a chamar o compilador e lidar com dependências Rust fornece cargo. Cargo é principalmente um gerenciador de pacotes que lida com as dependências de um projeto Rust, mas também pode ser usado para especificar como o projeto Rust deve ser construído. Isso inclui a construção e vinculação a bibliotecas C. Para fornecer este funcionalidade Cargo usa alguns arquivos de configuração e uma versão opcional roteiro. O primeiro arquivo de configuração, chamado de arquivo de manifesto, contém informações Sobre o projeto. Qual é o nome do projeto e que versão é? Quem escreveu? Ele também tem informações sobre quais dependências (Rust) são usadas e quais sinalizadores de recurso eles usam; quais outras bibliotecas devem ser vinculadas e onde encontrá-los. Ele também especifica como o próprio projeto é construído. Isso inclui opções como o tipo de biblioteca para a qual ela deve ser compilada (estática ou dinâmica), qual nível de otimização deve ser usado e como os pânicos (panic) devem ser tratados.
O outro arquivo de configuração “.cargo/config” e é usado para configurar o próprio Cargo.
Ele também pode ser usado para definir certos sinalizadores ao compilar para um destino específico e as opções neste arquivo podem ser espalhadas por vários arquivos, para cima na hierarquia de arquivos. Dessa forma, podemos especificar opções tanto globalmente quanto por projeto. O caminho final de influenciar a construção é um script de construção. Geralmente são chamados de “build.rs”, mas qualquer arquivo pode ser especificado no arquivo de manifesto. O arquivo de compilação contém um Rust programa que é executado antes da construção do projeto. Os casos de uso mais comuns para esses scripts de construção são para gerar código em tempo de compilação, código de construção escrito em outro idioma e para especificar como vincular aos idiomas nativos. A construção script pode passar comandos e opções para o Cargo usando sua saída padrão.
Rust usa uma estrutura de módulo hierárquica, o que significa que a estrutura do módulo representa uma árvore, com um módulo de nível superior que contém módulos filhos e em breve. Qualquer função, tipo, característica ou submódulo (um item) definido em um módulo é privado por padrão, mas pode ser tornado público pela palavra-chave pub. A exceção é o nível superior da biblioteca (caixa em linguagem de ferrugem), que não exporta nada por padrão. Um item é sempre público para seu módulo pai imediato, e o módulo dos filhos dos pais. Um módulo pode ser escrito no mesmo arquivo que seu pai, mas geralmente recebem seus próprios arquivos. Para simplificar o procurar por esses arquivos, o nome do arquivo é decidido pelo compilador Rust. Um arquivo contendo um módulo deve ter o mesmo nome do módulo ou ser chamado mod.rs e existe em uma pasta com o mesmo nome do módulo. Por exemplo, um módulo chamado foo pode ser escrito no arquivo do módulo pai, em foo.rs ou mod/foo.rs. Da mesma forma, Cargo espera que o arquivo de nível superior em uma biblioteca ser chamado de lib.rs, e em um executável main.rs.
Como o rustc visa o LLVM em vez de uma arquitetura real, o Rust pode ser compilado
para a maioria das plataformas para as quais o LLVM pode gerar código. Isso também significa que Rust é um compilador cruzado por padrão. Para compilar para um destino diferente, todos nós precisa fazer é obter a versão correta da biblioteca padrão e especificar quais alvo para o qual queremos compilar. No entanto, se quisermos usar a biblioteca padrão
(ou partes dele) em um alvo que Rust não suporta, ou queremos mudar como a biblioteca padrão é construída, nós mesmos temos que construir a biblioteca padrão.
Isso pode ser feito com a ferramenta Xargo, que imita o comportamento do Cargo mas também constrói a biblioteca padrão. Xargo irá compilar a biblioteca padrão e chamar o compilador com os sinalizadores corretos para que a nova biblioteca padrão seja vinculados. O Xargo, por padrão, só compilará o núcleo independente de plataforma da biblioteca padrão, mas se outras partes da biblioteca forem necessárias, eles também podem ser compilado.
Para saber como compilar para um alvo específico, o rustc usa uma especificação de arquivo alvo. Esta abordagem foi sugerida pela primeira vez na RFC 131. Ter o alvo especificações escritas em seu próprio arquivo de configuração permitem que os usuários editem os alvos facilmente, e assim facilmente transportar Rust para novas plataformas. O arquivo de configuração consiste de um objeto JSON que especifica qual destino LLVM deve ser usado, junto com o endianness, a largura do ponteiro e do inteiro e o layout de dados do alvo. Dentro além disso, existem campos para especificar o sistema operacional, ambiente (qual libc), fornecedor e arquitetura. Essas opções são usadas para condicional compilação de Rust. Por fim, existem muitas configurações opcionais que podem ser
conjunto. Entre eles estão qual linker usar e quais argumentos o linker deve ser usado, quais formatos de saída estão disponíveis e algumas configurações que controlam quais otimizações são aplicadas. Uma descrição completa da especificação alvo pode ser encontrado. Embora as especificações de destino possam ser escritas em JSON, os destinos suportados são construídos diretamente no rustc. Há duas razões para isso:
1. Facilita a distribuição, evitando a necessidade de arquivos de configuração;
2. As especificações tornam-se imutáveis e podem, portanto, serem confiáveis.
No entanto, o rustc pode imprimir as especificações no formato JSON. A especificação do thumbv7em-none-eabi alvo, que é o alvo para um bare metal Cortex M4 sem uma unidade de ponto flutuante pode ser visto na listagem abaixo:
{
"abi-blacklist": [
"stdcall",
"fastcall",
"vectorcall",
"thiscall",
"win64",
"sysv64"
],
"arch": "arm",
"data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
"emit-debug-gdb-scripts": false,
"env": "",
"executables": true,
"is-builtin": true,
"linker": "rust-lld",
"linker-flavor": "ld.lld",
"llvm-target": "thumbv7em-none-eabi",
"max-atomic-width": 32,
"os": "none",
"panic-strategy": "abort",
"relocation-model": "static",
"target-c-int-width": "32",
"target-endian": "little",
"target-pointer-width": "32",
"vendor": ""
}
Outra ferramenta útil para desenvolvedores Rust é (Rust-) Bindgen. Tanto do trabalho com a chamada de funções C vem do fornecimento de protótipos C em Rust, Bindgen foi feito para gerar essas ligações automaticamente. Bindgen usa libclang, um interface da biblioteca para o Clang. Dessa forma, o Bindgen pode gerar uma sintaxe abstrata árvore (AST) do código, e encontre todas as funções e definições de tipo que são usados. Ao usar libclang, o Bindgen também obtém o benefício de executar o pré-processador no código, então, se houver várias versões de uma função baseada em algumas opções de configuração, o Bindgen verá a correta.
Instalando Rust
Após incessantes procuras de como instalar o RUST em seu PC, cheguei a seguinte conclusão: não utilize no WINDOWS 7, não me pergunte o porque, mas repeti os mesmo processos no WINDOWS 10 e fluiu perfeitamente.
Das várias procuras, a que funcionou 100% no W10, MAC e LINUX, foi a do LINK abaixo
Que exemplo eu testei e onde ?
#![no_main]
#![no_std]
use core::time::Duration;
use cortex_m_rt::entry;
use panic_log as _; // panic handler
#[entry]
fn main() -> ! {
// uncomment to enable more verbose logs
// log::set_max_level(log::LevelFilter::Trace);
let board = dk::init().unwrap();
let mut led = board.leds._1;
let mut timer = board.timer;
for _ in 0..10 {
led.toggle();
timer.wait(Duration::from_secs(1));
log::info!("LED toggled at {:?}", dk::uptime());
}
dk::exit()
}
Assustador o programa, sim, um novo paradigma!
#![no_std]
O atributo #! [No_std] indica que o programa não fará uso da biblioteca padrão, a caixa std. Em vez disso, ele usará a biblioteca central, um subconjunto da biblioteca padrão que não depende de um sistema operacional (SO) subjacente.
#![no_main]
O atributo #! [No_main] indica que o programa usará um ponto de entrada personalizado em vez do padrão fn main () {..}.
| #[entry] |
O atributo # [entrada] declara o ponto de entrada personalizado do programa. O ponto de entrada deve ser uma função divergente cujo tipo de retorno é o tipo nunca!. A função não pode retornar; portanto, o programa não pode ser encerrado.
O exemplo utilizado foi o para piscar um LED (BLINK) o qual foi testado na placa BREAKOUT.
ÓTIMA REFERENCIA PARA PINOS DO ARDUINO E PINOS (GPIOS) DO NINA B302
https://www.u-blox.com/sites/default/files/NINA-B3_DataSheet_%28UBX-17052099%29.pdf
Gravando via ST-LINK V2 (VSCODE)
Sobre a SMARTCORE
Para programar será utilizado o ST-LINK V2
ÓTIMA REFERENCIA PARA PINOS DO ARDUINO E PINOS (GPIOS) DO NINA B302
LED LIGADO NO GPIO20 (P0.31)
Alterei o código para piscar mais rápido
#![no_main]
#![no_std]
use core::time::Duration;
use cortex_m_rt::entry;
use panic_log as _; // panic handler
#[entry]
fn main() -> ! {
// uncomment to enable more verbose logs
// log::set_max_level(log::LevelFilter::Trace);
let board = dk::init().unwrap();
let mut led = board.leds._1;
let mut timer = board.timer;
for _ in 0..100 {
led.toggle();
timer.wait(Duration::from_millis(100));
log::info!("LED toggled at {:?}", dk::uptime());
}
dk::exit()
}
LED PISCANDO 10Hz por 10 segundos
Abaixo algumas imagens principais do Ambiente RUST
Exemplo Blinky - Visual Studio Code
Alteração dos GPIOS para serem compatíveis com o NINA B302 - Ublox (lib.rs)
Compilando no Visual Code
Compilando no BASH
Gravando via ST-LINK V2 (BASH)
Executando
Dúvidas:
suporte@smartcore.com.br
Referências:
https://www.u-blox.com/en/docs/UBX-17056481
https://www.u-blox.com/sites/default/files/NINA-B3_DataSheet_%28UBX-17052099%29.pdf
suporte@smartcore.com.br
Referências:
https://www.u-blox.com/en/docs/UBX-17056481
https://www.u-blox.com/sites/default/files/NINA-B3_DataSheet_%28UBX-17052099%29.pdf
Nenhum comentário:
Postar um comentário