Our logo :(

Hackerspace Monterrey

Instalacion de toolchanin para nRF51 en linux

Instalacion de toolchain para nRF51 en linux

La razon para este tutorial es la necesidad de utilizar el nRF51822 en un proyecto. Al momento de escribir esto tengo una tarjeta [Carbon de 96boards] que contiene un nRF51822 con la interface SWD expuesta, y un ST Link V2 a modo de programador.

stlinkCarbon

Querer mantener trabajandome en linux me obliga a manejar el toolchain con herramientas abiertas. Lo bueno es que se tiene lo necesario para poder hacer esto:

  • GNU arm embedded toolchain provee el compilador y el debugger
  • Nordic nRF51_SDK provee las herramientas especificas y codigos para el manejo de los nRF51
  • openOCD la herramienta para comunicarnos directamente con el nRF51.

Instrucciones

Una carpeta para controlarlos a todos.

Crear una carpeta para trabajar los proyectos con este toolchain: ~$mkdir opt eso crea una carpeta en home llamada opt: /home/<usuario>/opt

GNU arm toolchain

  • Descargar, descomprimir y poner en la carpeta opt el GNU arm toolchain
  • No se necesita modificar nada del path.

Nordic nRF51_SDK

  • Descargar, descomprimir y poner en la carpeta opt el SDK de nordic para nRF51
  • Se modifica el archivo /home/<usuario>/opt/<SDK>/componentes/toolchain/gcc/Makefile.posix. Originalmente contiene la direccion de la instalacion global del arm-none-eabi-gcc, pero queremos usar la que descargamos, asi que lo cambiamos por el path absoluto del GNU arm toolchain

    ~~~~ GNU_INSTALL_ROOT := /home//opt/gcc-arm-none-eabi-7-2017-q4-major GNU_VERSION := 4.9.3 GNU_PREFIX := arm-none-eabi ~~~~

Con esto al momento de ejecutar el comando make desde alguno de los ejemplos del SDK se llama al executable arm-none-eabi-gcc contenido en opt

openOCD

  • Instalar libusb-1.0 sudo apt-get install git autoconf libtool make pkg-config libusb-1.0-0 libusb-1.0-0-dev libusb debe estar instalado ya que al configurar openocd se valida libusb para activar las configuraciones de los dongles usb

  • Descargar, descomprimir openOCD git clone git://git.code.sf.net/p/openocd/code openocd-code

  • Realizar el proceso de instalacion: ./bootstrap ./configure make sudo make install

openocd queda instalado en /usr/local/share/openocd

Validacion

Compilacion de ejemplos.

  • Ir a un ejemplo especifico, en este caso: /home/<usuario>/opt/<SDK>/examples/ble_peripheral/ble_app_beacon/
  • Ir a la carpeta que contine el codigo especifico para la aplicacion. <>/ble_app_beacon/pca10028/s130/ se escogio este ejemplo ya que es compatible con una tarjeta custom sin elementos extras utilizando el softdevice 130.
  • Ejecutamos make
  • Como resultado al make se crea la carpeta _build en la que reciden el .bin y el .hex. Este .hex es el que usaremos mas tarde para cargarlo a la tarjeta.

La interface SWD en el carbon tienen los pines: 3.3v - GND - CLK - DIO - RST. * Conectamos a los pines correspondientes en el conector del stlink v2

                        |   CARBON SWD  |   STLINK V2   |
                        |---------------|---------------|
                        |   3.3v        |   PIN 2       |
                        |   GND         |   PIN 6       |
                        |   CLK         |   PIN 9       |
                        |   DIO         |   PIN 7       |
                        |   RST         |   PIN 15      |
                        |---------------|---------------|
  • Alimentamos la Carbon mediante el puerto otg.
  • Conectamos el stlink con el cable microusb.

Iniciamos openocd

Creamos una carpeta para hacer esta prueba y colocar un archivo openocd.cfg que contenga los parametros que utilizara openocd para la conexion. * Interface: stlink-v2.cfg * Target: nrf51.cfg * Transport: hla_swd

$mkdir /home/<usuario>/opt/test

  • Abrimos el archivo nano openocd.cfg
  • Agregamos el siguiente texto ~~~~ # nRF51822 Target

Using stlink as SWD programmer

source [find interface/stlink-v2.cfg]

SWD as transport

transport select hla_swd

Use nRF51 target

set WORKAREASIZE 0x4000 source [find target/nrf51.cfg] ~~~~

La ventaja del stlink v2 es que ya existe un archivo de configuracion para usarlo como interface y un archivo de configuracion del nrf51 como target. * Ejecutamos openocd con el archivo que creamos: openocd -f openocd.cfg

Nos resulta el verbose de openocd que queda a la espera de conexiones

Info : The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD
adapter speed: 1000 kHz
Info : Listening on port 6666 for tcl connections
Info : Listening on port 4444 for telnet connections
Info : Unable to match requested speed 1000 kHz, using 950 kHz
Info : Unable to match requested speed 1000 kHz, using 950 kHz
Info : clock speed 950 kHz
Info : STLINK v2 JTAG v27 API v2 SWIM v6 VID 0x0483 PID 0x3748
Info : using stlink api v2
Info : Target voltage: 3.234714
Info : nrf51.cpu: hardware has 4 breakpoints, 2 watchpoints
Info : Listening on port 3333 for gdb connections

Control y carga de archivos

Con openocd corriendo y conectado al target podemos enviar la informacion al dispositivo. En este caso en particular le cargaremos el softdevice 130 y despues el ble_app_beacon que compilamos.

  • Abrimos un telnet al localhost (127.0.0.1) al puerto 4444 telnet localhost 4444 ~~~~ Trying 127.0.0.1… Connected to localhost. Escape character is ‘^]’. Open On-Chip Debugger > ~~~~
  • Reiniciamos y paramos el micro. reset halt ~~~~ target halted due to debug-request, current mode: Thread xPSR: 0xc1000000 pc: 0x000006d0 msp: 0x000007c0 ~~~~
  • borramos el micro nrf51 mass_erase ~~~~ nRF51822-QFAC(build code: A1) 256kB Flash ~~~~
  • Cargamos el softdevice flash write_image erase /home/<usuario>/opt/<sdk>/components/softdevice/s130/hex/s130_nrf51_2.0.1_softdevice.hex ~~~~ auto erase enabled Padding image section 0 with 2112 bytes using fast async flash loader. This is currently supported only with ST-Link and CMSIS-DAP. If you have issues, add “set WORKAREASIZE 0” before sourcing nrf51.cfg/nrf52.cfg to disable it target halted due to breakpoint, current mode: Thread xPSR: 0x61000000 pc: 0x2000001e msp: 0xfffffffc wrote 110592 bytes from file /home/eden/opt/nRF5_SDK_12.3.0_d7731ad/components/softdevice/s130/hex/s130_nrf51_2.0.1_softdevice.hex in 4.837066s (22.328 KiB/s) ~~~~
  • Cargamos el app flash write_image erase /home/eden/opt/nRF5_SDK_12.3.0_d7731ad/examples/ble_peripheral/ble_app_beacon/pca10028/s130/armgcc/_build/nrf51422_xxac.hex ~~~~ auto erase enabled using fast async flash loader. This is currently supported only with ST-Link and CMSIS-DAP. If you have issues, add “set WORKAREASIZE 0” before sourcing nrf51.cfg/nrf52.cfg to disable it target halted due to breakpoint, current mode: Thread xPSR: 0x61000000 pc: 0x2000001e msp: 0xfffffffc wrote 12288 bytes from file /home/eden/opt/nRF5_SDK_12.3.0_d7731ad/examples/ble_peripheral/ble_app_beacon/pca10028/s130/armgcc/_build/nrf51422_xxac.hex in 0.568909s (21.093 KiB/s) ~~~~
  • reiniciamos el micro reset

Para validar que el firmware funciono abrimos algna app como el nRFConnect y validamos que el beacon este haciendo advertising.

beacon

Referencias.

Enlaces en los que me base para lograr la implementacion del toolchain.

Muestra la configuracion para un nrf51 vanilla y los comandos para cargar tanto el softdevice como la app [Enlace 1][https://acassis.wordpress.com/2016/02/25/using-openocd-to-program-a-homebrew-nrf51822-board/] Muestra tambien el comando para cargar el nrf51 vanilla y algunos errores [Enlace 2][https://devzone.nordicsemi.com/question/70314/program-bluetooth-for-nrf51822-yunjia-board-with-stlink-v2/]

Túnel ssh para RaspberryPi

El objetivo.

Acceder a una RaspberryPi[1] que está detrás de una IP dinámica (lo más común para proveedores de Internet en hogares) sin necesidad de configurar algún servicio de NATing[2] en el modem y/o router.

Un caso de uso sería monitorear nuestros equipos remotamente, revisando que su funcionamiento sea el correcto.

Cómo funciona esto es que creamos un túnel inverso (eng. reverse SSH tunel) utilizando SSH[3], esto crea una conexión encriptada desde la Raspberry Pi al servidor, la configuramos de tal manera que esta conexión inicie automáticamente cada que se enciende la máquina, así podemos asegurarnos que la conexión se reestablesca si se llegase a interrumpir.

Asunciones

  • Se tiene acceso a un servidor con IP pública y SSH
  • Se tiene una PC (Workstation/Desktop/Mac/Laptop).
  • Se tiene una Raspberry Pi.
  • Se tiene una salida a Internet.
  • Se tiene una red local (LAN).
  • La PC y Raspberry están conectadas a la LAN.

Configuración para usuarios

## Preparar usuario para túnel la Raspberry

  • Habilitar SSH en raspberry.

    rpi$ sudo raspy-config

[imagen raspy-config menu] [imagen raspy-config opcion]

  • Crear usuario para el tunel en Raspberry.

    rpi$ sudo adduser tunnel

[imagen alta-usuario]

  • Cambiar de usuario a tunnel.

    rpi$ su tunnel

  • Crear un par de llaves SSH para el usuario Tunnel.

    rpi$ ssh-keygen

  • Obtener la dirección IP asignada a la Raspberry.

    rpi$ ip addr show

Esto desplegara una lista de tus interfaces, busca la dirección IP como un juego de cuatro números junto la etiqueta ‘inet’.

e.g.

3: wlan0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1400 qdisc mq state UP group default qlen 1000
    link/ether 00:00:00:00:00:00 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.2/24 brd 192.168.0.255 scope global wlan1
    valid_lft forever preferred_lft forever
    inet6 fe80::c66e:1fff:fe16:49e3/64 scope link
    valid_lft forever preferred_lft forever

En este caso la dirección sería 192.168.0.2

Preparar usuario para túnel en servidor

  • Crear usuario para túnel en servidor

    servidor$ sudo adduser tunnel

[imagen alta-usuario]

  • Crear carpeta .ssh

servidor$ su tunnel servidor$ cd ~ servidor$ mkdir .ssh servidor$ cd .ssh

Copiar llave pública al servidor

El par de llaves criptográficas que acabamos de crear nos servirán para poder conectarnos al servidor desde la Raspberry sin necesidad de tener que ingresar la contraseña del usuario cada vez que tenemos que conectarnos al él.

  • Copiamos la llave pública, id_rsa.pub, de la Raspberry al servidor, utilizando nuestra PC como intermediario. Reemplaza con la dirección.

    PC$ scp tunnel@<raspberry-ip>:.ssh/id_rsa.pub raspberry_public_key

  • Una vez hecho esto, copiamos la llave al servidor:

    PC$ scp raspberry_public_key tunnel@<servidor>:

  • Ingresamos al servidor para colocar la llave pública de la Raspberry en la lista de llaves autorizadas para realizar identificar.

PC$ ssh <servidor> servidor$ su tunnel servidor$ cat raspberry_public_key >> ~/.ssh/authorized_keys

Con esto debemos tener nuestra llave pública que se creo en la Raspberry Pi dentro de la cuenta del usuario tunnel dentro del servidor. Para validar que la llave se haya copiado correctamente, desplegamos que el contenido del archivo ~/.ssh/authorized_keys y verificamos que sea el mismo que generamos para el usuario tunnel en la Raspberry Pi.

`servidor$ cat ~.ssh/authorized_keys`

Crear túnel

Probar el comando para el túnel.

  • Ingresamos a raspberrypi con el tunnel desde pc/laptop.

    PC$ ssh tunnel@<ip-raspberry>

  • Probamos correr manualmente el comando que crea el túnel

rpi$ ssh -NTC -o ServerAliveInterval=60 -o ExitOnForwardFailure=yes -o StrictHostKeyChecking=no \ -i ~/.ssh/id_rsa -R 12345:localhost:22 tunnel@<servidor>

Si el comando fue bien la terminal se quedara en “stand-by”, esperando conexiones. Se puede agregar la opción -v al comando para ver lo que ocurre con las conexiones, esto nos ayuda en caso de que ocurra un error.

Para probar que realmente tenemos acceso, entramos al servidor y cambiamos de usuario a “tunnel”, con ese usuario activo ejecutamos:

servidor$ ssh localhost -p 12345

Si todo sale bien nuestro prompt cambia hacia el prompt de nuestra Raspberry Pi:

rpi$

Crear servicio de túnel.

Una vez validado el comando de túnel, lo que falta es hacer que se ejecute cada que la Raspberry Pi se encienda. Para ello usamos systemd[4] para crear un servicio que realice esta tarea.

  • Creamos el archivo del servicio

    rpi$ sudo nano /etc/systemd/system/tunnel-service

  • Añadimos la siguiente configuración a este archivo

``` [Unit] Description=SSH Tunnel Service ConditionPathExists=|/usr/bin After=network.target

[Service] User=tunnel ExecStart=/usr/bin/ssh -NTC -o ServerAliveInterval=60 -o ExitOnForwardFailure=yes -o StrictHostKeyChecking=no -i %h/.ssh/id_rsa -R 12345:localhost:22 tunnel@

RestartSec=3 Restart=always

[Install] WantedBy=multi-user.target ```

Guardamos el archivo antes de salir (presionando Ctrl-o en Nano).

  • Iniciamos el servicio.

    rpi$ sudo systemctl restart tunnel-service

Si el resultado es positivo veremos el siguiente mensaje en pantalla.

[imagen log de systemctl restart]

  • Habilitamos al servicio para que se ejecute desde boot.

    rpi$ sudo systemctl enable tunnel-service

Probar túnel.

Habiendo hecho esto, accedemos con cualquier usuario al servidor y cambiamos al usuario tunnel. Reiniciamos la Raspberry Pi, una vez reiniciada accedemos al túnel desde el servidor:

servidor$ su tunnel servidor$ ssh localhost -p 12345

Con ello debemos aparecer en la terminal de nuestra Raspberry Pi.

Recomendaciones.

  • Cambia el nombre de la Raspberry Pi a uno que sea mas especifico a nuestra aplicación (podemos tener muchas raspies regadas por ahi).

  • Asignar una dirección IP estática a la Raspberry, si por alguna razón estamos en el sitio y tenemos que acceder a la misma nos ahorramos el paso de buscar la dirección asignada por la red.

  • Usar un usuario diferente para cada túnel en el server para una mejor administración.

  • Se puede validar si el túnel esta vivo del lado del servidor si buscamos por conexiones ssh en modo LISTEN servidor$ netstat -l | grep ssh

Instalación de Arduino y Processing en RPi

Arduino y Processing en tu RPi

Antes de empezar, ¿Que se necesita?

- Un raspberryPi (en éste caso se uso el modelo 2 de 1gb)
- MicroSd de 8gb con Raspbian instalado
- monitor con entrada hdmi (o que soporte el adaptador a usar)
- Cable hdmi (en éste caso se usó un adaptador con el otro extremo a dBi)
- adaptador de corriente para alimentar tu RPi
- teclado
- mouse
- conexión a internet
- Arduino uno y su cable usb

Teniendo lo anterior estamos listos para empezar…



Spoiler-Disclaimer

La instalación será por comandos a través de la terminal, aquí se mostraran los comandos necesarios para la instalación de éstas plataformas de desarrollo.

  • No nos hacemos responsables de cualquier adicción adquirida durante la instalación o después de.
  • Cualquier fallo o duda presente durante la instalación de las dos plataformas es responsabilidad de cada una respectivamente (Arduino y Processing) el brindar soporte y/o facilitar foros para consultas.


Manos a la obra

Es sencillo instalar estas dos plataformas ya proporcionan información detallada del proceso y algunas recomendaciones para tener una mejor experiencia dentro de su plataforma de desarrollo.

Lo primero que haremos es encender nuestro raspberry y en el escritorio abriremos una nueva terminal lo siguiente sera instalar el IDE de Arduino.

#Para instalar el IDE de arduino solo hace falta escribir lo siguiente en la terminal.

$pi@raspberrypi:~ $ sudo apt-get install arduino

Después de dar “enter” mostrará una pregunta de si quieres continuar con la instalación pondremos que si escribiendo una Y , seguido daremos “enter” y continuará con la instalación hasta terminar (al finalizar sólo permitirá introducir un nuevo comando) .

#Para instalar el IDE Processing solo debemos escribir lo siguiente en la terminal.

$pi@raspberrypi:~ $ curl https://processing.org/download/install-arm.sh | sudo sh

Una ves finalizado va a permitir introducir un nuevo comando, ya con esto si lo deseamos solo hacer falta escribir el nombre de la plataforma en la terminal.

$pi@raspberrypi:~ $ arduino O bien de la misma forma podemos llamar directamente processing.

$pi@raspberrypi:~ $ processing

De otra forma podemos ir y abrirla de forma gráfica en el menú desplegable superior izquierdo en el la lista de aplicaciones para programación.

Para mas información

Para dudas sobre arduino has clic aquí.

Para dudas sobre Processing has clic aquí.

Mas allá de Arduino - parte 1

Programación de AVR ATtiny desde una Raspberry Pi.

img1

Hay un momento en la vida de todo maker en el que madura y empiezan a explorar otras plataformas, como todo lo que nos ofrece Atmel. Su plataforma AVR es el paso natural a seguir después de Arduino. Cabe mencionar que todo el toolchain de AVR es open source y podremos utilizarlo desde Linux en la Raspberry Pi sin chistar.

Layer Shortcuts - Eagle

EAGLE TIPS - Atajos de teclado.

img1



Dirección
Isaac Garza 735-A
Monterrey, N.L.
C.P. 64000
(81) 19-36-9480
Mapa

Horario
Martes
19:00 a 23:00

Sábado
14:00 a 00:00

Junta semanal
Martes 19:00