picoRust.md

Investigación de Pico W con Rust, para prox. semestre emigrar a este lenguaje y dejar C y python

Dejar comentarios poniendo encabezado, ponerse de acuerdo para no duplicar.

1.- Marco Teorico en markdown justificando RUST como alternativa para Raspberry Pico W

2.- 10 practicas de RUST para Raspberry PucoW donde la primera es paso a paso, compilar, enlazar y subir a el memoria flash de picow

3- Sobre compilador, liberias, plataformas de desarroolo o extensiones. Linux, mac, windows, AWS. No hay un simulador en linea pero se requiere una apoyo de seguridad del dispositivo. Investigar como depurar la pico W con otras plataformas y cables por ejemplo OPENOCD https://openocd.org debuger por hardware

10 Prácticas Rust para Raspberry Pi Pico W.

Practicas Rust, Autor: CHATGPT

1. Parpadeo del LED integrado (paso a paso)

#![no_std]
#![no_main]

use rp_pico::entry;
use rp_pico::hal::{pac, watchdog::Watchdog, clocks::init_clocks_and_plls, sio::Sio, Timer, gpio::Pins};
use embedded_hal::digital::v2::OutputPin;
use panic_halt as _;

#[entry]
fn main() -> ! {
    let mut pac = pac::Peripherals::take().unwrap();
    let core = pac::CorePeripherals::take().unwrap();
    let mut watchdog = Watchdog::new(pac.WATCHDOG);
    let clocks = init_clocks_and_plls(
        rp_pico::XOSC_CRYSTAL_FREQ,
        pac.XOSC, pac.CLOCKS, pac.PLL_SYS, pac.PLL_USB,
        &mut pac.RESETS, &mut watchdog
    ).unwrap();

    let sio = Sio::new(pac.SIO);
    let pins = Pins::new(pac.IO_BANK0, pac.PADS_BANK0, sio.gpio_bank0, &mut pac.RESETS);
    let mut led_pin = pins.led.into_push_pull_output();
    let mut timer = Timer::new(pac.TIMER, &mut pac.RESETS);

    loop {
        led_pin.set_high().unwrap();
        timer.delay_ms(500);
        led_pin.set_low().unwrap();
        timer.delay_ms(500);
    }
}

---

2. Imprimir un mensaje por UART

#![no_std]
#![no_main]

use core::fmt::Write;
use panic_halt as _;
use rp_pico::entry;
use rp_pico::hal::{pac, sio::Sio, clocks::init_clocks_and_plls, watchdog::Watchdog, uart::UartPeripheral, gpio::Pins};

#[entry]
fn main() -> ! {
    let mut pac = pac::Peripherals::take().unwrap();
    let mut watchdog = Watchdog::new(pac.WATCHDOG);
    let clocks = init_clocks_and_plls(
        rp_pico::XOSC_CRYSTAL_FREQ,
        pac.XOSC, pac.CLOCKS, pac.PLL_SYS, pac.PLL_USB,
        &mut pac.RESETS, &mut watchdog,
    ).unwrap();

    let sio = Sio::new(pac.SIO);
    let pins = Pins::new(pac.IO_BANK0, pac.PADS_BANK0, sio.gpio_bank0, &mut pac.RESETS);

    let uart_pins = (
        pins.gpio0.into_mode::<rp_pico::hal::gpio::FunctionUart>(),
        pins.gpio1.into_mode::<rp_pico::hal::gpio::FunctionUart>(),
    );

    let mut uart = UartPeripheral::new(pac.UART0, uart_pins, &mut pac.RESETS)
        .enable(rp_pico::hal::uart::common_configs::_115200_8_N_1, clocks.peripheral_clock.freq())
        .unwrap();

    writeln!(uart, "Hola desde Rust y Pico W\r").unwrap();

    loop {}
}

---

3. Imprimir una suma simple

let a = 5;
let b = 3;
let suma = a + b;
writeln!(uart, "La suma de {} + {} es {}\r", a, b, suma).unwrap();

---

4. Mostrar números del 1 al 10

for i in 1..=10 {
    writeln!(uart, "Número: {}\r", i).unwrap();
}

---

5. Multiplicación simple

let x = 6;
let y = 9;
let producto = x * y;
writeln!(uart, "{} x {} = {}\r", x, y, producto).unwrap();

---

6. Conversión de libras a kilogramos

let libras = 180.0;
let kg = libras * 0.453592;
writeln!(uart, "{} lb = {:.2} kg\r", libras, kg).unwrap();

---

7. Mostrar tabla de cuadrados del 1 al 10

for i in 1..=10 {
    writeln!(uart, "{}^2 = {}\r", i, i * i).unwrap();
}

---

8. Tabla de multiplicar del 7

for i in 1..=10 {
    writeln!(uart, "7 x {} = {}\r", i, 7 * i).unwrap();
}

---

9. Sumar enteros del 1 al 100

let mut suma = 0;
for i in 1..=100 {
    suma += i;
}
writeln!(uart, "Suma de 1 a 100 = {}\r", suma).unwrap();

---

10. Promedio de tres números

let a = 80;
let b = 90;
let c = 85;
let promedio = (a + b + c) / 3;
writeln!(uart, "Promedio = {}\r", promedio).unwrap();

1. Compilador y Librerías
Rust usa rustc como compilador y cargo como gestor de paquetes. Para la Pico W, se requiere la instalación de la cadena de herramientas adecuada:

Instalar Rust: rustup target add thumbv6m-none-eabi.
Librerías clave: rp-hal es una capa de abstracción de hardware para la serie RP2040.

2.Plataformas de Desarrollo
Rust es compatible con múltiples plataformas:

Linux/macOS: Se puede usar cargo junto con probe-rs para flashear el firmware.

Windows: Se recomienda usar WSL2 o instalar cargo-binutils para la conversión de formatos.

AWS: No hay soporte directo, pero se puede usar contenedores para compilar firmware en la nube.

3. Depuración con OpenOCD
Para depurar la Pico W con hardware, se usa OpenOCD:

Instalar OpenOCD: git clone https://github.com/raspberrypi/openocd.git --branch rp2040

Compilar: ./bootstrap && ./configure --enable-picoprobe && make -j4

Conectar hardware: Se usa Picoprobe para conectar dos Picos y depurar con GDB.

1. Seguridad de Memoria
   Rust: Previene errores de memoria con su sistema de propiedad y verificación en tiempo de compilación.

C: Requiere gestión manual de memoria, lo que puede generar vulnerabilidades como desbordamientos de búfer.

2. Plataformas de Desarrollo
Rust es compatible con múltiples plataformas:

Linux/macOS: Se puede usar cargo junto con probe-rs para flashear el firmware.

Windows: Se recomienda usar WSL2 o instalar cargo-binutils para la conversión de formatos.

AWS: No hay soporte directo, pero se puede usar contenedores para compilar firmware en la nube.

3.Para depurar la Pico W con hardware, se usa OpenOCD:

Instalación de OpenOCD:

git clone https://github.com/raspberrypi/openocd.git --branch rp2040

Compilación:

./bootstrap && ./configure --enable-picoprobe && make -j4

4. Comparativa entre Rust y C

1. Seguridad de Memoria
   Rust: Previene errores de memoria con su sistema de propiedad y verificación en tiempo de compilación.

C: Requiere gestión manual de memoria, lo que puede generar vulnerabilidades como desbordamientos de búfer.

2. Concurrencia y Paralelismo
   Rust: Ofrece primitivas seguras para concurrencia, evitando condiciones de carrera.

C: Permite control manual, pero es propenso a errores en programación concurrente.

3. Velocidad de Ejecución
   Rust: Tiene una ligera sobrecarga por verificaciones de seguridad, pero es comparable a C en rendimiento.

C: Es altamente optimizado y ofrece control total sobre detalles de bajo nivel.

4. Depuración y Desarrollo
   Rust: Su compilador detecta errores antes de la ejecución, reduciendo fallos en producción.

C: Depuración más difícil, ya que los errores pueden aparecer en tiempo de ejecución.

5. Tendencias Futuras para Rust y C
Rust: Crecimiento y Expansión
Optimización del compilador: Mejoras en SIMD, evaluación de funciones en tiempo de compilación y optimización en tiempo de enlace.

Mayor adopción en la industria: Empresas como Microsoft y Google están migrando partes de su código a Rust debido a su seguridad de memoria.

Expansión en sistemas embebidos: Rust se está volviendo más popular en dispositivos IoT y sistemas embebidos gracias a su eficiencia y seguridad.

Uso en la nube: Se espera que Rust tenga un mayor impacto en el desarrollo de infraestructura en la nube y servicios de alto rendimiento.

C: Persistencia y Especialización
Aunque Rust está creciendo, C sigue siendo fundamental en ciertos sectores:

Optimización extrema: C sigue siendo la mejor opción para sistemas donde cada ciclo de CPU cuenta, como en firmware y sistemas operativos.

Compatibilidad y legado: Muchas aplicaciones críticas aún dependen de C, y su ecosistema es difícil de reemplazar completamente.

Seguridad mejorada: Se están desarrollando herramientas para mejorar la seguridad en C, aunque no igualan el enfoque de Rust

ejemplo:

let a = 5;
let b = 3;
let suma = a + b;
writeln!(uart, "La suma de {} + {} es {}\r", a, b, suma).unwrap();