Controlando placas de IoT desde javascript


Node.js framework  fue  creado por Bocoup para controlar placas de desarrollo en una configuración de host-cliente   aunque   realmente su uso mayoritario sea como plataforma web   siendo    Johnny-Five la plataforma open  source de Robótica e IoT de JavaScript 

En realidad existen diferentes  plataformas donde se puede ejecutar el programa Johnny-Five :

  • En un entorno Linux a bordo: beagleBone Black,Chip,Intel Galileo gen 1,Intel Galileo Gen 2,Intel Edison Arduino,Intel Edison Mini, SparkFun Edison GPIO Block,SparkFun Arduino Block, Intel Joule 570x (Carrier Board),Linino One,pcDuino3 Dev Board,Raspberry Pi 3 Model B, Raspberry Pi 2 Model B. Raspberry Pi Zero,Raspberry Pi Model A Plus,Raspberry Pi Model B Plus, Raspberry Pi Model B Rev 1, Raspberry Pi Model B Rev 2, Tessel 2
  • En una máquina host conectada (a través de Serial USB o Ethernet) a un cliente.: Arduino Uno,SparkFun RedBoard, On a host machine communicating over Bluetooth to the client. Arduino Uno,Arduino Leonardo, Arduino Mega, Arduino Fio,Arduino Micro,Arduino Mini,arduino Nano,Arduino pro Mini,Boatduino,chipKit uno32,Spider robot Controller,DfRobot Romeo,Teensy 3,
  • En una máquina host que se comunica por wifi al cliente: Electric Imp April, pinoccio Scout, Particle Core ( Spark Core) ,Particle Photon, Sparkfun Photon RedBoard
  • En una máquina host que se comunica a través de Bluetooth al cliente :Blend Micro v1.0,LightBlue bean,

Johnny-Five como vemos hacer un énfasis especial en la robótica, pero tambien puede hacer muchas cosas diferentes con el software.De hecho ha existido durante hacer  más tiempo que la mayoría de los marcos de JavaScript para hardware . Ademas iene una API clara  y “fresca” ,ambas cosas ideales para los principiantes de hardware.

Lanzado porBocoup en 2012, Johnny-Five esta mantenido por una comunidad de desarrolladores de software apasionados e ingenieros de hardware. De hecho más de 75 desarrolladores han hecho contribuciones para construir un ecosistema robusto, extensible y muy versatil.

 

Hola Mundo! 

A los microcontroladores y las plataformas SoC nos gusta decir “Hola mundo” con un simple LED parpadeante, así  que veamos en primer lugar un ejemplo como lo hariamos  usando el Ide clásico  de Arduino

Como vemos en la imagen ,conectaremos un led entre el pin 13  y masa , respetando la polaridad (el ánodo al pin13 y el cátodo o pin corto a masa )

Para  hacer destellear el citado led,  estos son los pasos básicos  que tenemos que seguir en nuestro sketch  programandolo desde el IDE de Arduino:

  1. Configurar el pin 13 (con LED incorporado) como una SALIDA
  2. Establecer el pin 13 ALTO para encender el LED
  3. Esperamos 500 ms (medio segundo)
  4. Establecer el pin 13 BAJO para apagar el LED

Y este es el código completo para ejecutar desde el Ide de Arduino:

void setup() {
pinMode(13, OUTPUT);    
}
void loop() {
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);  
delay(500);
}

Y ahora vamos a ver el mismo ejemplo , pero ejecutandolo en Javascript por medio de node-js,

Desgraciadamente  si usamos un Arduino o alguno de sus variantes (Arduino Uno,SparkFun RedBoard, On a host machine communicating over Bluetooth to the client. Arduino Uno,Arduino Leonardo, Arduino Mega, Arduino Fio,Arduino Micro,Arduino Mini,arduino Nano,Arduino pro Mini,Boatduino,chipKit uno32,Spider robot Controller,DfRobot Romeo,Teensy 3,)   necesitaremos que el programa JavaScript se ejecute en una máquina host que ejecute Node.js. de modo que el programa transmitirá instrucciones básicas de E / S a la placa a través de una interfaz  serie USB , que actuara como un cliente ligero .

El método host-cliente implica la comunicación a través de una API común entre el host y el cliente. El marco Node.js usado con Arduino y placas similares , Johnny-Five, se comunica (de forma predeterminada) con las placas  utilizando un protocolo llamado Firmata, protocolo que permite que los hosts (computadoras) y los clientes (microcontroladores) intercambien mensajes de ida y vuelta en un formato basado en mensajes MIDI. El protocolo Firmata especifica cómo deben ser esos mensajes de comando y datos. La implementación de Firmata de Arduino proporciona el firmware real que puede poner en su tablero para hacer que “hable” Firmata. Toma la forma de un boceto de Arduino que sube al tablero.

Firmata es lo suficientemente popular como para que los bocetos de Firmata que necesita vengan empaquetados con el IDE de Arduino asi que bastara con subir este a Arduino una única vez  ya que  el código javascript  correra en el host usando node.js.

Puede seguir estos pasos para cargar el interfaz correcto de Firmata en su Arduino  para que se pueda utilizar como cliente en una configuración de host-cliente:

Resumidamente estos son los pasos previos para ejecutar el   mismo  ejemplo del led parpadeante  que hemos visto pero   en  javascript en una placa Arduino;

  • En primer lugar  conectar  su Arduino  mediante USB a  su ordenador
  • Lanzar el IDE de Arduino.
  • Asegurarse que esta configurada la version de su placa,  así como el puerto COM  virtual al que esta conectado
  • Acceda al menú Archivo> Ejemplos> Firmata
  • Seleccione StandardFirmataPlus de la lista y despliegue este sw sobre su Arduino

  • Ahora Instale Node.js   en su pc . Funciona  con ultima version 11.3.0  de  64 bit que incluye  npm 6.4 (no olvidar de chequear que se instalen  otros componentes )Este es el link de descarga https://nodejs.org/en/download/ 
  • En la instalación de Node.js, repetimo  no debemos olvidar de chequear que se instalen  otros componentes  pues  con ellos se   instalara automáticamente
    • Python 2.7.3 (http://www.python.org/getit/releases/2.7.3/)
    • Visual Studio Express 2010 de 32 bits (con  las dependencias de C ++)
    • El comando npm
    • Alternativamente si dispusiésemos de npm podríamos instalar ambos entornos  con  npm --add-python-to-path install --global --production windows-build-tools
  • Este pasos anterior ( instalacion de componentes ) es  innecesario  si chequeamos en la instalación  de node.js  pues se instalaran  esos componentes  automáticamente
  • Ahora instalar node-gyp  medianete  el comando  npm install -g node-gyp (esto instalará node-gyp globalmente)                          
  • Ya puede  crear su primer proyecto Johnny-Five, por lo que en primer lugar cree un directorio para él e instale el paquete framework npm, como se muestra en la siguiente lista:
    • < mkdir hello-world
    • < cd hello-world
    • < npm install johnny-five
  • Ejecute  el comando “npm install johnny-five” desde la carpeta del proyecto
  • Ya por fin podemos crear el fichero javascript  con su editor de texto  que contendrá el código en javascript  . 

Realmente estos son los pasos  que tenemos que seguir:

  1. Requerir el paquete johnny-five
  2. Inicializar un nuevo objeto Board que represente a su placa .
  3. Esperar a que el tablero dispare el evento listo
  4. Crear una instancia de un objeto LED en el pin 13 (el pin LED incorporado de Uno)
  5.  Hacer que el LED parpadee cada 500 ms

Este es el código en js :


const five = require(‘johnny-five’);
const board = new five.Board();
board.on(‘ready’, () => {
 const led = new five.Led(13);
   led.blink(500);
});


Guarde el archivo como hello-world.js  y  conecte su Arduino  a un puerto USB en su ordenador  si aún no está conectado.

En una terminal  de windows  vaya al directorio del proyecto y ejecute este comando:

<node hello-world.js


Verá una salida como la siguiente en su terminal ejecutando hello-world.js en una terminal

 

 

Si el LED incorporado parpadea ,!enhorabuena !  !acaba de controlar una placa Arduino con JavaScript!  ¿a que es realmente sencillo?.

Aunque en el caso de la familia Arduino tiene la innegable penalización de necesitar un host para operar , la ventajas de este  modelo son evidentes pues no tenemos que estar constantemente compilando  y  subiendo el sketch con el ide de Arduino ya que el programa corre en host . Ademas  podemos usar un simple editor de texto para cambiar el código en javascript fácilmente

Asimismo el lenguaje javascript ha ido evolucionando hasta un ritmo que no podemos imaginar   incluyendo muchas características que no son soportadas de forma directa desde Arduino

Por ultimo mencionar la autentica potabilidad del código , pues el código que hemos visto en el ejemplo podremos usarlos  en múltiples plataformas  tan diferentes como Raspberry pi, Intel Edison , etc usando siempre el mismo código fuente aun siendo soportado por placas muy diferentes ¿ a que es interesante?

 

 

Placas soportadas

Johnny-Five ha sido probado con una variedad de tableros compatibles con Arduino . 

Para los proyectos que no están basados ​​en Arduino, los complementos de IO específicos de la plataforma están disponibles. Los complementos IO permiten que el código Johnny-Five se comunique con cualquier hardware en cualquier idioma que la plataforma hable.

Como comentábamos   existen diferentes  formas de   ejecutar  el programa Johnny-Five  segun la placa:

  • En un entorno Linux a bordo: beagleBone Black,Chip,Intel Galileo gen 1,Intel Galileo Gen 2,Intel Edison Arduino,Intel Edison Mini, SparkFun Edison GPIO Block,SparkFun Arduino Block, Intel Joule 570x (Carrier Board),Linino One,pcDuino3 Dev Board,Raspberry Pi 3 Model B, Raspberry Pi 2 Model B. Raspberry Pi Zero,Raspberry Pi Model A Plus,Raspberry Pi Model B Plus, Raspberry Pi Model B Rev 1, Raspberry Pi Model B Rev 2, Tessel 2) ,   Es  facil adivinar qeu este es el mabiente ideal   pues dentro de la placa se oprtan tanto el host como el cliente  por lo qeu no ncesitamos conectarnos con otro dispositivo
  • En una máquina host conectada (a través de Serial USB o Ethernet) a un cliente.: Arduino Uno,SparkFun RedBoard, On a host machine communicating over Bluetooth to the client. Arduino Uno,Arduino Leonardo, Arduino Mega, Arduino Fio,Arduino Micro,Arduino Mini,arduino Nano,Arduino pro Mini,Boatduino,chipKit uno32,Spider robot Controller,DfRobot Romeo,Teensy 3,
  • En una máquina host que se comunica por wifi al cliente.: Electric Imp April, pinoccio Scout, Particle Core ( Spark Core) ,Particle Photon, Sparkfun Photon RedBoard
  • En una máquina host que se comunica a través de Bluetooth al cliente :Blend Micro v1.0,LightBlue bean,

Veamos  ahora cada  caso en concreto;

Arduino Uno 

Ambiente 

  • Firmware / Runtime: : StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

SparkFun RedBoard 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

ping

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

 

Arduino leonardo 

Ambiente 

  • Firmware / Runtime:  StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

Arduino Mega 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
ping

Arduino Fio 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

Arduino Micro 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

  • Admite la extensión PING_READ , cuando se usa con PingFirmata .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
One wire no
Paso a paso no
Serial / UART
Dac no
Ping

Arduino Mini 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

  • Admite la extensión PING_READ , cuando se usa con PingFirmata .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
One wire no
Paso a paso no
Serial / UART
Dac no
Ping

Arduino Nano 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus (additional instructions)
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

  • Admite la extensión PING_READ , cuando se usa con PingFirmata .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
Ping

Arduino Pro Mini 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

  • Admite la extensión PING_READ , cuando se usa con PingFirmata .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
One wire no
Paso a paso no
Serial / UART
Dac no
ping

BotBoarduino 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere amarre.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
ping

chipkit uno32 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere tethering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
One wire
Paso a paso
Serial / UART
Dac no
ping

Spider Robot Controller 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere  tetehering.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
ping

DFRobot Romeo 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere amarre.

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART
Dac no
Ping

Teensy 3 

Ambiente 

  • Firmware / Runtime: StandardFirmataPlus ( instrucciones adicionales )
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a la placa a través de una serie USB , que actúa como un cliente ligero .Requiere amarre.
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART no
Dac no
ping

BeagleBone Black 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

CHIP 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo no
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Ping no

Blend Micro v1.0 

Ambiente 

  • Complemento IO: BlendMicro-IO ( instrucciones adicionales )
  • Firmware / Runtime: BLEFirmata
  • El programa JavaScript se ejecuta en una máquina host que ejecuta Node.js. El programa transmite instrucciones básicas de E / S a través de Bluetooth a la placa, que actúa como un cliente ligero .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Ping no

 Electric Imp  April 

Ambiente 

Plataforma específica 

  • Requiere una conexión WiFi conectada a Internet y está sujeto a la limitación de la tasa de solicitud por parte del servidor de Electric Imp API.
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C no
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Intel Galileo Gen 1 

Ambiente 

Plataforma específica 

  • Las compilaciones que no son IoTKit ya no son compatibles.
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Intel Galileo Gen 2 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Silbido no

Intel Edison Arduino 

Ambiente 

Plataforma específica 

  • El hardware es capaz de soportar solo 4 salidas PWM. Como resultado, los enlaces nativos no admiten PWM en los pines 10 y 11.
  • Aunque Galileo-io / Edison-io / Joule-io todavía no admite comunicaciones en serie, puede enlazar a / dev / ttyFMD1 en la placa Edison Arduino usando el módulo serialport .
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Silbido no

Intel Edison Mini 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
Silbido no

SparkFun Edison GPIO Block 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

SparkFun Arduino Block

Ambiente 

Plataforma específica 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable
Paso a paso
Serial / UART no
Dac no
ping no

Intel Joule 570x (Carrier Board) 

Ambiente 

Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

LightBlue Bean

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Linino uno 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

pcDuino3 Dev Board 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo no
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Pinoccio Scout 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C no
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping no

Raspberry Pi 3 Modelo B 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
ping no

Raspberry Pi 2 Modelo B 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
Silbido no

Raspberry Pi Zero 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
ping no

Raspberry Pi Model A Plus 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
ping no

Frambuesa Pi Modelo B Plus 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
Silbido no

Raspberry Pi Modelo B Rev 1 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
Ping no

Raspberry Pi Modelo B Rev 2 

Ambiente 

Plataforma específica 

  • analogRead componentes analogRead pueden analogRead a través de instancias de Expander . Ver Expander API para ejemplos.
Lectura analógica no
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac no
ping no


Particle Core (Spark Core)

Ambiente 

Plataforma específica 

  • Los temporizadores se comparten en grupos: Temporizador 2: A0 , A1 , Temporizador 3: A4 , A5 , A6 , A7 , Temporizador 4: D0 , D1
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping


Particle Photon

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
ping no
Silbido

Sparkfun Photon RedBoard 

Ambiente 

Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART no
Dac no
ping

Tessel 2 

Ambiente 

Plataforma específica 

  • El soporte de servo se proporciona a través de componentes I2C (por ejemplo, PCA9685 )
  • DAC está limitado a Puerto B, Pin 7
Lectura analógica
Lectura digital
Escritura digital
PWM
Servo
I2C
Un cable no
Paso a paso no
Serial / UART
Dac
ping no

Mas información en  http://johnny-five.io/platform-support/

Anuncios

Error splicing file:file too large


En efecto en un ordenador con sistema operativo Linux  en cualquier de sus variantes como Ubuntu, Lubuntu ,Fedora, etc.  puede  que copiando archivos  grandes hacia una unidad extraible USB termine dando error con el típico mensaje   “Error splicing file:file too large“.

Afortunadamente entender el motivo  del error es sencillo ,pues generalmente el problema se debe a que el disco de destino (es decir en la unidad extraible en el que desea copiar el archivo) está formateado con el sistema de fichero FAT32 , el cual  tiene un límite de tamaño de archivo de aproximadamente 4GB, por lo que efectivamente Linux cuando intenta copiar sobre una unidad destino formateada en fat32 el so. empieza copiando hasta que llega  aproximadamente a los 4GB , momento en el cual no puede continuar, pues el sistema de ficheros no lo permite, terminando dando error y abortándose la copia.

Curiosamente según el tipo de fichero que sea ,es posible que incluso abortando la copia con el mensaje Error splicing file:file too large , en caso de copias de ficheros de vídeo ( por ejemplo en formato mkv) , a pesar de esto, incluso con el error puedan ser reproducibles parcialmente ( es decir, sin poder reproducirse hasta su totalidad).

Afortunadamente para resolver este problema, la solución es bien sencilla pues bastara en volver a  formatear su disco de destino a EXT3, EXT4 o NTFS.

Mientras que FAT, FAT32 y exFAT se utilizan en memorias USB y tarjetas SD , NTFS es   utilizado sobre todo por discos duros, lo cual no significa  que ntfs no  deba usarse también en unidades extraibles USB: todo lo contrario ,pues por las razones que vamos a ver , ntfs tambien deberia ser  la mejor opción para unidades  extraibles usb.

NTFS (New Technology File System) es el sistema de archivos que Windows utiliza por defecto,  (de hecho windows sólo puede ser instalado en una unidad con este sistema),Su adaptación no es casual pues , ntfs  conlleva  múltiples ventajas:

  • Como hemos comentado su límite de tamaño de archivos es de 16 TB,  ( los volúmenes pueden llegar a tener 264 TB cada uno)
  • Se pueden configurar los permisos de acceso a un archivo (vital para un sistema operativo).
  • Permite cifrar archivos.
  • Permite nombres de archivos largos.
  • Se recupera más fácilmente de errores si el ordenador se cuelga

Vemos pues para soslayar el problema “Error splicing file:file too large”  y la unidad destino esta formateada en otro formato ,  tendremos  que  formatear en NTFS  pues así no habrá problemas  a  la hora de copiar estos ficheros.

 

FORMATEO DESDE WINDOWS

En realidad formatear en NTFS un unidad USB con Windows 10 es muy fácil:

  • Pinche con el botón DERECHO del ratón en el menú Inicio de Windows y elige Explorador de archivos.
  • En la ventana que se abre haga clic a la izquierda en Este equipo.
  • A la derecha verá las unidades de disco duro, particiones, discos o pendrives USB o CD/DVD que tenga tu PC. Seleccione la unidad que quiere formatear pinchando en ella con el botón izquierdo. Luego haz clic encima con el botón DERECHO y elige Formatear. (!IMPORTANTE !: -Es obvio que debe elegir con mucho cuidado la unidad pues formatearla borrará por completo todo lo que haya en ella.
  • Al elegir la opción de formateo se abre su ventana de propiedades.Defina así las opciones siguientes que incluye:
      • Sistema de archivos:Pincha en la lista desplegable de abajo y elija  NTFS.
      • Tamaño de unidad de asignación. Lo normal es que deba mantener el tamaño que te indique por defecto la ventana de formateo.
      • Etiqueta del volumen :Escriba un nombre que describa lo que hay o habrá en ese disco o USB. No es una opción obligatoria pero sí recomendable.
      • Opciones de formato:Desactive la casilla de Formato rápido haciendo clic en ella. Así obligara a que Windows chequee el disco o USB e intente reparar de forma automática posibles errores que tenga por lo que puede ahorrarle problemas futuros o hasta pérdidas de datos. Por cierto mantener el formato rápido acelera el proceso pero se salta la comprobación del disco o USB.
  • Finalmente pulse Iniciar cuando acabes de configurar esas opciones. Confirme con Aceptar el aviso de que se borrará todo lo que haya en esa unidad.
  • El formateo tardara más o menos dependiendo del tamaño de la unidad seleccionada, la velocidad de su PC y si ha elegido o no la opción rápida. Acepte y cierra la ventana cuando termine.

 

FORMATEO DESDE LINUX

Ahora veremos como  soslayar el problema ” Error splicing file:file too large”  y la unidad destino esta formateada en otro formato ,   formateando  en NTFS  desde el propio Linux  para que no haya problemas  a  la hora de copiar ficheros de mas de 4GB

Lo primero que tenemos que tener claro a la hora de formatear una unidad es la ruta en la que se encuentra en el sistema.

Para ver que dispositivo es el que vamos a usar escribimos en Terminal (Abrir Terminal presionando Ctrl + Alt + T) :

Para eso, solo tendremos que escribir en el Terminal el comando:

df

Este comando nos mostrará todos las particiones y discos que tiene actualmente el ordenador conectados al sistema. Como podremos observar, los sistemas basados en Ubuntu 16.04 asignan cómo nombre de partición de la siguiente forma sdaX donde la X es un número de partición, por lo que si tenemos una unidad USB  conectado , el nombre será muy similar a sdaX ( por e ejemplo sdb3).

Una vez hayamos encontrado la memoria USB desde el terminal, tenemos que desmontarlo del sistema para que podamos formatearlo. Para realizar esta tarea tendremos que ejecutar el siguiente comando:

sudo umount /dev/sdb3

Ahora ya lo tenemos preparado para formatear. Por lo que tendremos que escribir la siguiente línea de código en el terminal.

sudo mkfs.vfat -F 32 -n "Nombre_pendrive" /dev/sdb3

Quizá no entiendas nada de lo que hemos puesto en esa parte de código, pero aquí estamos para resolver estas dudas:

  • mkfs.vfat: Es el programa de ejecución de la herramienta del terminal para formatear unidades del sistema.

  • -F 32: Esto le indica al sistema que el formato ha de realizarse con el sistema de archivos de Fat32.

  • -n “Nombre_pendrive”: Este será el nombre que aparecerá cada vez que conectemos el USB al ordenador.

  • /dev/sdb3: Esta tiene que ser la ruta completa donde se sitúa la memoria USB que queremos formatear.

 

Es posible formatear   en diferentes formatos:

  • Formatear USB con Extended File System (Ext) :Este es el sistema de archivos preferido por Linux.

<pre “>

sudo mkfs.ext4 /dev/sdb3

  • Formatear USB con FAT (File Allocation Table) 
 sudo mkfs.vfat /dev/sdb3 
  • Formato de formato USB con NTFS (Sistema de archivos de nueva tecnología)
 sudo mkfs.ntfs /dev/sdb3 

Por ultimo, salimos de Terminal con:

exit

Esta es la salida de la ejecución de estos comandos:

[email protected]:~$ df
Filesystem 1K-blocks Used Available Use% Mounted on
udev 214372 0 214372 0% /dev
tmpfs 47028 2948 44080 7% /run
/dev/sda1 38192692 11567744 24655132 32% /
tmpfs 235132 0 235132 0% /dev/shm
tmpfs 5120 4 5116 1% /run/lock
tmpfs 235132 0 235132 0% /sys/fs/cgroup
tmpfs 47024 12 47012 1% /run/user/1000
/dev/sdb1 15108880 41156 15067724 1% /media/carlos/KINGSTON16G

[email protected]:~$ sudo umount /dev/sdb1
[sudo] password for carlos:

[email protected]:~$ sudo mkfs.ntfs /dev/sdb1
Cluster size has been automatically set to 4096 bytes.
Initializing device with zeroes: 41%100% – Done.
Creating NTFS volume structures.
mkntfs completed successfully. Have a nice day.
[email protected]:~$

 

No esta de mas recordar que debe cambiar la identificación del dispositivo USB en los comandos anteriores o desde el interfaz grafico ,En el  ejemplo en un viejo portatil hp con Lubuntu se ha usado sdb3 , pero no necesariamente sera el mismo identificador que tengan sus unidades.

Como puedes observar, es un proceso muy sencillo pero tiene las complicaciones de saber que es lo que hace cada cosa y cual es la dirección correcta que queremos formatear, ya que si nos equivocamos puede ser fatal para nuestro sistema operativo.

 

 

 

Conversión de Raspberry Pi en Google Home


Gracias a que se  liberó el SDK del Google Assistant , ya se  puede usar Google Home en  Español entre otros nuevos idiomas  con cualquier hw que los permita ! Así que ahora es posible montar nuestro propio Google Assistant en una Raspberry Pi, en pocos minutos, con un micrófono y un altavoz, tendrá a una Raspberry Pi lista para atender sus peticiones!

Ideal para ponerla en el salón o cualquier sitio escondida, con un buen micrófono omnidireccional, podremos hacerle consultas en nuestro propio idioma y medianamente nos las esquivará correctamente , Por cierto a parte del Español, también soporta Inglés, Alemán, Francés, Italiano y Japonés. 

El proyecto se llama AIY que resulta de la mezcla de AI (inteligencia artificial en sus siglas en inglés, Artificial Intelligence) y DIY (hazlo tú mismo, en sus siglas en inglés, Do it Yourself).

Echemos un vistazo a lo que necesitamos .

  • Raspberry Pi 3  con fuente de alimentación y tarjeta MicroSD
  • Micrófono USB. Se puede  utilizar el micrófono incluido en algunas cámaras web para las pruebas. La gran ventaja del mini micrófono es la potabilidad del prototipo pero cualquier producto similar hará el trabajo de forma satisfactoria.
  • Altavoces con entrada de audio de 3,5 mm  Aunque inclusive unos auriculares de cable son más que suficiente para realizar las pruebas, idealmente podremos contar con algún tipo de altavoz equipado con conector de 3.5mm para obtener una mejor experiencia de usuario
  • Ratón y teclado USB

 

Instalando el SO

Para instalar el software necesitamos nueva imagen descargada a partir del sitio  oficial Raspbian ,y flashearla en la microSD con un ordenador:

 

raspbian

 

Una vez descargada y descomprimida  la imagen correspondiente  en su ordenador siga los siguientes pasos:

  • Inserte la tarjeta SD en el lector de tarjetas SD  de su ordenador comprobando cual es la letra de unidad asignada. Se puede ver fácilmente la letra de la unidad, tal como G :, mirando en la columna izquierda del Explorador de Windows.
  • Puede utilizar la ranura para tarjetas SD, si usted tiene uno, o un adaptador SD barato en un puerto USB.
  • Descargar la utilidad Win32DiskImager desde la página del proyecto en SourceForge como un archivo zip; puede ejecutar esto desde una unidad USB.
  • Extraer el ejecutable desde el archivo zip y ejecutar la utilidad Win32DiskImager; puede que tenga que ejecutar esto como administrador. Haga clic derecho en el archivo y seleccione Ejecutar como administrador.
  • Seleccione el archivo de imagen que ha extraído anteriormente de Raspbian.
  • Seleccione la letra de la unidad de la tarjeta SD en la caja del dispositivo. Tenga cuidado de seleccionar la unidad correcta; si usted consigue el incorrecto puede destruir los datos en el disco duro de su ordenador! Si está utilizando una ranura para tarjetas SD en su ordenador y no puede ver la unidad en la ventana Win32DiskImager, intente utilizar un adaptador SD externa.
  • Haga clic en Escribir y esperar a que la escritura se complete.
  • Salir del administrador de archivos  y expulsar la tarjeta SD.
  • Ya puede insertar la SD en su Raspberry Pi en el adaptador de micro-sd , conectar un monitor por el hdmi , conectar un teclado y ratón en los  conectores USB, conectar la  con un cable ethernet  al router  conectividad a Internet y finalmente conectar la alimentación  para comprobar que la Raspeberry arranca con la nueva imagen

 

Cuando acabamos de flashear la tarjeta la colocamos en la Raspi y ya podemos empezar. Para arrancar la Raspberry Pi 3 con el Voice Kit vamos a necesitar un monitor con cable HDMI y un teclado con ratón. Conectamos todo y le damos energía a la Raspi.

El primer inicio del sistema puede tardar varios minutos. El sistema que corre en la Raspberry Pi es una versión de Debian modificada especialmente para este dispositivo y que se llama Raspbian. Debian es una de las distribuciones más extendidas de GNU/Linux y en la que se basan distribuciones tan famosas como Ubuntu.

Una vez tengamos el escritorio activo, arriba a la derecha vamos a poder conectarnos a nuestra red Wi-Fi entre los símbolos del Bluetooth y del volumen. 

Respecto al micrófono usb

Dado el precio y el tamaño, se necesita  un micrófono funcional que sea capaz de captar voces cercanas o grandes sonidos pero   sin gastarse una fortuna  requiriéndose  un micrófono  usb  que sea  reconocido y funcione con Raspbian en una Raspberry Pi3( por  ejemplo el modelo  RRunzfon de kinobo)

Este tipo de micrófonos no son de alta fidelidad de modo que cuando escuche las reproducciones está claro que hay mucha estática a menos que esté hablando directamente con el micrófono, pero para este proyecto  lo importante es que sea  capaz de funcionar para el reconocimiento de voz utilizando la compilación Alexa Raspberry Pi.

Es interesante instalar la activación “siempre encendida” para no tener que presionar un botón para activarla, y pero dadas  las características de este modesto micrófono  solo  funcionara   si está cerca de este

Dado el tamaño y el precio, esta es una de las maneras más fáciles de agregar un micrófono por menos de $ 10, pero si está esperando un audio de alta calidad, es mejor que busque otras opcion. Para aquellos que buscan un micrófono decente para uso diario, existen mejores opciones en cuanto a calidad de sonido. (lo que hace que este micrófono sea genial es lo pequeño y económico que es)

Para las personas que buscan probar Google Assistant  con  Raspberry Pi, este micrófonono funciona con RPI v1, pero sí funciona con RPI v3 de fábrica. Cuando lo conecta al puerto USB, se detecta automáticamente y puede verlo en la salida “arecord -l“.

Bajo el sistema operativo Linux, parece que el sonido grabado es un poco bajo. Es posible que necesite normalizar (aumentar la ganancia) en el sonido usando un programa como mp3gain, ffmpeg, sox, etc. o mejor aún aumentar la ganancia en el receptor usando pulseaudio. Si eleva el volumen a un nivel alto, obtendrá una gran cantidad de estática, que es de esperar.

 

 

 

 

Prueba de sonido

Usaremos una Raspberry Pi 3 con Raspbian instalado y actualizado, lo primero será verificar que el audio nos funciona bien, tanto el del micrófono como los altavoces por donde queremos sacar el sonido ,para ello editamos nuestro fichero de configuración de audio ‘~/.asound’ y especificamos el micrófono que estamos usando, en este caso un USB específico, pero también podríamos usar el micro de una webcam, así como el audio que me lo saque por la predeterminada

Antes de continuar pues  debemos configurar el sistema de audio en la Raspberry Pi.

  1. Encontrar los dispositivos de grabación y reproducción.

    1. Coloque el micrófono USB en la lista de dispositivos de hardware de captura. Anote el número de tarjeta y el número de dispositivo.

      arecord -l
    2. Coloque el altavoz en la lista de dispositivos de hardware de reproducción. Anote el número de tarjeta y el número de dispositivo. Tenga en cuenta que el conector de 3,5 mm se etiqueta típicamente o (no). Analogbcm2835 ALSAbcm2835 IEC958/HDMI

      aplay -l
  2. Crear un nuevo archivo llamado .asoundrec  en el directorio home(/home/pi). Asegúrese de que tiene las definiciones de derecho esclavo para micrófono y altavoz; Utilice la configuración  a continuación pero cambie <card number><device number>  con el número que anotó en el paso anterior. Hacer esto para ambos y..asoundrc/home/pi<card number><device number>pcm.micpcm.speaker

    pcm.!default {
      type asym
      capture
    .pcm "mic"
      playback
    .pcm "speaker"
    }
    pcm
    .mic {
      type plug
      slave
    {
        pcm
    "hw:<card number>,<device number>"
     
    }
    }
    pcm
    .speaker {
      type plug
      slave
    {
        pcm
    "hw:<card number>,<device number>"
     
    }
    }
  3. Verificar esa grabación y la reproducción del ejemplo:

    1. Ajustar el volumen de reproducción.

      alsamixer

      Pulse la tecla de flecha hacia arriba para ajustar el volumen de reproducción nivel a alrededor de 70.

    2. Reproducir un sonido de prueba (se trata de una persona que habla). Presione Ctrl + C al hecho. Si no se oye nada cuando se ejecuta esto, Compruebe la conexión del altavoz.

      speaker-test -t wav
    3. Grabar un clip audio corto.

      arecord --format=S16_LE --duration=5 --rate=16000 --file-type=raw out.raw
    4. Compruebe la grabación por reproducirlo. Si no se oye nada, puede que necesite registrar el volumen de grabación. alsamixer

      aplay --format=S16_LE --rate=16000 out.raw

    Si están trabajando la grabación y reproducción, ya se ha configurado el  audio. Si no es así, verifique que el micrófono y el altavoz están correctamente conectados. Si no es el problema, intente un diferentes micrófono o altavoz.

    Tenga en cuenta que si tiene un monitor HDMI y un altavoz de jack de 3,5 mm conectado, usted puede reproducir audio por  cualquiera de los dos. Ejecute el siguiente comando:

    sudo raspi-config

    Ir a Opciones avanzadas > Audio y seleccione el dispositivo de salida deseada.

 

Activación servicio

Para activar el servicio nos iremos  a la consola de las Acciones de Google, nos validaremos con una cuenta de Google válida y crearemos un nuevo proyecto de Google Cloud Platform,.Con la API de Google Assistant instalada en nuestra Raspberry accederemos para realizar consultas y el proyecto nos mostrará los datos sobre los consumos.

En primer lugar nos iremos  a la consola de las Acciones de Google, en https://console.actions.google.com, deberemos validarnos con una cuenta de Google válida y crear un nuevo proyecto de Google Cloud Platform, para ello pulsamos en “Add/Import project”

Si no tiene ningún proyecto creado, nos aparece una ventana para  aceptar las condiciones de servicio. Es importante en este punto no olvidar  si queremos cambiar el idioma a español   para las Acciones  así como  seleccionar nuestro País, 

 

Tenemos que tener en cuenta  que el máximo de proyectos gratuitos es 3 ,por lo que  no podremos añadir nuevos, así que una opción es eliminar proyectos antiguos o incluso seleccionar alguno de estos proyectos antiguos de Google App Engine  como origen  de automatización ( ese es el caso de nuestro ejemplo “soloelectronicossalva”)

En caso de no tener ningún proyecto en la nube de Google ,deberemos  indicar el nombre del Proyecto (recordar que  aparecerá un combo si tiene ya varios proyectos creados)

Ahora tenemos que habilitar la API de Google Assistant API para nuestro proyecto , por lo que nos iremso a  https://console.developers.google.com/apis/api/embeddedassistant.googleapis.com/overview y daremos al boton de Habilitar . Si no estamos situados en nuestro proyecto  seleccionamos del combo nuestro proyecto y pulsamos en “Habilitar”,(API > Enable API > Google Assistant > Enable)

 

Y al pulsar el botón  quedara habilitado el API  de Google Assistant para nuestro proyecto

 

 

Observe que no es completamente gratuito, estando limitado a 500 peticiones al día  con un máximo de 60 peticiones/minuto , aspectos que podemos estudiar en el menú  de Cuotas

Ahora ya podríamos ir a registrar nuestro dispositivo! Vamos de nuevo a la Consola, en https://console.actions.google.com/
Ir a “Device registration” > “Register Model” y lo crearíamos

 

En caso de haber importado un proyecto que ya teníamos, el proceso es diferente, pues repetiremos las dos opciones primeras de Add/Import  , pero esta vez en el menú que nos aparece seleccionaremos  Device registration” > “Register Model” y lo creariamos (la url seria del tipo https://console.actions.google.com/u/0/project/proyecto_importado/deviceregistration/)

 

 

En ambos casos, llegado a este punto, pulsaremos al botón   “Device registration

 

 

 

Tendremos que ponerle un nombre o ‘Product Name’ (que anotaremos), un nombre del fabricante o ‘Manufacter Name’  y seleccionamos si queremos algún tipo de dispositivo, que en nuestro caso al ser una raspberry Pi 3 lo dejaremos en ‘Auto’, pulsamos en “Register Model”,

 

 

 

 

Nos toca ahora descargar el fichero con los credenciales de acceso al servicio de Google Assistant, pulsamos en “Download OAuth 2.0 credentials” y los guardamos en una ruta de nuestro ordenador que nos sea fácil de recordar

Ahora   copiaremos   dichos archivo  a la Raspberry Pi  en la ruta  /home/pi,

 

 

En este ultimo paso , es interesante las opciones que nos ofrece:

  • Brillo: Este rasgo cubre cómo controlar el brillo de un dispositivo. La configuración de brillo absoluto se encuentra en un rango normalizado de 0 a 100 (las luces individuales pueden no ser compatibles con todos los puntos del rango según su configuración de LED). 
  • ColorSpectrum Este rasgo pertenece a cualquier dispositivo que pueda establecer un espectro de color. Esto se aplica a las bombillas de color “completas” que toman rangos de color RGB. Las luces pueden tener cualquier combinación de ColorSpectrum y ColorTemperature, las luces de acento y las tiras de LED solo pueden tener Spectrum, mientras que algunas bombillas de lectura solo tienen Temperatura. Las bombillas básicas, o luces tontas en enchufes inteligentes, no tienen ninguno.
  • Temperatura del color: Este rasgo pertenece a cualquier dispositivo que pueda ajustar la temperatura del color. Esto se aplica a las bombillas de “calor” que tienen un punto de color en Kelvin. Esta es generalmente una modalidad separada de ColorSpectrum, y es posible que haya puntos blancos disponibles a través de la temperatura que Spectrum no pueda alcanzar. Según los rasgos disponibles, Google puede elegir el modo apropiado para usar según la solicitud y el tipo de luz (por ejemplo, si las luces de la sala de estar están en blanco podrían enviar comandos de temperatura a algunas bombillas y comandos de espectro a tiras de LED).
  • Muelle: Este rasgo está diseñado para dispositivos auto-móviles que pueden ser ordenados a regresar para la carga. En general, estas son aspiradoras robóticas actualmente, pero esto también se aplicaría a algunos drones, robots de entrega y otros dispositivos futuros. 
  • Encendido apagado :La funcionalidad básica de encendido y apagado para cualquier dispositivo que tenga activado y desactivado el binario, incluidos enchufes e interruptores, así como muchos dispositivos futuros. Tenga en cuenta que los termostatos tienen una configuración de ‘modo’ expandida, que es un interruptor de múltiples vías que incluye encendido y apagado, pero los termostatos generalmente no tienen esta característica. 
  • StartStop :Este rasgo cubre iniciar y detener el dispositivo. Iniciar y detener un dispositivo cumple una función similar para encenderlo y apagarlo. Los dispositivos que heredan este rasgo funcionan de manera diferente cuando se encienden y cuando se inician. Algunas lavadoras, por ejemplo, pueden encenderse y modificar sus configuraciones antes de comenzar a operar.
  • Ajuste de temperatura : Este rasgo cubre el manejo tanto del punto de temperatura como de los modos. 

Para  nuestro ejemplo no seleccionaremos ninguna de esta opciones por el momento y pulsaremos  “SaveTraits

 

Nos debe aparece ahora  al entrada    con la configuración definida:

 

 

Si pinchamos en la entrada  podemos cambiar algunos de los parámetros ya definidos ( no olvidar darle al botón de “save“) 

 

 

 

 

Grabamos el dispositivo que acabamos de registrar, pulsando en “SAVE”,

 

 

Configruacion de la Raspberry Pi

 

Bien, ahora en la Raspberry Pi configuraremos el entorno virtual de Python para aislar el SDK y sus dependencias de los paquetes Python del sistema, nos escogemos la opción de Python 3:

sudo apt-get install python-dev python-virtualenv

virtualenv env –no-site-packages

env/bin/python -m pip install –upgrade pip setuptools wheel

source env/bin/activate

Instalamos las dependencias necesarias además de  Google Assistant SDK que nos permitirá tener Google Assistant corriendo en la Raspberry Pi:

sudo apt-get install portaudio19-dev libffi-dev libssl-dev libmpg123-dev


Mediante pip instalamos la última versión de Python en el entorno virtual:

python -m pip install --upgrade google-assistant-sdk[samples]

Instalamos o actualizamos la herramienta de autorización:

python -m pip install --upgrade google-auth-oauthlib[tool]

 

Ahora generamos los credenciales para ejecutar los ejemplos, usaremos el fichero JSON que nos hemos descargado previamente:

google-oauthlib-tool –scope 

https://www.googleapis.com/auth/assistant-sdk-prototype –scope

 https://www.googleapis.com/auth/gcm –save –headless –client-

secrets /home/pi/client_secret_xxxx.apps.googleusercontent.com.json

 

 

Si todo es correcto, nos pondrá algo como:

Please visit this URL to authorize this application: https://..."
 

Copiamos la URL y vamos a ella con un navegador que esté validado con nuestra cuenta de Google. Tras permitir el acceso o nos dará un código de autenticación que debemos pegar en la shell.

Y ahora, ya estamos listos para probar un ejemplo!

En el mismo entorno virtual, ejecutamos el siguiente comando indicando nuestro ID de Proyecto y nuestro ID de modelo, En caso de no haber  anotando estos datos , ambos estan  en la Consola de Actions de Google buscando en las opciones generales del proyecto y del dispositivo.

Si esta todo OK ejecutamos el siguiente comando y quedará listo para que hablemos con el Assistantar:

 

  googlesamples-assistant-hotword --project_id entrada-txarlatana --device_model_id entrada-txarlatana-entrada-xxxx

 

Por cierto, para cambiar el idioma de nuestro Asistente, lo haremos directamente con nuestro teléfono móvil, con la app del Assistant que supongo la tendréis instalada (y si no os la instaláis :P, la abrís, pulsamos arriba en la brújula, y en la siguiente pantalla en Explorar debemos ir a “Ajustes”,

En Ajustes debemos buscar en Dispositivos el dispositivo que hemos registrado antes, lo seleccionamos, y ahí ya le podremos dar acceso a más datos nuestros a los señores de Google o seleccionar el idioma que queremos para interactuar con el Assistant!

 

 

MEJORA DEL MICRÓFONO 

Finalmente, dependiendo de la calidad de tu micrófono, notará que tiene algunos problemas a la hora de escucharle. En lugar de gritar  cada vez que quiera usarlo, lo que haremos será regular el micrófono mediante la línea de comandos una vez más.

  • Introduzca  en la termina ssh  el siguiente comando:
     alsaixer
  • Pulsee F6 para seleccionar un USB diferente. Use, las flechas para seleccionar tu micrófono.
  • Usa las flechas para aumentar el volumen de captura.
  • Cuando esté satisfecho con el volumen, pulse  ESC para salir.
  • Escriba el siguiente comando para hacer permanentes los cambios.
     sudo alsactl store

Ahora será capaz de comunicarte con su Echo casero hablando de manera normal   en lugar de gritando. Desde esta misma pantalla también se puede cambiar el volumen por defecto si lo necesitara.

 

Tenemos el servicio montado bajo una Raspberry Pi, si volvemos a ejecutar el ejemplo anterior estará el Asistente en nuestro idioma pero  tendremos que constantemente pulsar Enter o decir ‘OK, Google’ independientemente de los ejemplos que tenemos para interactuar.

Si no nos  interesa que el micrófono esté siempre escuchando y así también evitar la necesidad de decir ‘OK Google’ todo el rato, mediante un script  en c-shell   podemos   iniciar  o detener el Assistant

google_assistant_para.sh

cd /home/pi/

source env/bin/activate

nc -l 12345 | /home/pi/env/bin/python3 /home/pi/env/bin/googlesamples-assistant-pushtotalk –project-id txarlatana –device-model-id txarlatana-pitxarlatana-xxxx &

 

google_assistant_para.sh

pkill python3

pkill google

pkill nc

 

 

Mas información en  https://developers.google.com/assistant/sdk/guides/library/python/

 

 

 

 

 

 

 

Shell script: programas externos, E/S y dirección de shell


Bash , c-shell  o simplemente shell scripting es  un lenguaje de script  creado a fines de la década de 1980 por un programador llamado Brian Fox, que trabajaba para la Free Software Foundation . Fue pensado como una alternativa de software libre para el shell Bourne (de hecho, su nombre es un acrónimo de Bourne Again SHell ), e incorpora todas las características de ese shell, así como nuevas características como la aritmética de enteros y el control de trabajo

Bash es un “shell de Unix”, es decir  una interfaz de línea de comandos para interactuar con el sistema operativo por lo que está ampliamente disponible, siendo el shell predeterminado en muchas distribuciones de GNU / Linux y en Mac OSX, con puertos existentes para muchos otros sistemas.

En post anteriores hemos hablado en una primera aproximación  al lenguaje c-sheall  con el primer ejemplo famoso de  Hello world y avanzando comandos ,tuberías ,variables ,parámetros y salidas posibles y en un segundo post  sobre el  uso de las Tuberías , sustitución de comandos,operadores ,asignación de variables ,Bucles , literales , variables   y aritmética no entera

Asimismo   en un  post  anterior continuamos  avanzando en el conocimiento de este lenguaje con el uso de las funciones, subshells  y las  variables de entorno

En esta ocasión vamos a ver el uso de funciones de shell, funciones de e/s y la redirección shell

close up code coding computer

 

 

 

Funciones de shell 

Programas externos

Bash, como un shell, es en realidad un lenguaje de “pegamento”. Ayuda a los programas a cooperar entre sí, y se beneficia de ello. Siempre busque en Internet lo que desea: hay muchas utilidades de línea de comandos disponibles.

Usando whiptail 

Whiptail es un programa que permite que los scripts de shell muestren cuadros de diálogo al usuario con fines informativos, o para obtener información del usuario de manera amigable. Whiptail se incluye de forma predeterminada en Debian y en varias otras distribuciones de GNU / Linux.

Desde el diccionario GNU / Linux : whiptail es un reemplazo de “diálogo” que usa newt en lugar de ncurses.
Desde su README: whiptail está diseñado para ser compatible con el cuadro de diálogo (1), pero tiene menos funciones: algunos cuadros de diálogo no están implementados, tales como caja de cola, caja de tiempo, caja de calendario, etc.

Usando man, info y ayuda 

Estos tres programas son donde puede encontrar ayuda o referencia de. man muestra las páginas de manual de roff , la información muestra las documentaciones de texinfo, mientras que la ayuda muestra las ayudas integradas.

Al añadir --long-ayuda , --help o --usage a un programa de línea de comandos puede también le da la información de uso. Posibles sinónimos incluyen -H y -h .

Solo prueba estos:

man --help
man man

info --help
man info
info info

help help

Presionar h en las interfaces de man and info también puede darle alguna dirección.

Entrada / Salida

La lectura incorporada 

De la ayuda leída :

read: read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]

Lea una línea de la entrada estándar y divídala en campos. La lectura es excelente tanto para las entradas del usuario como para la lectura de entradas / tuberías estándar.

Un ejemplo de entrada de usuario:

 # 'readline' pronuncie el nombre de la variable predeterminada 
read -e -p "Haga esto:" -i "destruye el  comando " commmand

echo  "$command "

O incluso más simple:

pause ()  {  read -n 1 -p "Presione cualquier tecla para continuar ..."  ;  }

Ejemplo de nivel de Hola-mundo de la operación stdout:

 echo  'Hola mundo!'  | {  read hola
 echo  $hola  }

Solo se creativo. Por ejemplo, en muchos sentidos, leer puede reemplazar el látigo. Aquí hay un ejemplo, extraído del script de shell de Arthur200000 :

# USAGE 
# yes_or_no "title" "text" width ["yes text"] ["no text"] 
# INPUTS 
# $ LINE = (y / n) - Si debemos usar el estilo de entrada basado en líneas (lectura) 
# $ _DEFAULT = (opcional) - El valor predeterminado para leer yes_or_no ()  { 
yes_or_no() {
  if [ "$LINE" == "y" ]; then
    echo -e "\e[1m$1\e[0m"
    echo '$2' | fold -w $4 -s
    while read -e -n 1 -i "$_DEFAULT" -p "Y for ${5:-Yes}, N for ${6:-No}[Y/N]" _yesno; do
      case $_yesno in
        [yY]|1)
          return 0
          ;;
        [nN]|0)
          return 1
          ;;
        *)
          echo -e "\e[1;31mINVALID INPUT\x21\e[0m"
       esac
  else whiptail --title "${1:-Huh?}" --yesno "${2:-Are you sure?}" ${3:-10} ${4:-80}\
         --yes-button "${5:-Yes}" --no-button "$6{:-No}"; return $?
  fi
}
# USAGE  # user_input var_name ["title"] ["prompt"] [altura] [ancho] 
 # ENTRADAS  # $ LINE = (y / n) - Si debemos usar el estilo de entrada basado en líneas (lectura) 
 # $ _DEFAULT = ( opcional) - El valor predeterminado para leer; por defecto a nada. user_input () 
user_input(){
  if [ "$LINE" == "y" ]; then
    echo -e "\e[1m${2:-Please Enter:}\e[0m" | fold -w ${4:-80} -s
    read -e -i "${_DEFAULT}" -p "${3:->}" $1
  else
    eval "$1"=$(whiptail --title "$2" --inputbox "$3" 3>&1 1>&2 2>&3)
  fi
}
 

Redirección de shell 

En shells, la redirección se usa para la E / S de archivos. El uso más común de es redirigir secuencias estándar (stdin, stdout y stderr) para aceptar la entrada de otro programa a través de tuberías, para guardar la salida del programa como un archivo, y para suprimir la salida del programa redireccionando una secuencia a / dev / null .

Índice de símbolos 

Símbolo Explicación
!
  • Lógicamente niega el estado de salida de una tubería. Por ejemplo, si grep YES votes.txt devuelve 0 , entonces ! grep YES votes.txt devuelve 1 , pero de lo contrario es equivalente.
  • También soportado por el [...] builtin, y dentro de expresiones condicionales. Por ejemplo, si [[-e file.txt]] es verdadero, entonces [[! -e archivo.txt]] es falso.
  • También se admite en expresiones aritméticas. Por ejemplo, si $ i es distinto de cero, entonces $ ((! I)) es 0 .
  • Vea también #! abajo.
"..."
  • Cita un argumento (o parte de un argumento) para que no esté dividido por espacios en blanco en múltiples argumentos, pero sin impedir la expansión de parámetros y la sustitución de comandos internamente.
  • Véase también $ "..." a continuación.
#
  • Introduce un comentario (que continúa hasta el final de la línea). Por ejemplo, el comando foo bar baz # bip es equivalente al comando foo bar baz , porque el comentario # bip se elimina.
  • Dentro de una expresión aritmética, un literal entero de la forma b # n se interpreta en la base b . Por ejemplo, 2 # 110110 es binario 110110, es decir, cincuenta y cuatro.
  • Vea también #! abajo.
  • Véase también $ # abajo.
#!
  • (Por lo general, ” shebang ” cuando se lee en voz alta). Se usa al comienzo de un script ejecutable para especificar el intérprete que se debe usar para ejecutarlo. Por ejemplo, si la primera línea de script.pl es #! / Usr / bin / perl , y script.pl tiene permisos ejecutables, entonces ./script.pl es aproximadamente equivalente a / usr / bin / perl ./script.pl .
  • La primera línea de un script Bash generalmente es #! / Bin / bash o #! / Bin / sh . (El primero generalmente se considera preferible.)
PS
  • Introduce varios tipos de expansiones, especialmente la expansión de parámetros (como en var o $ { var } ), la sustitución de comandos (como en $ ( comando ) ) y la expansión aritmética (como en $ (( expresión )) ).
PS
  • Una variante de "..." (ver más arriba) que admite la traducción específica del entorno local. (A menos que esté escribiendo scripts para su uso en varios idiomas, por ejemplo, inglés y francés, no debe preocuparse por esto).
PS
  • El número de parámetros posicionales (argumentos de un script o función). Por ejemplo, si se invoca un script como script.sh abc , entonces $ # será 3 . Los elementos incorporados que modifican los parámetros posicionales, como shift y set , también afectan a $ # .
% El operador de módulo. Devuelve el resto resultante de la división entera. Ej. 5% 2 = 1
Y Ampersand Comúnmente se utiliza para iniciar un comando en el fondo. Ej. Firefox &
' Una frase. Se utiliza para citar texto literalmente.
( Paréntesis abiertos. Se utiliza para denotar el comienzo de una subshell, entre otras cosas.
) Paréntesis de cierre. Se utiliza para denotar el “EOF” de una subshell.
* Asterisco. Denota multiplicación. Ej. 5 * 2 = 10
+ Más.Denota la suma. Ej. 5 + 2 = 7
, Coma. Utilizado para la separación. Ej. Archivo ls {1,2,3}
- Guión. Denota la resta. Ej. 5-2 = 3
. Parada completa.
/ Barra inclinada. Indica división entera (por ejemplo, 5/2 = 2) o parte de una ruta (por ejemplo, / home / usuario)
: Colon.
; Punto y coma. Separa las líneas si no existe una nueva línea / EOL. Ej. Echo hola; mundo eco
< Soporte de ángulo abierto. Utilizado para la redirección de entrada
= Signo de igualdad Se utiliza para asignar variables y comprobar la igualdad.
> Ángulo de cierre del soporte. Se utiliza para la redirección de salida.
? Signo de interrogación.
@ A la señal. Normalmente se utiliza como una variable que contiene todos los argumentos pasados ​​al entorno como $ @
El Abra el corchete. Utilizado como una alternativa visualmente más atractiva para probar. Por ejemplo, si [condición]; entonces etc
\ Barra invertida Más comúnmente utilizado para escapar. Por ejemplo, archivo rm \ con \ a \ manojo \ de \ espacios.txt
] Cierre corchete. Cierra los recintos de prueba.
^ Signo de intercalación.
_ Guion bajo.
`…`
  • Activa la sustitución de mando; equivalente a $ (…) , pero es algo más propenso a errores.
{ Abra el apoyo rizado. Utilizado para expansión de variable específica. Por ejemplo, (donde var = “hola”) echo “$ {var} world” imprimirá “hola mundo”, echo “$ varworld” generará un error, esperando una variable llamada varworld.
| Tubo. Se utiliza para redireccionar la entrada a la salida. Específicamente, toma la salida del comando en el lado izquierdo, ejecuta el programa en el lado derecho y luego pasa el contenido de la salida del primer comando al segundo, como si se estuviera escribiendo desde un teclado. ‘ls -l | grep Desk ‘es equivalente a ejecutar “grep Desk”, y luego escribir manualmente lo que ls -l tendría salida. Cada vez que se presiona la tecla de retorno, se activará grep hasta que se presione ^ D para pasar el EOF.
} Cierre corsé.
~ Tilde. Normalmente se utiliza para referirse al directorio de inicio. Registrado como “mrwhite”, cd ~ (o simplemente cd) iría a / home / mrwhite. Al iniciar sesión como otro usuario, se podría lograr el mismo efecto con ‘cd ~ mrwhite’.

Enlaces externos en ingles

Introduccion al shell scripting o c-shell


Bash , c-shell  o simplemente shell scripting es  un lenguaje de script  creado a fines de la década de 1980 por un programador llamado Brian Fox, que trabajaba para la Free Software Foundation . Fue pensado como una alternativa de software libre para el shell Bourne (de hecho, su nombre es un acrónimo de Bourne Again SHell ), e incorpora todas las características de ese shell, así como nuevas características como la aritmética de enteros y el control de trabajo

Bash es un “shell de Unix”, es decir  una interfaz de línea de comandos para interactuar con el sistema operativo por lo que está ampliamente disponible, siendo el shell predeterminado en muchas distribuciones de GNU / Linux y en Mac OSX, con puertos existentes para muchos otros sistemas.

Además del modo interactivo, donde el usuario escribe un comando a la vez, con ejecución y respuesta inmediatas, Bash (como muchos otros shells) también tiene la capacidad de ejecutar un script completo de comandos, conocido como “Bash shell script” (o “Bash script” o “shell script” o simplemente “script”)  que es justo   lo que vamos a tratar en este post

 

 

Un scriptl  cinstituye un fichero normalmente con extensión .sh  que  puede contener solo una lista muy simple de comandos, o incluso un solo comando, aunque   los normal es que  contenga funciones, bucles, construcciones condicionales y todas las demás características de la programación imperativa.

Por otra parte los scripts de shell se pueden llamar desde línea de comandos interactiva descrita anteriormente o  bien, se pueden llamar desde otras partes del sistema. Por ejemplo se puede configurar un script para que se ejecute cuando se inicie el sistema; otro podría configurarse para funcionar todos los días de la semana a las 2:30 AM; otro podría ejecutarse cada vez que un usuario inicia sesión en el sistema.

Los scripts de shell se usan comúnmente para muchas tareas de administración del sistema, como realizar copias de seguridad en disco, evaluar registros del sistema, etc. También se utilizan comúnmente como scripts de instalación para programas complejos. Son especialmente adecuados para todo esto porque alejan la complejidad sin necesidad de casi hacer nada  si un script solo necesita ejecutar dos programas externos, puede ser un script de dos líneas, y si necesita toda la capacidad de toma de decisiones y poder de un lenguaje de programación imperativo Turing-completo, entonces puede tener eso también.

Cuando esté experimentando, es probable que le resulte útil consultar la documentación de varios comandos. Para los comandos que están integrados en Bash, puede usar el comando de ayuda incorporado(comando help ) ; por ejemplo, help echo “imprimirá” (es decir, mostrará) información sobre el comando echo incorporado. Para programas externos, es probable que sus páginas de manual estén instaladas en su sistema, en cuyo caso puede verlas a través del comando man (“manual”); por ejemplo, para información sobre el comando cp(“copiar”), puede escribir man cp . Además, la mayoría de los programas, cuando se ejecutan con el argumento --help , imprimirán información de ayuda; por ejemplo, cp --help proporciona casi tanta información como man cp . (Sin embargo, con muchos programas, el enfoque de ayuda no brinda tanta información como el enfoque del comando  man ).

 

close up code coding computer

Photo by Lorenzo Cafaro on Pexels.com

Hello world en bash script

Empecemos con un programa simple “hola mundo”:

  echo 'Hola mundo!'

Podemos escribir esto directamente en el indicador de Bash, o bien guardar esto como un archivo (por ejemplo, hello_world.sh ) y ejecutarlo escribiendo bash hello_world.sh en el indicador de Bash  o también  mendiante el comando Kash  (kash hello_world.sh  ).

En cualquier caso, se imprimirá Hello, world! :

 $ echo 'Hello, world!'  ¡Hola Mundo!

Aquí hemos utilizado el símbolo $ para indicar el indicador de Bash: después de $ , el resto de la línea muestra el comando que escribimos, y la siguiente línea muestra la salida del comando.

Aquí hay un script un poco más complejo:

  if [[ -e readme.txt ]] ;  then 
   echo 'El archivo "readme.txt" existe.'
 else
   echo 'El archivo "readme.txt" no existe.'
 fi

Esta secuencia de comandos comprueba si existe un archivo llamado readme.txt en el directorio actual y utiliza una instrucción if para controlar, en función de esa prueba, qué comandos se ejecutan. También se puede escribir directamente en el indicador de comandos (cualquier script), pero en este caso no es probable que sea útil.

Es decir todo lo  anterior es  completamente “dentro de Bash”, ya que no requiern que Bash ejecute ningún programa externo. (Los comandos echo , if ... then ... else ... fi , y [[-e ...]] son comandos incorporados, implementados por Bash.) Pero, al ser un lenguaje de shell-scripting, una gran parte del propósito de Bash es para ejecutar programas externos.

La siguiente secuencia de comandos demuestra esta capacidad:

  if [[ -e config.txt ]] ;  then
   echo 'El archivo "config.txt" ya existe.  Comparando con el predeterminado.  .  .'
   diff -u config-default.txt config.txt> config-diff.txt
   echo 'A diff se ha escrito en "config-diff.txt".'
 else
   echo 'El archivo "config.txt" no existe.  Copia por defecto.  .  .'
   cp config-default.txt config.txt
   echo '.  .  .  hecho.'
 fi

Aquí diff y cp son dos programas de utilidad comunes que, aunque no forman parte de Bash, se encuentran en la mayoría de los sistemas que tienen Bash.

La secuencia de comandos anterior asume la presencia de un archivo de configuración predeterminado llamado config-default.txt , y verifica la presencia de un archivo de configuración llamado config.txt . Si existe config.txt , entonces el script usa el programa externo diff para producir un “dif” (un informe de las diferencias entre, en este caso, dos archivos), para que el usuario pueda ver qué configuraciones no predeterminadas están en su lugar. . Si config.txt no existe, entonces el script usa el programa externo cp (“copiar”) para copiar el archivo de configuración predeterminado en config.txt .

Como puede ver, los programas externos se ejecutan utilizando el mismo tipo de sintaxis que los comandos incorporados ( ambos son solo “comandos”).

La versión anterior de este script es muy “detallada”, ya que genera una gran cantidad de resultados. Es probable que una secuencia de comandos más típica no incluya los comandos de eco , ya que es poco probable que los usuarios necesiten este nivel de información. En ese caso, podríamos usar la notación # para incluir comentarios que Bash ignore por completo y que no aparezcan al usuario. Tales comentarios son simplemente notas informativas para alguien que lee el script en sí:

  if [[ -e config.txt ]] ;  then
   # si config.txt existe:
   diff -u config-default.txt config.txt> config-diff.txt # ver qué ha cambiado
 else
   # si config.txt no existe:
   cp config-default.txt config.txt # toma el valor predeterminado
 fi

Pero lo anterior es simplemente por el bien de la demostración. En realidad, un script tan simple no requiere ningún comentario.

Comandos simples 

Un comando simple consiste en una secuencia de palabras separadas por espacios o tabulaciones. La primera palabra se toma como el nombre de un comando, y las palabras restantes se pasan como argumentos al comando. Ya hemos visto una serie de ejemplos de comandos simples

Aquí algunos comandos más  usuales:

  • cd ..
    • Este comando usa cd (“cambiar directorio”; un comando incorporado para navegar por el sistema de archivos) para navegar “hacia arriba” en un directorio.
    • La notación .. significa “directorio padre”. Por ejemplo, /foo/bar/../baz.txt es equivalente a /foo/baz.txt .
  • rm foo.txt bar.txt baz.txt
    • Suponiendo que el programa rm (“remove”) está instalado, este comando elimina los archivos foo.txt , bar.txt y baz.txt en el directorio actual.
    • Bash encuentra el programa rm buscando en una lista configurable de directorios un archivo llamado rm que sea ejecutable (según lo determinen sus permisos de archivos).
  • /foo/bar/baz bip.txt
    • Este comando ejecuta el programa ubicado en / foo / bar / baz , pasando bip.txt como único argumento.
    • / foo / bar / baz debe ser ejecutable (según lo determinado por sus permisos de archivo). Por cierto ,asegúrese de que NO HAY ESPACIO entre la barra inclinada y los archivos que la siguen:por ejemplo, asumiendo que la carpeta “foo” existe en el directorio “raíz”, luego ejecute el siguiente comando: “rm -r / foo” destruirá su computadora si se realiza con el acceso “sudo”. Usted ha sido advertido. Si no entiende lo anterior, no se preocupe por el momento.
    • Si / foo / bar / baz es un archivo de texto en lugar de un programa binario, y su primera línea comienza con #! , luego, el resto de esa línea determina el intérprete a usar para ejecutar el archivo. Por ejemplo, si la primera línea de / foo / bar / baz es #! / Bin / bash , entonces el comando anterior es equivalente a / bin / bash / foo / bar / baz bip.txt .

Ese ejemplo con / foo / bar / baz tiene una nota especial, ya que ilustra cómo se puede crear un script Bash que se pueda ejecutar como un programa ordinario: simplemente incluya #! / Bin / bash como la primera línea del script (suponiendo ahí es donde se encuentra Bash en su sistema; de lo contrario, ajuste según sea necesario) y asegúrese de que el script tenga los permisos de archivo correctos para ser legible y ejecutable. Para el resto des ejemplos de scripts de shell completos comenzarán con la línea #! / Bin / bash .

El problema con los espacios 

Vimos anteriormente que el comando rm foo.txt bar.txt baz.txt elimina tres archivos separados: foo.txt , bar.txt y baz.txt . Esto sucede porque Bash divide el comando en cuatro palabras separadas basadas en espacios en blanco, y tres de esas palabras se convierten en argumentos para el programa rm . Pero, ¿y si necesitamos eliminar un archivo cuyo nombre contiene un espacio?

Bash ofrece varios mecanismos de cotización que son útiles para este caso; las más utilizadas son comillas simples y comillas dobles.

Cualquiera de estos comandos eliminará un archivo llamado this file.txt :

  rm 'este archivo.txt'
  rm "este archivo.txt"

Dentro de las comillas, el carácter de espacio pierde su significado especial como separador de palabras. Normalmente envolvemos una palabra completa entre comillas, como se muestra arriba, pero de hecho, solo el espacio en sí necesita ser encerrado; este '' archivo.txt o este "" archivo.txt es equivalente a 'este archivo.txt' .

Otro mecanismo de citación comúnmente usado es la barra invertida \ , pero funciona de manera ligeramente diferente; Cita (o “escapa”) un solo carácter. Este comando, por lo tanto, es equivalente al anterior:

  rm este \ archivo.txt

En todos estos casos, los mismos caracteres de cita no se pasan al programa. (Esto se denomina eliminación de comillas ). Como resultado, rm no tiene forma de saber si se invocó, por ejemplo, como rm foo.txt o como rm 'foo.txt' .

Comodines de nombre de archivo y expansión de tilde

Bash admite una serie de notaciones especiales, conocidas como expansiones , para pasar tipos de argumentos de uso común a los programas.

Uno de ellos es la expansión del nombre de archivo , donde un patrón como * .txt se reemplaza con los nombres de todos los archivos que coinciden con ese patrón. Por ejemplo, si el directorio actual contiene los archivos foo.txt , bar.txt , este archivo.txt y algo.else , entonces este comando:

  echo * .txt

es equivalente a este comando:

  echo 'bar.txt' 'foo.txt' 'este archivo.txt'

Aquí el asterisco  significa “cero o más caracteres”; hay algunos otros caracteres de patrón especiales (como el signo de interrogación ?, que significa “exactamente un carácter”), y algunas otras reglas de coincidencia de patrón, pero este uso de  es, con mucho, el uso más común de patrones.

La expansión del nombre de archivo no se limita necesariamente a los archivos en el directorio actual. Por ejemplo, si queremos listar todos los archivos que coincidan con t * .sh dentro del directorio / usr / bin , podemos escribir esto:

  echo /usr/bin/t*.sh

que puede expandirse a algo como esto:

  echo /usr/bin/test.sh /usr/bin/time.sh

Si no hay archivos que coincidan con un patrón específico, no se realizará ninguna sustitución; por ejemplo, este comando:

  echo asfasefasef * avzxv

probablemente solo imprima asfasefasef * avzxv .

 

Si algún nombre de archivo comienza con un guión, entonces la expansión del nombre del archivo a veces puede tener consecuencias sorprendentes. Por ejemplo, si un directorio contiene dos archivos, llamados -n y tmp.txt , cat * se expande a cat -n tmp.txt , y cat interpretará -n como una opción en lugar de un nombre de archivo; en su lugar, es mejor escribir cat ./* o cat - * , que se expande a cat ./-n ./tmp.txt o cat - -n tmp.txt , eliminando este problema.

 

 

¿Qué sucede si tenemos un archivo real llamado * .txt al que queremos referirnos? (es decir  si los nombres de archivo pueden contener asteriscos). Pues podemos usar cualquiera de los estilos de cita que vimos anteriormente. Cualquiera de estos:

  cat '* .txt'
  gato "* .txt"

imprimirá el archivo real * .txt , en lugar de imprimir todos los archivos cuyos nombres terminen en .txt .

Otra expansión similar es la expansión de tilde . La expansión de tilde tiene muchas características, pero la principal es esta: en una palabra que consiste únicamente en una tilde ~ , o en una palabra que comienza con ~ / (tilde-barra), la tilde se reemplaza con la ruta completa a directorio de inicio del usuario actual. Por ejemplo, este comando:

  echo ~ / *. txt

imprimirá los nombres de todos los archivos nombrados * .txt en el directorio de inicio del usuario actual.

 

 

Uso de las llaves

Similar a la expansión de nombre de archivo es la expansión de refuerzo , que es una forma compacta de representar múltiples argumentos similares. Los siguientes cuatro comandos son equivalentes:

  ls file1.txt file2.txt file3.txt file4.txt file5.txt
  ls archivo { 1 , 2,3,4,5 } .txt
  ls archivo { 1 ..5..1 } .txt
  ls archivo { 1 ..5 } .txt

El primer comando enumera cada argumento explícitamente. Los otros tres comandos utilizan la expansión de refuerzo para expresar los argumentos de forma más concisa: en el segundo comando, se dan todas las posibilidades 1 a 5 , separadas por comas; en el tercer comando, se da una secuencia numérica (“de 1 a 5, incrementando en 1”); y el cuarto comando es el mismo que el tercero, pero deja el … 1 implícito.

También podemos listar los archivos en el orden opuesto:

  ls file5.txt file4.txt file3.txt file2.txt file1.txt
  ls archivo { 5 , 4,3,2,1 } .txt
  ls archivo { 5 ..1 ..- 1 } .txt
  ls archivo { 5 ..1 } .txt

siendo el tamaño de incremento predeterminado -1, cuando el punto final de la secuencia es menor que el punto de inicio.

Como en Bash, la primera palabra de un comando es el programa que se ejecuta, también podríamos escribir el comando de esta manera:

  { ls, archivo { 1 ..5 } .txt }

pero obviamente eso no es propicio para la legibilidad. (El mismo tipo de cosas, por cierto, se puede hacer con la expansión del nombre de archivo).

La expansión del refuerzo, como la expansión del nombre de archivo, se puede desactivar por cualquiera de los mecanismos de cotización; '{' , "{" , o \ { produce una llave literal real.

 

Redireccionando la  salida 

Bash permite que la salida estándar de un comando (descriptor de archivo 1) se envíe a un archivo, en lugar de a la consola. Por ejemplo, el programa de utilidad común cat escribe un archivo en una salida estándar; Si redirigimos su salida estándar a un archivo, tenemos el efecto de copiar el contenido de un archivo en otro archivo.

Si queremos sobrescribir el archivo de destino con la salida del comando, usamos esta notación:

  cat input.txt> output.txt

Si queremos mantener los contenidos existentes del archivo de destino como están y simplemente agregar la salida del comando al final, usamos esta notación:

  cat input.txt >> output.txt

Sin embargo, no todo lo que un programa escribe en la consola pasa por la salida estándar. Muchos programas utilizan el error estándar (descriptor de archivo 2) para los mensajes de error y algunos tipos de mensajes de “registro” o “canal lateral”. Si deseamos que el error estándar se combine con la salida estándar, podemos usar cualquiera de estas notaciones:

  cat input.txt y >> output.txt
  cat input.txt >> output.txt 2 > & 1

Si deseamos que el error estándar se adjunte a un archivo diferente de la salida estándar, usamos esta notación:

  cat input.txt >> output.txt 2 >> error.txt

De hecho, podemos redirigir solo el error estándar, dejando solo la salida estándar:

  cat input.txt 2 >> error.txt

En todos los ejemplos anteriores, podemos reemplazar >> con > si queremos sobrescribir el objetivo de redireccionamiento en lugar de agregarlo.

Más adelante veremos algunas cosas más avanzadas que podemos hacer con la redirección de salida.

Redireccionando la entrada 

Así como Bash permite que la salida de un programa se envíe a un archivo, también permite que la entrada de un programa se tome de un archivo. Por ejemplo, la utilidad común de Unix cat copia su entrada a su salida, de manera que este comando:

  cat <input.txt

Escribirá el contenido de input.txt en la consola.

Como ya hemos visto, este truco no es necesario en este caso, ya que a Cat se le puede pedir que copie un archivo específico a su salida; el comando anterior es simplemente equivalente a este:

  cat input.txt

Esta es la regla en lugar de la excepción; Las utilidades más comunes de Unix que pueden tomar entrada desde la consola también tienen la funcionalidad incorporada para tomar su entrada de un archivo en su lugar. De hecho, muchos, incluido cat , pueden recibir información de varios archivos, lo que los hace aún más flexibles que los anteriores. El siguiente comando imprime input1.txt seguido de input2.txt :

  cat input1.txt input2.txt

No obstante, la redirección de entrada tiene sus usos, algunos de los cuales veremos más adelante.

 

Tuberías (pipes) 

Una canalización  o  Pipe es una serie de comandos separados por el carácter de canalización | . Cada comando se ejecuta al mismo tiempo, y la salida de cada comando se usa como entrada para el siguiente comando.

Por ejemplo, considere esta tubería:

  cat input.txt |  grep foo |  grep -v bar

Ya hemos visto la utilidad de cat cat input.txt simplemente escribe el archivo input.txt en su salida estándar. El programa grep es una utilidad común de Unix que filtra (“greps”, en el lenguaje de Unix) según un patrón; por ejemplo, el comando grep foo imprimirá en su salida estándar cualquier línea de entrada que contenga la cadena foo . El comando grep -v bar usa la opción -v para invertir el patrón; El comando imprime las líneas de entrada que no contienen la barra de cadena. Dado que la entrada de cada comando es la salida del comando anterior, el resultado neto es que la canalización imprime cualquier línea de input.txt que contenga foo y no contenga barra .

Variables 

En un script de Bash, hay algunos tipos diferentes de parámetros que pueden contener valores . Un tipo importante de parámetro son las variables : parámetros nombrados. Si está familiarizado con casi cualquier otro lenguaje de programación imperativo (como C, BASIC, Fortran o Pascal), entonces ya está familiarizado con las variables. La siguiente secuencia de comandos simple utiliza la ubicación variable para mantener el mundo del valor, e imprime un “¡Hola, mundo!” mensaje:

  location = world # store "world" en la variable "location"
 echo "Hola, $ { ubicación } !"  # imprimir "¡Hola mundo!"

Como puede ver, la cadena $ {ubicación} en la segunda línea fue reemplazada por world antes de que se ejecutara ese comando. Esta sustitución se conoce como expansión variable , y es más flexible de lo que podría sospechar. Por ejemplo, incluso puede contener el nombre del comando para ejecutar:

  cmd_to_run = echo # store "echo" en la variable "cmd_to_run"
 " $ { cmd_to_run } " '¡Hola mundo!'  # imprimir "¡Hola mundo!"

En los dos ejemplos anteriores, hemos usado la notación $ { variable_name } para realizar la expansión de la variable. La notación más breve nombre_variable , sin llaves, tendría el mismo efecto en estos casos. A veces, los corchetes son necesarios (por ejemplo, $ {foo} bar no se puede escribir como $ foobar , porque este último se interpretaría como $ {foobar} ), pero generalmente se pueden omitir, y los guiones del mundo real por lo general los omiten .

Por supuesto, no hace falta decir que los anteriores no son ejemplos muy realistas; solo demuestran cómo usar las variables, no por qué o cuándo usarlas. Si está familiarizado con otros lenguajes de programación imperativos, entonces probablemente ya sea obvio por qué y cuándo usaría las variables; si no, entonces esto debería quedar claro a medida que lee este libro y vea ejemplos que los usan de manera más realista.

Es posible que haya notado que hemos usado comillas dobles " , en lugar de comillas simples cadenas de caracteres que incluyen expansiones variables':en general, es una buena idea envolver las expansiones variables entre comillas dobles; por ejemplo, use "$ var" en lugar de $ var .  . Esto se debe a que las comillas simples evitan la expansión de variables; un comando como echo' $ {location} ' imprimirá la cadena real $ {ubicación} , en lugar de imprimir el valor de una variable llamada ubicación .

En general, es una buena idea envolver las expansiones de las variables con comillas dobles, porque de lo contrario, los resultados de la expansión de las variables sufrirán la expansión del nombre de archivo, así como la división de palabras (donde se utiliza el espacio en blanco para separar las palabras que forman un comando). Por ejemplo, este script:

  foo = 'ab *' # tienda "ab *" en la variable "foo"
 echo $ foo

es probable que imprima algo como ba.txt bd.sh , que probablemente no sea lo que queremos. Las secuencias de comandos del mundo real con frecuencia no incluyen comillas dobles, excepto cuando son claramente necesarias, pero esta práctica a veces conduce a errores confusos.

Una serie de variables tienen un significado especial. Por ejemplo, la variable PATH determina la lista de directorios en los que Bash debería buscar cuando intenta ejecutar un programa externo; si está configurado en / usr / bin: / bin , entonces el comando cp src.txt dst.txt buscará ejecutar / usr / bin / cp o / bin / cp . La variable HOME está preinicializada en el directorio inicial del usuario actual y determina el comportamiento de la expansión de tilde. Por ejemplo, si una secuencia de comandos establece HOME = / foo , echo ~/bar imprimirá / foo / bar . (Sin embargo, esto no cambiará el directorio de inicio del usuario).

Parámetros posicionales 

En la mayoría de los comandos anteriores, tanto los que ejecutan un comando integrado como los que usan un programa externo, hemos suministrado uno o más argumentos , que indican en qué debe funcionar el comando. Por ejemplo, cuando invocamos la utilidad común de Unix mkdir (“make directory”) para crear un nuevo directorio, lo invocamos con un comando como este:

  mkdir tmp

donde tmp es el nombre del nuevo directorio para crear.

Y como hemos visto, los scripts de Bash son programas que pueden ejecutarse. Así que no hace falta decir que ellos también pueden tomar argumentos. Estos argumentos están disponibles para el programa como sus parámetros posicionales . Anteriormente, vimos que las variables son un tipo de parámetro. Los parámetros posicionales son muy similares, pero se identifican por números en lugar de por nombres. Por ejemplo, $ 1 (o $ {1} ) se expande al primer argumento del script. Supongamos que queremos crear un script simple llamado mkfile.sh que tome dos argumentos, un nombre de archivo y una línea de texto, y cree el archivo especificado con el texto especificado. Podemos escribirlo de la siguiente manera:

  #! / bin / bash
 echo " $ 2 " > " $ 1 "

(Observe la línea #!/bin/bash al principio del archivo; cubrimos esa línea en los comandos básicos . Cuando ejecute este código, esa línea garantizará que será interpretada por el shell Bash, incluso si está ejecutándose desde otro programa o su computadora tiene una configuración no estándar.)

y (después de hacerlo ejecutable ejecutando chmod + x mkfile.sh ) podemos ejecutarlo de la siguiente manera:

  ./mkfile.sh file-to-create.txt 'línea para poner en el archivo'

También podemos referirnos a todos los argumentos a la vez usando $ @ , que se expande a todos los parámetros posicionales, en orden. Cuando se envuelven en comillas dobles, como "$ @" , cada argumento se convierte en una palabra separada. (Nota: la alternativa $ * es quizás más común, pero "$ *" se convierte en una sola palabra, con espacios entre los parámetros originales. "$ @" Casi siempre es preferible a $ @ o $ * , lo que permite un argumento para dividirse en varias palabras si contiene espacios en blanco, y para "$ *" , que combina múltiples argumentos en una sola palabra.) Esto suele ser útil en concierto con el comando incorporado shift , que elimina el primer parámetro posicional, como que $ 2 se convierte en $ 1 , $ 3 se convierte en $ 2 , y así sucesivamente. Por ejemplo, si cambiamos mkfile.sh de la siguiente manera:

  #! / bin / bash
 file = " $ 1 " # guarda el primer argumento como "$ file"
 shift # suelta el primer argumento de "$ @"
 echo " $ @ " > " $ file " # escribe los argumentos restantes en "$ file"

entonces podemos ejecutarlo de la siguiente manera:

  ./mkfile.sh file-to-create.txt línea para poner en el archivo

y todos los argumentos, excepto el nombre de archivo, se escribirán en el archivo.

El número de parámetros posicionales está disponible como $ # ; por ejemplo, si $ # es 3 , entonces los parámetros posicionales son $ 1 , $ 2 y $ 3 .

Tenga en cuenta que los parámetros posicionales más allá de $ 9 requieren las llaves; Si necesita referirse al décimo argumento, por ejemplo, debe escribir $ {10} en lugar de $ 10 . (Este último se interpretaría como $ {1} 0 ). Dicho esto, no suele ser una buena idea tener tantos argumentos con significados específicos, ya que es difícil para los usuarios realizar un seguimiento de ellos. Si se encuentra específicamente refiriéndose al décimo argumento de su guión, puede valer la pena volver a evaluar su enfoque.

Si tiene alguna experiencia con Bash, o con las utilidades de Unix, lo más probable es que haya notado que muchos comandos pueden tomar varias “opciones”, indicadas con un guión principal, además de sus argumentos habituales. Por ejemplo, rm " $filename" elimina un archivo individual, mientras que rm -r " $dirname " elimina un directorio completo con todo su contenido. (La -r es la abreviatura de “recursivo”: el comando “recursivamente” elimina un árbol completo de directorios). Estas opciones son en realidad solo argumentos. En rm " $filename " , solo hay un argumento ( "$ filename" ), mientras que en rm -r " $dirname " hay dos ( -r y "$ dirname" ). En cierto sentido, no hay nada intrínsecamente especial en estos argumentos, pero esta notación para las opciones está tan extendida que se considera estándar; muchos o la mayoría de los comandos incorporados de Bash pueden aceptar varias opciones, y más adelante veremos varias técnicas para respaldar las opciones como argumentos para nuestros scripts de Bash.

Salida de un script 

Cuando se completa un proceso, devuelve un pequeño valor entero no negativo, llamado su estado de salida o su estado de retorno , al sistema operativo. Por convención, devuelve cero(es decir un exit 0  )  si se completó con éxito, y un número positivo si falló con un error ( es decir un exit <>0)  y de este modo se puede distinguir varios errores diferentes mediante el uso de diferentes números positivos

 Un script Bash puede obedecer esta convención mediante el uso del comando integrado exit . El siguiente comando:

  exit 4

termina el script de shell, devolviendo un estado de salida de cuatro, indicando algún tipo de error. Cuando no se especifica ningún estado de salida (ya sea porque la salida se ejecuta sin argumentos, o porque la secuencia de comandos finaliza sin llamar a exit ), la secuencia de comandos devuelve el estado de salida del último comando que ejecutó.

Una forma en que se utilizan los estados de salida es con los operadores Bash && (“y”) y || (“o”). Si dos comandos están separados por && , entonces el comando de la izquierda se ejecuta primero, y el comando de la derecha solo se ejecuta si el primer comando tiene éxito. Por el contrario, si están separados por || , entonces el comando de la derecha solo se ejecuta si el comando de la izquierda falla.

Por ejemplo, supongamos que queremos eliminar el archivo file.txt y volver a crearlo como un archivo en blanco. Podemos eliminarlo utilizando la utilidad común de Unix rm (“eliminar”), y volver a crearlo utilizando la utilidad común de Unix touch ; así, podríamos escribir esto:

  rm file.txt
 touch file.txt

Pero realmente, si rm falla, no queremos ejecutar el comando  touch : no queremos volver a crear el archivo si no pudimos eliminarlo para empezar. Entonces, podemos escribir esto en su lugar:

  rm file.txt && touch file.txt

Esto es lo mismo que antes, excepto que no intentará ejecutar touch a menos que rm haya tenido éxito.

Un tercer operador booleano similar, (“no”), invierte el estado de salida de un comando. Por ejemplo, este comando:

  ! rm file.txt

es equivalente a rm file.txt, excepto que indicará éxito si rm indica error, y viceversa. (Esto no suele ser útil cuando los estados de salida se usan como estados de salida reales, lo que indica éxito o fracaso, pero pronto veremos algunos usos extendidos de los estados de salida donde una operación “no” es más útil).

El estado de salida de un comando está (breve mente) disponible como $? .Esto puede ser útil cuando es necesario distinguir entre varios estados de falla diferentes; por ejemplo, el comando grep (que busca líneas en un archivo que coinciden con un patrón específico) devuelve 0 si encuentra una coincidencia, 1 si no encuentra coincidencias y 2 si se produce un error genuino.

emacs1

 

¿A  que no es tan difícil programar en c-shell?Le invitamos a que si tiene un terminal Unix o Linux ( por ejemplo una Raspberry Pi)   lo intente!seguro  que se le ocurren mil ideas interesantes que hacer !

 

 

Cómo conectarse a una Raspberry Pi desde un smartphone


No siempre esta fácilmente accesible un ordenador para conectarnos cómodamente desde ssh o por vnc   o tal vez no tenga un segundo teclado o ratón disponibles, así que ¿porque no intentar acudir a  una  smartphone  o tableta para conectarnos desde allí ?

 

Screenshot_2018-11-04-23-01-45-352_com.realvnc.viewer.android[1]

 

Pues en  efecto es posible conectarse a una Raspberry Pi desde un smartphone o tableta , y de forma muy sencilla ,como vamos a  ver a  continuación, pero para ello, en primer lugar necesitamos ,  obtener la dirección IP de la Raspberry Pi

Para conocer la dirección IP del Raspberry Pi, tendrá que  conectar la Raspberry Pi  a la alimentación , deberá tener conexión a  Internet   .

Ahora  desde    un terminal   ejecutar el comando ifconfig. La  salida  desde una Raspberry Pi 3 sera similar a esta:

[email protected]:~ $ ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 192.168.1.64 netmask 255.255.255.0 broadcast 192.168.1.255
inet6 fe80::625:6aec:6f57:df7c prefixlen 64 scopeid 0x20<link>
ether b8:27:eb:67:0c:6f txqueuelen 1000 (Ethernet)
RX packets 661 bytes 45810 (44.7 KiB)
RX errors 0 dropped 1 overruns 0 frame 0
TX packets 585 bytes 202270 (197.5 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10<host>
loop txqueuelen 1000 (Local Loopback)
RX packets 17 bytes 1004 (1004.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 17 bytes 1004 (1004.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

wlan0: flags=4099<UP,BROADCAST,MULTICAST> mtu 1500
ether b8:27:eb:32:59:3a txqueuelen 1000 (Ethernet)
RX packets 0 bytes 0 (0.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

[email protected]:~ $

 

Observe que en negrita casi al principio de la salida del comando ,  el comado nos indica la dirección IP para podernos conectarnos  de forma remota, asi  que recomendamos que la anote aparte.

Una vez que tenemos la ip   si antes no  se ha conectado de forma remota asegúrese de que esta habilitado la conexión tanto por SSH como por VNC , para lo cual  nos iremos a Preferencias-->Configuración de la Raspberry Pi y seleccionaremos la pestaña Interfaces.

Es esta pantalla , debemos seleccionar SSH y VNC . Finalmente pulsaremos aceptar  pero  para que se apliquen los cambios tendremos que reiniciar la Raspberry  Pi

 

ssh.PNG

Por cierto, si no recuerda la clave que escribió en la primera configuración debería ir a  Preferencias–>Configuración de la Raspberry Pi y en la pestaña Sistema pulsar cambiar clave, pues sera esta la que tendrá que escribir casa vez que intente conectarse a la Raspberry Pi

 

clave.PNG

Conexión hacia la Raspberry Pi por ssh

Lo  primero  que quizás se nos ocurra es la la conexión de Pi con teléfono via  SSH cliente):SSH (Secure Socket Shell), el cual  es un protocolo de acceso  muy común a todo los equipos unix  y Linux que nos da acceso a la consola de comandos

Existe  una app llamada  Serverauditor  que se puede descargar desde la store de Android (Google Play ) gratuitamente. Asimismo también está disponible para dispositivos iOS.

Asegúrese de que el smartphone o tableta y la Raspberry  Pi están en la misma red para poder realizar la conexión

Los pasos para instalar Serverauditor en el teléfono:

Alias: cualquier nombre es aceptable como por ejemplo Raspberry Pi 

Username: pi

Nombre de host: la  dirección Ip  obtenida con el comando ifconfig

Contraseña: la pwd que haya puesto

Los demás campos se pueden dejar espacios en blanco, luego toque la marca de verificación en la derecha superior. Después de eso, haga clic en una Conectar cuando se le preguntó ” Si desea conectar el dispositivo

  • Nota:Nombre de usuario y contraseña son los de frambuesa Pi. Si uno ha cambiado del predeterminado, necesita entrar con el actual nombre de usuario y contraseña.
Screenshot_2018-11-04-22-30-22-624_com.server.auditor.ssh.client[1]

Ahora  ya tiene un modo muy sencillo de ejecutar consola de Raspberry Pi en la pantalla así que !disfrútelo!.

En el vídeo siguiente precisamente podemos ver el programa en funcionamiento

Conexión hacia la Raspberry Pi via vnc

Ya que se ha conectado exitósamente a la consola de comandos por ssh , seguro que le interesa también poderse conectar tambien  al interfaz gráfico por lo que ahora nos toca instalar y configurar el servidor de VNC sobre Raspberry Pi  en su tablet/smartphone.

Para instalar y configurar el VNC viewer en su tablet/smartphon en  android  siga los siguientes pasos:

  • Descargue la app Vnc Viewwer desde Google Play desde la url  oficial https://play.google.com/store/apps/details?id=com.realvnc.viewer.android
  • Al ejecutar la   app por primera vez le pedira una cuenta de  vnc, de modo qeu si no la tiene tendra que creala desde la propia aplicacion introduciendo una cuenta de correo, un nombre , apellido,pais   y un catcha,
  • En nuestro correo electrónico recibiremos un email que debemos validar para confirmar que  cuenta nos pertenece
  • Una vez que haya confirmado los datos puede intentar volver a entrar en la app VNV Viewer ingresando las credenciales que introdujo
  •  Ahora  siga el procedimiento similar al del ssh
    • Haga clic en el el Boton del signo másen la parte inferior izquierda de la pantalla y seleccione la opción Nuevo Host.
    • Entrar los siguientes datos:

    Alias: cualquier nombre es aceptable como por ejemplo Raspberry Pi 

    Username: pi

    Nombre de host: la  dirección Ip  obatnida con el comando ifconfig

    Contraseña: la pwd que haya puesto

    Los demás campos se pueden dejar espacios en blanco, luego toque la marca de verificación en la derecha superior. Después de eso, haga clic en una Conectar cuando se le preguntó ” Si desea conectar el dispositivo

  • Para  conectarse  a  su Raspberry Pi , dado que ya ha creado la conexión, pulse  sobre el icono nuevo que aparece en la pantalla de inicio
  • Enseguida deberían aparecer   las credenciales de acceso  y probablemente el pwd en blanco que deberemos completar  .
  • Finalmente progresar la conexión  pulsando en CONTINUE
  • Una vez dado el botón de conectar debería aparecer la pantalla principal de Raspbian que ahora podremos controlar desde nuestro smartphone  haciedo uso de las herramientas que nos aparecen en la parte superior de la pantalla

 

Screenshot_2018-11-04-23-01-45-352_com.realvnc.viewer.android[1]

  • Para faciliar el manejo VNC sin teclado  y ratón   clásicos  aparte de la barra de herramientas , este  programa  añade soporte de gestos con los dedos  para  facilitarnos la interaccion con Raspbian:

Screenshot_2018-11-04-23-00-59-320_com.realvnc.viewer.android[1]Screenshot_2018-11-04-23-00-52-332_com.realvnc.viewer.android[1]

 

NOTA: En caso de versiones MUY  antiguas de Raspbian que no traigan VNC instalado deberá instalar al version servidor de VNC  en la Raspberry Pi de forma manual desde consola por   línea de consola, para ello introduzca los siguientes comandos en orden.

  1.  Instalar el paqueete TightVNC paquete:  sudo apt-get install tightvncserver
  2. Ejecutar servidor TightVNC; tightvncserver
  3. Se le pedirá que introduzca una contraseña y una contraseña de sólo lectura opcional.
  4. Crear un archivo de secuencia de comandos para iniciar el servidor VNC. Use Oeditor de texto  escribiendo el siguiente comando:nano
  5. Poner el siguiente script en él: #!/bin/sh  vncserver :1 -geometry 1920×1080 -depth 24 -dpi 96
  6. “Ctrl+o” para guardar el archivo. La extensión debe ser “.sh” por ejemplo llamelo “vnc.sh”. A continuación, “Ctrl + X” para salir del editor de.
  7. Hacer el archivo ejecutable.sudo chmod +x vnc.shCon este archivo, puede iniciar servidor VNC desde tu tablet/smartphone enviando un comando a través de SSH: ./vnc.sh dsfs

 

 

 

:

 

Cámara trasera con Raspberry PI para coche basada en Android


En efecto  simplemente podemos  usar una frambuesa Pi como retrovisor o cámara trasera  en conjunción con su smartphone o tablet gracias a la aplicación  RearPi.

Esta app disponible en Google Play  gratuita  y sin anuncios se conecta a su Raspberry  Pi a través de SSH y activa bien  una cámara usb  externa  o bien    la  cámara nativa para Raspberry Pi con interfaz CSI  un enlace de mayor ancho de banda que transporta los datos de píxeles de la cámara al procesador.  .

Disponiendo de la Rasberry con una cámara,   basta  con conectarse  a esta via ssh (nombre de IP-Adress/Login y contraseña), iniciar la cámara en el arranque de la aplicación o con el botón “Abrir” y  pulsar  el  modo de pantalla completa  para disponer de la visión trasera desde la app de un modo  muy nítido  . Al continuar el trayecto si ya no se requiere  basta cerrar la cámara con el botón “EXIT” para disponer nuestro smartphone  para reproducir nuestra lista de música favorita o que nos guié a través de alguna app  de navegación

 

Imagen

Razones para usar una Raspberry Pi como cámara trasera

RearPi es una sencilla aplicación para Android disponible gratuitamente   SIN PUBLICIDAD en en Google Play  que nos va a permitir  visualizar y grabar señales de vídeo transmitidas por una Raspberry Pi o similar   a través de WiFi , por lo que es utilizable para casi todos los coches para transmitir señales  de vídeo procedentes de una cámara frontal  o  de una cámara trasera hacia un terminal Android.

Puede que piense que existen en el mercado soluciones especificas de cámaras traseras para coche  a un precio  similar  a una Raspberry Pi   sobre todo si pensamos en que necesitamos adquirir el hardware especifico que vamos a describir, lo cual  ciertamente podría ser parcialmente cierto , pero  esta afirmación se desmorona si  podemos usar elementos que ya tengamos   pero  sobre todo  , si deseamos  usar  nuestro smartphone o incluso un  terminal obsoleto  que tengamos  para visualizar la señal , lo cual  es un punto a su favor de  esta solución  si lo comparamos con las pequeñísimas o antiestéticas  pantallas de visualización  que  ofrecen los kits de cámaras traseras  (piensese que  solemos llevar  siempre  un smartphone y ademas puede usarse para otras usos)

Incluso en otros vehículos (por ejemplo  para las caravanas)  pueden  usarse para ofrecer la visión delantera o trasera por  múltiples pantallas de  forma inalámbrica

Algunas características de esta aplicación:
  • Grabación cámara  (.. 15 min 30 min 45 min)
  • Bucle de grabación (.. 15 min 30 min 45 min)
  • Opción para establecer la calidad de grabación
  • Reproductor multimedia integrado para ver grabaciones
  • Modo de pantalla completa  y sin publicidad
  •  Documentación Integrada

En realidad  como podemos intuir , esta  app  se conecta a su Raspberry Pi ( o  cualquier placa basada en Linux  )  por ssh   mediante   IP-Dirección , login y contraseña mediante WIFI dentro de la misma red , y , una vez conectada se puede  iniciar la cámara en la   aplicación o con el botón “OPEN” ,pudiéndose   cerrar la cámara con el botón “SALIR”

Para utilizar su Frambuesa Pi con RearPi como cámara y esta aplicación  rearPi    tendremos   que seguir unos pocos sencillos   pasos en la Raspberry  PI, pero antes veamos  el hardware necesario

 

Hardware necesario

¿Qué necesita para obtener una señal de video?

  • Una Raspberry Pi o un dispositivo que ejecute una distribución de Linux con un sistema operativo preinstalado y una trabajando la conexión SSH.
  • Un dongle WiFi como el “Edimax EW-7811”
  • Una cámara USB o cámara web como Logitech C270
  • Un cable de carga micro USB
  • Un cargador de coche como el “Anker” PowerDrive2 ” Entrada: DC 12 / 24V Salida: 5V / 4.8A 2.4 A por puerto.Por favor, asegúrese de que su Raspberry  se pone suficiente potencia y el voltaje correcto.La salida de su cargador de coche debería tener 5V y la capacidad actual recomendada para su modelo está escrito en la lista siguiente:

raspberrrypower.PNG

Instalación de mjpg streamer

Para que su Raspberry esté lista para transmitir video via tcp/ip a traves de una conexión wifi, debe seguir estos pasos:

1. Abra un terminal por ssh
2. Instale mread streamer con estos comandos (comience con el primero):
 sudo apt-get install libv4l-dev
 sudo apt-get install libjpeg8-dev
 sudo apt-get install subversion
 sudo apt-get install imagemagick
 svn co https://svn.code.sf.net/p/mjpg-streamer/code/
 cd / home / pi / code / mjpg-streamer /
 make USE_LIBV4L2 = true clean all
 sudo make DESTDIR = / usr install
3. !Listo!!

Configurar una dirección IP estática y conexión WiFi

Para asegurarse de que su Raspberry Pi siempre tenga la misma dirección IP, establezca IP estática (para que no tenga problemas al  iniciar la app)

Por ello verifque su interfaz WiFi  con  el comando :ifconfig (buscar la ip asociada a Interfaz WiFi) y una vez seap el  nombre de interfaz WiFi asi  , edite las interfaces:

  • sudo nano / etc / network / interfaces
  • Desplazarse hacia abajo a la #WLAN  sección (si no está allí crear uno al final del archivo)
  • Configure su interfaz a IP estática
  • Configure su Raspberry Pi  a una  dirección  fija ,por ejemplo “192.168.43.125” o lo que quiera
  • Escriba el nombre de la zona wifi y contraseña entre comillas  “
  • Salvar el fichero y reiniciar la Raspberry

RearPi

Para empezar a usar  su Raspeberrry Pi como cámara IP trasera, una vez seguido el proceso anterior de personalización de la  Pi , es importante que  nuestro smartphone  y la  Raspberry estén en la misma red , para lo cual podemos  automatizar el proceso con la App Automate , tal y como vimos en este post 

Muy  resumidamente  la red wifi , se consigue con la función de “hot spot ”  de nuestro teléfono inteligente  la cual permite conectar diferentes dispositivos conectados a nuestra propia red wifi generada desde el  propio terminal   .En caso de Android   vaya a “Configuración –>Más –>Anclaje y punto de acceso portátil” o en versiones de Android superiores a   a la 7 vaya   a  Ajustes (la tuerca ) , busque la opción de  Más y vaya  a  Anclaje de red y zona Wi-Fi  y pulse  Zona Wifi portátil  y áctivelo ( interruptor a la derecha).Una  vez creada la zona wifi podemos  automatizar el proceso con la App Automate buscando   el punto de acceso en el automóvil ( Hotspot ON/OF CAR ) y descargando el flujo

Ahora con  ambos  equipos en red ,conecte la Raspberry Pi con su cargador e Instale la app RearPi desde Google Play 

Una vez ejecute la app, abra la “configuración” y configure la “Dirección IP”, el “Nombre de inicio de sesión” y la contraseña (std pw = raspberry) y podemos empezar con los ajustes de  la pantalla de inicio ajustable:

  •  Establezca los segundos por cuánto tiempo pantalla de inicio se queda (en la configuración)
  •  Establecer “0” para ninguna pantalla de inicio
  •  Activar la cámara cada inicio

Imagen Imagen

Una vez  realizados los ajustes , pulsaremos  el  botón ABRIR , el cual  se conectará a la Raspberry Pi y activara la cámara  actualizando la señal de vídeo

Si queremos abandonar  esta utilidad  , pulsaremos  el  Botón EXIT, el cual se conectara a la Raspberry Pi y desactivara la cámara, cerrando  aplicación

Un modo muy interesante es el Modo de pantalla completa, qu e opera del siguiente modo:

  •  Toque una vez en el vídeo para obtener modo de pantalla completa
  •  Toque  nuevamente para salir de pantalla completa modo

Imagen

Un truco muy interesante es el Modo de pantalla completa al inicio, que conseguiremos si  establecemos la marca de verificación para ir directamente en el modo de pantalla completa (configuración)  cuando iniciemos la aplicación

Por cierto también es posible  grabar video  y visionarlo  desde la propia  aplicación

 

Imagen

 

Resumidamente estos son los posos a seguir para crear una camara trasera  :

  • Establecer un hot spot  para conectar la Pi y su teléfono / tableta.
  • Para transmitir vídeo tiene que instalar streamer MJPG  en Raspberry Pi:.
  • Ejecute   sudo ◦ apt-get install build-essential libjpeg-dev ImageMagick subversión libv4l-dev checkinstall
  • Ejecute  svn co svn: //svn.code.sf.net/p/mjpg-streamer/code/ MJPG-streamer
  • Ejecute cd MJPG-streamer / mjpg-streamer
  • Ejecute  VERSION = $ (sed -n ‘/SOURCE_VERSION/s/^.*”\(.*\)”.*$/\1/gp’ REVISIÓN ◦ = $ (CN svnversion | sed “s /.*: //”)
  • Ejecute sudo checkinstall –pkgname = MJPG-streamer –pkgversion = “$ + $ VERSIÓN DE REVISIÓN ~ checkinstall” –default
  • Hacer USE_LIBV4L2 = true ← opcional
  • De a suu Raspberry Pi una dirección IP estática (pasos detallados en el manual de PDF).
  •  Conectar con la App a su a Pi (IP / Conexión / PW)

 

Con  esta solución  no, necesita alguna fuente de radiación lumínica o infrarroja pues  en condiciones de muy baja luminosidad trabaja bien especialmente si usa la camra nativa.

Por cierto para probar si esta funcionando el stream de video ,tenemos  el comando raspistill que   sirve para hacer fotografías. Si busca en internet hay proyectos para hacer de forma automatizada varias tomas y hacer un timelapse  de modo  qeu la ventaja de esta cámara es que la podrá usar como cámara de vigilancia con uno leds infrarojos para iluminar la zona

En el siguiente vídeo podemos  ver la cámara en acción:

 

Documentación: https://alikamouche.files.wordpress.com … _v1-33.pdf