Como instalar una pantalla tactil de 5″ en una Raspberry Pi 3


En realidad, en efecto,  es bastante sencillo y “económico”  dotar a nuestra Raspberry Pi 3 de una pantalla táctil  siempre que no optemos por adquirir la version oficial  , la cual es mucho mas cara ( sobre unos 70€  mas gastos de envió  ) en clara  contraposición de  versiones de otras pantallas mas pequeñas pero mas económicas .

La cuestión es que la  pantalla oficial ofrece ,excepto por su tamaño, características muy similares a las de otros fabricantes, pues de  hecho las características de  la version oficial  son las siguientes:

  • Tamaño: 7″
  • Resolución: 800×480 hasta 60fps
  • Color: hasta 24bits
  • Táctil: capacitiva de 10 puntos
  • Placa adicional para hacer la conexión, también que sirve para alimentar la Raspberry Pi 3 por lo que con un solo cable de alimentación tendremos todo funcionando
  • Función dual screen de esta pantalla y la salida HDMI que pueden estar activas de forma simultánea

Es de destacar  que la pantalla al final no es tan nativa como cuentan pues  ademas usa una placa intermedia para convertir la señal de la salida directa de la placa a una señal de un tipo más simple y que abarata el tipo de pantalla. Esta placa básicamente es un convertidor LVDS a  HDMI quedando integrada con la pantalla y con la Raspberry Pi 3 bastante bien pero no mejor que con otras soluciones. Dual screen permitiría usar como pantalla principal un monitor HDMI y mantener esta como secundaria pudiendo hacer cosas como lanzar una app desde esta pantalla TFT, OMXPlayer por ejemplo, y que se vean en la otra, esto da mucho juego pero tampoco quizás no sea  algo tan frecuente .

En contraposición a la pantalla oficial vamos a ver  una  solución mucho  mas barata propuesta por Kuman  que cuenta mas de la mitad  de la solución oficial .(unos 35€  a Amazon.es) El modelo  que vamos  que hemos probado en este blog  es el modelo Kuman 5 Pulgadas , con pantalla resistiva, resolución  800×480  con salida  HDMI para Raspberry Pi 3 2 Modelo B RPI 1 B B + A A + SC5A

Estas son algunas de las características de este modelo de kuman,

  • Pantalla estándar TFT de 5 ‘”
  • Resolución 800 × 480
  • Con pantalla táctil resistiva, control táctil compatible
  • Con control de luz de fondo(  la luz de fondo se puede apagar para ahorrar energía con un interruptor integrado)
  • Es compatible con la entrada de interfaz HDMI estándar
  • Se puede insertar directamente con Raspberry Pi (3ª, 2ª y 1ª generación)
  • Se puede usar como monitor HDMI de uso general, por ejemplo: conectando un ordenador  por medio del HDMI como pantalla secundaria (la resolución debe poder forzar la salida de 800 x 480)
  • Por supuesto se puede usar con Raspberry Pi  siendo compatible con Raspbian, Ubuntu, Kodi, win10 IOT (táctil resistiva)
  • Puede funcionar como monitor de PC  pues es compatible con XP, win7, win8, sistema win10 (no admite touch) touch Certificación CE, RoHS

A diferencia del modelo oficial este modelo de kuman, cuenta con interfaz USB para alimentarlo externamente por ejemplo  para usar la pantalla de forma independiente ,de modo que  cuando se conecta a la Raspberry Pi a través del conector de expansión   de 13×2 se pude  obtener  5V de alimentación del  propio  conector  USB  y obviamente no haya que alimentar  a la  raspberry  y al   modulo   de kuman,de forma independiente,

Respecto al vídeo  al incorporar el interface Interfaz HDMI simplemente hay que conectar un puente macho hdmi- macho hdmi  entre la Raspberry Pi  y la placa de  la pantalla  lo cual ademas permite mantener unidas ambos módulos

Por cierto , cuenta con  interruptor de encendido de la luz de fondo para controlar la retroiluminación encendida y apagarla  cuando no se necesite  para ahorrar energía por ejemplo en aplicaciones portátiles

A diferencia de otras soluciones   la conexión del digitalizador  adherido a  la pantalla se  hace  directamente    por medio del  socket de 13 * 2 pines , el cual ademas sirve   para alimentar con 5V al   modelo de kuman, desde  el pin de potencia de la Rasperry Pi  al mismo tiempo que  se transfiera la señal táctil

De vuelta a la Raspberry Pi algo muy interesante es la interface interfaz extendida  de la placa  pues de la señal 13 * 2   volvemos a tener nuevamente los mismo pines en la placa de control para poderlo usar para  nuestras  aplicaciones   con la importante salvedad que para el digitalizador se usan los pines 19(MI) , 22(IRQ), 21 (MO) , 23 (SCK)  y 26 (TC) , pines que por tanto no deben ser usados en otras aplicaciones.

1) "NC" significa No conectado, los pines "NC" no se utilizan en esta pantalla LCD.
2) SI solo se usa para visualización (sin tocar), puede dejar que este Pin 13 * 2 sea libre, solo conecte el USB ySeñal HDMI para hacerla mostrar.
3) 13 * 2 señales de pin extendidas para el usuario.

Una vez entendida las conexiones de la placa, veamos los pasos para conectar el   modulo de kuman,   a la  raspeberry Pi;

Software

Instalación automática

Con este  modulo de kuman   se adjuntan en un dvd  tres imágenes  con los drivers  ya instalados   y configurados  .Estas  imágenes corresponden   a  tres sabores de Linux:  KALI, RASPBIAN  y UBUNTU , y  que deberemos copiar desde el propio dvd. Estos son los nombres de los ficheros:

  • 5inch_KALI2017.01.7z
  • 5inch_raspbian20180418.7z
  • 5inch-RPI3-RPI2-ubuntu-mate-16.04-beta2.7z

Una vez haya decidido   que imagen vaya   a instalar ( recomendamos la de Raspbian 20180418 ) , necesitara  descomprimir el ficheo con el programa gratuito 7zip

Con la imagen correcta del S.O.  ahora   realice  el formateo de tarjeta TF  usando  SDFormatter

Por ultimo grabe la imagen oficial en la tarjeta TF utilizando Win32DiskImager.
Cuando termine  el proceso , saque la memoria  sd del lector del pc  ,   e introduzca esta en su Raspberry Pi
Observe que las credenciales de acceso  , según la imagen que  haya grabado en la sd son diferentes:

  • <5inch_raspbian20170705> user:pi      password:raspberry
  • <5inch-RPI3-RPI2-ubuntu-mate-16.04-beta2> user:pi password:raspberry
  • <5inch_kali2017.01> user:root  password:toor

Instalación manual

Podemos hacer una instalación  automática  que ya hemos hablado, en la que se han incluido  todos los drivers  necesarios para soportar el digitalizador, o bien podemos hacer la instalación controlada , veamos ahora los pasos a seguir:
En primer lugar necesitamos   instalar la imagen oficial de Raspbian o UbuntuMate ,para  ello descargue desde el sitio web oficial: https://www.raspberrypi.org/downloads/   o https://ubuntu-mate.org/download/ .

Con la imagen correcta del S.O.  ahora   realice  el formateo de tarjeta TF  usando  SDFormatter

Por ultimo grabe la imagen oficial en la tarjeta TF utilizando Win32DiskImage

Ahora nos toca instalar manualmente los drivers para lo cual podemos usar dos métodos parecidos en función de que tenga  la Raspebrry Pi o conexión a internet

Método 1: instalación en línea

En este  método  la Raspberry Pi necesita conectarse a Internet,
Los pasos  a seguir son los siguientes:

  1.  Inicie sesión en la Raspberry Pi usando el programa y Putty SSH (Usuario: pi; Contraseña: raspberry)
  2. Ejecute los siguientes comando (puede hacer clic con el botón derecho del ratón para pegar después de copiarlo en Putty)                                                                                                        git clone https://github.com/goodtft/LCD-show.git
    chmod -R 755 LCD-show
    cd LCD-show/
    sudo ./LCD5-show
  3. Espere hasta finalizar la ejecución del ultimo comando antes de usar el panel LCD

Método 2: instalación fuera de línea

  1. Escanee el código QR en el lado derecho    .
  2. Puede copiar el fichero    llamado  “LCD – show – 160701. The tar. gz” desde  el  DVD   al directorio raíz de la tarjeta del sistema Raspberry Pi; (Sugerencia: copie directamente en su pc  directamente a la tarjeta TF después de completar el paso inicial, o copie por SFTP u otros métodos para copia remota).
  3. Descomprima y extraiga los archivos del disco con los siguientes comandos                                                                                                                cd /boot
    sudo tar zxvf LCD-show-160701.tar.gz
    cd LCD-show/
    sudo ./LCD5-showmo el siguiente comando:cd / bootsudo tar zxvf LCD-show-160701.tar.gzcd LCD-show /sudo ./LCD5-show3)
  4. Cuando termine  el proceso , saque la memoria  sd del lector del pc  ,   e introduzca esta en su Raspberry Pi

Instalación hardware

Una vez tengamos  ya instalado el S.O.   con los drivers del digitalizador , es hora de instalar esta  en nuestras Raspberrry Pi  (i (3ª, 2ª y 1ª generación).
En primer lugar  colocaremos los  4  separadores roscados en la pantalla  >Ahora  solo hay que conecte el zócalo del Pin LCD 13 * 2 a la Raspberry Pi como se muestra en la imagen de abajo.Observe que  encaja en el conector exactamente , pero ademas también debe  encajar uno de los separadores roscados en uno de los orificios de las Rasberry Pi así como debe estar alineados ambos conectores hdmi ( el de la placa con el de la raspberry Pi)  Conecte  ahora  la pantalla LCD y la Raspberry Pi con el adaptador HDMI  espacial .Observe  que debe encajar  el puente hdmi -hdmi  entre ambas placas , lo cual  ademas le dará rigidez mecánica al montaje

Observe por cierto en la parte de atrás abajo a la izda el interruptor que permite apagar la luz de retro-iluminación de la pantalla
A su favor esta placa  también que sirve para alimentar la Raspberry por lo que con un solo cable de alimentación tendremos todo funcionando  y el montaje queda bastante robusto  que difiere por cierto   bastante diferente  la versión  oficial  cuyo conjunto es  un poco endeble con mucho cablecito plano y mucho hilo suelto que no parecen encajar bien con un entorno tipo educativo.

En la imagen  mas abajo podemos ver el montaje terminada a falta de la carcasa , donde se aprecia claramente que es manejable con el dedo   aunque  también  se pueda usar el lápiz táctil que acompaña este kit

Para terminar , si hecha de menos una caja , hay un diseño  que la podemos descargar desde aqui :https://www.thingiverse.com/thing:1698162

Para terminar una nota de aplicación : por si  no nos parece suficiente la  pantalla conectada  a la Raspberry Pi ,   si desconectamos el adaptador  hdmi -hdmi entre la pantalla y la Raspberry Pi , podemos conectar la salida HDMI desde  un ordenador  a la interfaz LCD HDMI mediante un cable normal  HDMI. Luego solo   necesitaremos conectar  el microUSB  del LCD a  un  puerto USB del   pc  mediante un cable USB  y así podremos usar este pequeño LCD , como segundo monitor  o    incluso monitor de   pruebas( obviamente como monitor de pc  la función táctil no estará disponible).

Para terminar , este kit esta accesible en Amazon  por unos 36€

Anuncios

Shell scripting :funciones ,subshells y variables de entorno


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

En este  post  vamos  a continuar  avanzando en el conocimiento de este lenguaje con el uso de las funciones, subshells  y las  variables de entorno

close up code coding computer

 

 

 

Funciones de shell 

Una función de shell es un tipo especial de variable que es esencialmente un script dentro de otro script. Gracias a estas funciones c-shell  nos permite agrupar una secuencia de comandos en un solo comando con nombre, lo cual es particularmente útil si la secuencia de comandos necesita ejecutarse desde muchos lugares dentro del script  .

Como una función de shell puede incluso consistir en un solo comando; esto puede ser útil si el comando es particularmente complicado, o si su significado no sería inmediatamente obvio para un lector,es  decir, las funciones de shell pueden servir para dos propósitos:

  • pueden guardar la escritura
  • Pueden permitir un código más legible mediante la creación de comandos con nombres intuitivos

Como ejemplo considere la siguiente secuencia de comandos:

#! / bin / bash
# Uso: get_password VARNAME 
# Le pide al usuario una contraseña y lo guarda como $ VARNAME. 
# Devuelve un estado de salida distinto de cero si la entrada estándar no es un terminal, o si el 
comando # "leer" devuelve un estado de salida distinto de cero. 
get_password ()  { 
  si  [[ -t 0  ]]  ;  then
    read -r -p 'Contraseña:' -s "  $ 1  "  &&  echo 
  else 
    return  1
   fi
 }

get_password PASSWORD &&  echo  "  $ PASSWORD  "

El script anterior crea una función de shell llamada get_password que le pide al usuario que escriba una contraseña y almacena el resultado en una variable específica. Luego ejecuta get_password PASSWORD para almacenar la contraseña como $ PASSWORD ; y por último, si la llamada a get_password tuvo éxito (según lo determinado por su estado de salida), la contraseña recuperada se imprime en la salida estándar (que obviamente no es un uso realista pues  el objetivo aquí es simplemente demostrar el comportamiento de get_password ).

La función get_password no hace nada que no se pueda hacer sin una función de shell, pero el resultado es mucho más legible. La función invoca la lectura de comando incorporada (que lee una línea de entrada del usuario y la guarda en una o más variables) con varias opciones con las que la mayoría de los programadores de Bash no estarán familiarizados:

  • La opción -r desactiva un significado especial para el carácter de barra diagonal inversa;
  • la opción -p hace que aparezca un mensaje específico, en este caso Contraseña:, al principio de la línea;
  • la opción -s evita que se muestre la contraseña a medida que el usuario lo escribe. Desde la -s la opción también evita que se muestre la nueva línea del usuario,

El comando echo proporciona una nueva línea y además, la función usa la expresión condicional -t 0 para asegurarse de que la entrada del script proviene de un terminal (una consola) y no de una archivo o de otro programa que no sabría que se está solicitando una contraseña. (Esta última característica es discutible; dependiendo de la funcionalidad general del script,pues  puede ser mejor aceptar una contraseña de entrada estándar independientemente de su origen, suponiendo que la fuente se diseñó teniendo en cuenta el script). El punto general es que darle un nombre a la secuencia de comandos – get_password – hace que sea mucho más fácil para un programador saber qué hace.

Dentro de una función de shell, los parámetros posicionales$ 1 , $ 2 , etc., así como $ @ , $ * y $ # ) se refieren a los argumentos con los que se llamó a la función, no a los argumentos del script que contiene la función. Si se necesitan estos últimos, entonces deben pasarse explícitamente a la función, usando "$ @" . (incluso entonces, shift y set solo afectarán a los parámetros posicionales dentro de la función, no a los de la persona que llama).

Una llamada de función devuelve un estado de salida, al igual que un script (o casi cualquier comando). Para especificar explícitamente un estado de salida, use el comando return , que finaliza la llamada a la función y devuelve el estado de salida especificado. (El comando de salida no se puede usar para esto, ya que terminaría la secuencia de comandos completa, como si se llamara desde fuera de una función). Si no se especifica ningún estado de salida, ya sea porque no se da ningún argumento al comando de devolución o porque se llega al final de la función sin haber ejecutado un comando de retorno , a función devolverá el estado de salida del último comando que se ejecutó.

Incidentalmente, cualquiera de las funciones o () pueden omitirse de una declaración de función, pero al menos una debe estar presente. En lugar de , muchos programadores escriben  de manera similar, la notación {...} que no es exactamente necesaria y no es específica de las funciones; es simplemente una notación para agrupar una secuencia de comandos en un solo comando compuesto.

El cuerpo de una función debe ser un comando compuesto, como un bloque {…} o una instrucción if ; {…} Es la opción convencional, incluso cuando todo lo que contiene es un comando compuesto único y, por lo tanto, teóricamente podría prescindirse de él.function get_password ( )get_password ()

Subshells 

En Bash, uno o más comandos se pueden envolver entre paréntesis, lo que hace que esos comandos se ejecuten en una “subshell”(también hay algunas formas en que se pueden crear subshells implícitamente) Un subshell recibe una copia del “entorno de ejecución” del contexto circundante, que incluye cualquier variable, entre otras cosas; pero cualquier cambio que haga a subshell al entorno de ejecución no se vuelve a copiar cuando se completa la subshell.

Así, por ejemplo, este script: #! / bin / bash

foo  = barra
 echo  "  $ foo  "  # imprime 'barra'

# subshell:
 (
  echo  "  $ foo  "  # imprime 'barra' - la subshell hereda las variables de sus padres 
  baz  = bip
   echo  "  $ baz  "  # imprime 'bip' - la subshell puede crear sus propias variables 
  foo  = foo
   echo  "  $ foo  "  # imprime ' foo '- la subshell puede modificar variables heredadas
 )

echo  "  $ baz  "  # no imprime nada (solo una nueva línea) - se pierden las nuevas variables de la subshell 
echo  "  $ foo  "  # imprime 'barra' - los cambios de la subshell a las variables antiguas se pierden

La ejecución imprimirá esta salida:

bar

bar

bip

foo

bar

Si necesitase llamar a una función que modifica una o más variables, pero en realidad no desea que esas variables se modifiquen, puede ajustar la llamada a la función entre paréntesis, para que tenga lugar en una subshell. Esto “aislará” las modificaciones y evitará que afecten el entorno de ejecución circundante.Dicho esto: cuando sea posible, es mejor escribir funciones de tal manera que este problema no se presente para comenzar, pues la palabra clave local puede ayudar con esto.

Lo mismo ocurre con las definiciones de funciones; al igual que una variable regular, una función definida dentro de una subshell no es visible fuera de la subshell.

Una subshell también delimita los cambios a otros aspectos del entorno de ejecución; en particular, el comando cd (“cambiar directorio”) solo afecta a la subshell. Así, por ejemplo, este script:

  #! / bin / bash

cd /
 pwd  # imprime '/'

# subshell:
 (
  pwd  # prints '/' - la subshell hereda el directorio de trabajo 
  cd home
   pwd  # prints '/ home' - la subshell puede cambiar el directorio de trabajo 
)  # end of subshell

pwd  # prints '/': los cambios de la subshell en el directorio de trabajo se pierden

imprime esto:

/ / /casa /

Si su script necesita cambiar el directorio de trabajo antes de ejecutar un comando dado, es una buena idea usar una subshell si es posible,. de lo contrario, puede resultar difícil hacer un seguimiento del directorio de trabajo al leer un script. Alternativamente, los comandos incorporados pushd y popd se pueden usar para un efecto similar.

 

Una declaración de salida dentro de una subshell termina solo esa subshell. Por ejemplo, este script:

  #! / bin / bash
(  exit  0  )  &&  echo  'subshell successed' 
(  exit 1  )  ||  echo  'subshell failed'

imprime esto:

 subshell tuvo éxito
subshell falló

Al igual que en una secuencia de comandos en su conjunto, exit de los valores predeterminados  devuelve el estado de salida del comando de última ejecución, y una subshell que no tiene una instrucción de salida explícita devolverá el estado de salida del comando de última ejecución.

Variables de entorno

Ya hemos visto que, cuando se llama a un programa, recibe una lista de argumentos que se enumeran explícitamente en la línea de comandos. Lo que no hemos mencionado es que también recibe una lista de pares nombre-valor denominados “variables de entorno”.

Diferentes lenguajes de programación ofrecen diferentes formas para que un programa acceda a una variable de entorno; Los programas C pueden usar getenv (" variable_name ") (y / o aceptarlos como un tercer argumento para main ), los programas Perl pueden usar $ ENV {' variable_name '} , los programas Java pueden usar System.getenv (). Get (" variable_name ") , y así sucesivamente.

En Bash, las variables de entorno se convierten simplemente en variables regulares de Bash. Así, por ejemplo, la siguiente secuencia de comandos imprime el valor de la variable de entorno HOME :

#! / bin / bash
echo  "  $ HOME  "

Sin embargo, lo contrario no es cierto: las variables regulares de Bash no se convierten automáticamente en variables de entorno. Así, por ejemplo, este script:

#! / bin / bash
foo  = bar
bash -c 'echo $ foo'

Esto no imprimirá la barra , porque la variable foo no se pasa al comando bash como una variable de entorno. ( De bash -c scripts argumentos ... corre el Bash script de una línea de la escritura ).

Para convertir una variable Bash normal en una variable de entorno, tenemos que “exportarla” al entorno. La siguiente secuencia de comandos hace la impresión de barras :

#! / bin / bash
export  foo  = bar
bash -c 'echo $ foo'

Tenga en cuenta que la exportación no solo crea una variable de entorno; en realidad marca la variable Bash como una variable exportada, y las asignaciones posteriores a la variable Bash también afectarán a la variable de entorno. Ese efecto es ilustrado por este script:

#! / bin / bash
foo  = bar
bash -c 'echo $ foo'  # no imprime nada 
export foo
bash -c 'echo $ foo'  # imprime 'bar' 
foo  = baz
bash -c 'echo $ foo'  # imprime 'baz'

El comando de exportación también se puede usar para eliminar una variable de un entorno, incluyendo la opción -n ; por ejemplo, export -n foodeshace el efecto de export foo. Y múltiples variables pueden ser exportadas o no exportadas en un solo comando, como export foo barexport -n foo bar.

Es importante tener en cuenta que las variables de entorno solo se pasan a un comando; nunca se reciben de vuelta de un comando. En este sentido, son similares a las variables y subshells regulares de Bash. Así, por ejemplo, este comando:

#! / bin / bash
export  foo  = bar
bash -c 'foo = baz'  # no tiene efecto 
echo  "  $ foo  "  # print 'bar'

barra de estampados ; el cambio a $ foo dentro del script de una línea no afecta el proceso que lo invocó. (Sin embargo, podría afectar a cualquier script que fueron llamados a su vez por ese guión.)

Si se desea una variable de entorno dada para un solo comando, se puede usar la sintaxis, con la sintaxis de una asignación de variable (o múltiples asignaciones de variables) que precede a un comando en la misma línea. (Tenga en cuenta que, a pesar de usar la sintaxis de una asignación de variable, esto es muy diferente de una asignación de variable Bash normal, en que la variable se exporta automáticamente al entorno y en que solo existe para el comando. Si desea evitar la confusión de sintaxis similar hacer las cosas diferentes, se puede utilizar la común utilidad Unix env para el mismo efecto que la utilidad también hace que sea posible. eliminar una variable de entorno para un comando – o incluso para eliminar todas las variables de entorno para un comando) Si. $ varvar =value commandya existe, y se desea incluir su valor real en el entorno para un solo comando, que se puede escribir como .var = " $var " command

Aparte: a veces es útil colocar definiciones de variables, o definiciones de funciones, en un script de Bash (por ejemplo, header.sh ) que puede ser llamado por otro script de Bash (por ejemplo, main.sh ). Podemos ver que simplemente invocar ese otro script Bash, como ./header.sh o como bash ./header.sh , no funcionará: las definiciones de variables en header.sh no serán vistas por main.sh , ni siquiera si “exportado” esas definiciones. (Este es un punto de confusión común: exportar las variables de exportación al entorno para que otros procesos puedan verlas, pero solo las ven los procesos secundarios , no los padres.) Sin embargo, podemos usar el comando incorporado Bash (“punto”) o fuente , que ejecuta un archivo externo casi como si fuera una función de shell. Si header.sh se ve así:

 foo  = función de barra
 baz ()
 {
  echo  "  $ @  "
 }

entonces este script:

#! / bin / bash
. header.sh
baz "  $ foo  "

imprimirá 'barra' .

Alcance 

Ahora hemos visto algunos de los caprichos del alcance variable en Bash.

Para resumir lo que hemos visto hasta ahora:

  • Las variables regulares de Bash están orientadas al shell que las contiene, incluidas las subshells en ese shell.
    • No son visibles para ningún proceso secundario (es decir, para programas externos).
    • Si se crean dentro de una subshell, no son visibles para el shell principal.
    • Si se modifican dentro de una subshell, esas modificaciones no son visibles para el shell principal.
    • Esto también se aplica a las funciones, que en muchos aspectos son similares a las variables regulares de Bash.
  • Las llamadas de función no se ejecutan inherentemente en subshells.
    • Una modificación de variable dentro de una función generalmente es visible para el código que llama a la función.
  • Las variables de Bash que se exportan al entorno tienen un alcance al shell que las contiene, incluidas las subshells o procesos secundarios en ese shell.
    • El comando incorporado de exportación se puede utilizar para exportar una variable al entorno. (También hay otras formas, pero esta es la forma más común).
    • Difieren de las variables no exportadas solo en que son visibles para los procesos secundarios. En particular, todavía no son visibles para shells principales o procesos primarios.
  • Los scripts de Bash externos, como otros programas externos, se ejecutan en procesos secundarios. El o el comando integrado de origen se puede utilizar para ejecutar un script de este tipo internamente, en cuyo caso no se ejecuta de forma inherente en una subshell.

Ademas a  esto añadimos ahora:

  • Las variables de Bash que están localizadas en una función-llamada están sujetas a la función que las contiene, incluyendo cualquier función llamada por esa función.
  • El comando incorporado local se puede usar para localizar una o más variables a una llamada de función, usando la sintaxis local var1 var2o . (también hay otras formas, por ejemplo, el comando declarar incorporado tiene el mismo efecto, pero esta es probablemente la forma más común).local var1 = val1 var2 = val2)
  • Se diferencian de las variables no localizadas en que desaparecen cuando finaliza su función-llamada. En particular, todavía son visibles para subshells y llamadas de función hijo. Además, al igual que las variables no localizadas, se pueden exportar al entorno para que también las vean los procesos secundarios.

En efecto, usar local para localizar una variable en una función-llamada es como poner la función-llamada en una subshell, excepto que solo afecta a una variable; otras variables pueden dejarse sin ser “locales”.

 

Una variable que se establece dentro de una función (ya sea mediante asignación o mediante un comando for-loop u otro comando incorporado) debe marcarse como “local” utilizando el comando incorporado local , para evitar que se afecte accidentalmente el código fuera del función, a menos que se desee específicamente que la persona que llama vea el nuevo valor.

Es importante tener en cuenta que, aunque las variables locales en Bash son muy útiles, no son tan locales como las variables locales en la mayoría de los otros lenguajes de programación, ya que son vistos por llamadas de funciones secundarias. Por ejemplo, este script:

#! / bin / bash

foo  = bar

function f1 ()
 {
  echo  "  $ foo  "
 }

function f2 ()
 {
  local  foo  = baz
  f1 # imprime 'baz'
 }

 f2

En realidad se imprimirá baz en lugar de barra . Esto se debe a que el valor original de $ foo está oculto hasta que devuelve f2 . (En la teoría del lenguaje de programación, una variable como $ foo se dice que tiene un “ámbito dinámico” en lugar de un “ámbito léxico”).

Una diferencia entre local y subshell es que mientras que un subshell toma inicialmente sus variables de su shell principal, una declaración como local foo oculta inmediatamente el valor anterior de $ foo ; es decir, $ foo se desestabiliza localmente. Si se desea inicializar el $ foo local al valor del $ foo existente , debemos especificarlo explícitamente, mediante el uso de una declaración como local foo = "$ foo" .

Cuando una función sale, las variables recuperan los valores que tenían antes de sus declaraciones locales (o simplemente se anulan, si no se habían anulado). Curiosamente, esto significa que un script como este:

 #! / bin / bash

function f ()
 {
  foo  = baz
   local  foo  = bip
 }

foo  = bar
 F
echo  "  $ foo  "

Realmente imprimirá baz : la declaración foo = baz en la función surte efecto antes de que la variable se localice, por lo que el valor baz es lo que se restaura cuando la función regresa.Y dado que local es simplemente un comando ejecutable, una función puede decidir en tiempo de ejecución si localizar una variable dada, por lo que este script:

#! / bin / bash

function f ()
 {
  si  [[  "  $ 1  "  ==  'sí'  ]]  ;  entonces
    Foo
   local fi
  foo  = baz
 }

foo  = bar
f yes # modifica un $ foo localizado, por lo que no tiene ningún efecto 
echo  "  $ foo  "  # imprime 'barra' 
f # modifica el $ foo no localizado, configurándolo en 'baz' 
echo  "  $ foo  "  # imprime 'baz'

Este script en realidad se imprimirá

 bar
baz

 

Radio por internet con Raspberry pi


Desde Adafruit nos enseñan como construir  un  controlador de pantalla táctil para nuestra  Raspberry pi   con la idea de usar  esta  con la pantalla táctil , como  un Radio Reproductor por internet  gracias al  número creciente de emisoras de radio de internet disponibles. Obviamente  esta idea de instalar una pantalla táctil  a nuestra raspberry pi es ideal no solo para usar nuestra Pi como a radio por internet sino también para muchísimas  mas funciones como  reproductor mp3,cámara Ip, como tableta, para modding  y una infinidad de ideas      

Concretamente este interesante proyecto combina la versatilidad de la Raspberry Pi y el económico  PiTFT 2,8″ con pantalla táctil TFTdisplay. Una interfaz de visualización personalizada le permite controlar el volumen, la estación y ver lo que se está reproduciendo siendo ideal para personas que tienen una Raspberry Pi  y no le encuentran  otra  utilidad o simplemente para probar la funcionalidad del interfaz táctil

Como vamos a ver  hay bastantes pasos, pero el resultado merece la pena .

Resumidamente estos son los pasos a seguir:

  1. Montar  la PiTFT 320 x 240 2,8″ con pantalla táctil (esto puede no ser necesario si su PiTFT esta ya  premontado)
  2. Calibrar la pantalla táctil
  3. Instalar Music Player Daemon (MPD) y el cliente de reproductor de música (MPC) en laPi
  4. Encontrar y añadir emisoras de radio internet a mpc
  5. Descargar el código de radioplayer 
  6. Disfrutar de streaming de radio por internet en su escritorio Deben completarse todos los pasos de configuración y calibración para la pantalla de PiTFT.

Como adelanto en el siguiente vídeo podemos ver el proyecto en funcionamiento

 

 

Sin duda  es una idea muy interesante , veamos los pasos más en detalle.

 

1-Preparación y calibrado del sensor tactil 

Si su PiTFT de Adafruit pantalla táctil de 2,8″ vino como un kit ( por ejemplo el de Adafruit) necesitara completar las instrucciones para montar la pantalla,  aunque resumidamente hay que descargar y grabar la imagen PiTFT o bien utilizar una instalación existente de Raspbian e instalar el script de configuración sencilla. 

Si usa una  imagen para  instalar o utiliza el script instalador,entonces  todos los  pasos que vamos a ver  no son necesarios pues  ya están hechos  de modo que lo que vamos  a ver  es sólo para usuarios avanzados que tengan curiosidad sobre cómo configurar y personalizar la pantalla táctil siendo el procedimiento  idéntico para el 2.4″, 2.8″, 3.2″y 3.5″ PiTFTs resistivas.
Lo realmente interesante de este procedimiento es que ademas puede ser útil para otras pantallas diferentes a la de Adafruit en Amazon , pues  existen opciones razonables  por 25€ ( pantallas , soporte  y dializador incluidos )   que tendremos que configurar .
Como vamos a  ver el procedimiento es superable  aunque es cierto  que tengamos que pasar por un proceso de  calibración , pero no es difícil en absoluto.
Pantalla táctil de 3,5 pulgadas TFT LCD pantalla con protector caja de acrílico para Raspberry Pi 3 B+ [3 x disipador de calor de aluminio, CD con sistema instalado, lápiz capacitivo]
En este el caso  de comprar un kit , el montaje  físico es bastante sencillo  pues se reduce a  montar sobre la respberry pi sobre el  conector  de la GPIO  ,colocar el puente de hdmi  (segun el  modelo  especialmente en las pantallas mas grandes )   y montar finalmente los acrílicos
Este vídeo  nos puede servir para hacernos idea  de modo que nos  puede ayudar https://www.youtube.com/watch?v=gVK9MpPzK44,
No obstante  aun siendo sencillos  loa pasos , según el modelo puede haber variaciones  asi que lo recomendables es consultar las instrucciones que del fabricante del kit 
 
Veamos los  pasos a seguir una vez hayamos ,montado  la pantalla sobre la Raspberry Pi
 
  • Antes de empezar, vamos a hacer una regla udev para la pantalla táctil. Eso es porque el nombre eventX del dispositivo va a cambiar mucho y su molesto para averiguar lo que su llamada dependiendo de si tiene un teclado o el otro ratón instalado.   Ejecutar   sudo nano /etc/udev/rules.d/95-stmpe.rules   para crear un nuevo archivo de udev y copia y pega la siguiente línea: SUBSYSTEM==”input”, ATTRS{name}==”stmpe-ts”, ENV{DEVNAME}==”*event*”, SYMLINK+=”input/touchscreen” 
  •  Quite y vuelva a instalar la pantalla táctil con  sudo rmmod stmpe_ts; sudo modprobe stmpe_ts  
  • A continuación  realize un listado del directorio  escribiendo ls -l /dev/input/touchscreen  debe apuntar a eventX donde X es algún número, que número será diferente en diferentes configuraciones ya que otros teclados/ratones y dispositivos USB se llevará una ranura de evento
  • Hay algunas herramientas que podemos utilizar para calibrar y depurar la pantalla táctil. Instalar el “evento de prueba” y “biblioteca de pantalla táctil” paquetes con sudo apt-get install evtest tslib libts-bin
  • Evtest corriente :Ahora usted puede utilizar algunas herramientas como  sudo evtest /dev/input/touchscreen  ,  que le permitirá ver eventos de la pantalla táctil en tiempo real, pulsar en la pantalla táctil para ver los informes.
  • Script de calibración AutoMagic :Si se gira la pantalla necesita volver a calibrar la pantalla táctil para trabajar con la nueva orientación de la pantalla. Puede ejecutar manualmente los procesos de calibración en la sección siguiente, o puede volver a ejecutar el script instalador y seleccionar una nueva rotación.Intente utilizar este script de calibración por defecto para calibrar fácilmente su pantalla táctil. Tenga en cuenta que los valores de calibración pueden no ser adecuados para la pantalla, pero deben ser lo suficientemente cercanas para la mayoría de las necesidades. Si usted necesita la calibración de pantalla táctil más precisa, siga los pasos en la siguiente sección manualmente calibrar la pantalla táctil.
  • Calibración manual :Si la técnica de calibración “automagic” no funciona para usted o si tiene alguna otra instalación donde tiene que calibrar cuidadosamente te puede hacer ‘manualmente’se quiere calibrar la pantalla una vez pero no tiene que hacer más que eso. Empezaremos por la calibración en la línea de comandos ejecutando sudo TSLIB_FBDEVICE=/dev/fb1 TSLIB_TSDEVICE=/dev/input/touchscreen ts_calibrate .Siga las instrucciones en la pantalla, tocando cada punto. Utilizando un lápiz es sugerido para obtener un toque preciso. No uso algo de metal, plástico.Veremos cinco objetivos de punto de mira. Si ve menos que esos, la pantalla táctil probablemente genera señales múltiples de un solo toque, y usted debe tratar de calibrar otra vez.A continuación se puede ejecutar sudo TSLIB_FBDEVICE=/dev/fb1 TSLIB_TSDEVICE=/dev/input/touchscreen ts_test que le permitirá dibujar-prueba de la pantalla táctil. Volver atrás y volver a calibrar si sientes que la pantalla no es suficientemente precisa.
  • X calibración :También puede calibrar el sistema de entrada de X pero tienes que usar un programa diferente llamado xtcal (xinput_calibrator ya no funciona).Puede hacer esto si la calibración de la pantalla no es de tu agrado o cualquier momento cambiar la rotación = XX ajustes del módulo de la pantalla. Puesto que el controlador de pantalla y touch son completamente separados, la pantalla táctil no rotara automáticamente
sudo apt-get install libxaw7-dev libxxf86vm-dev libxaw7-dev libxft-dev
git clone https://github.com/KurtJacobson/xtcal
cd xtcal
make
  • Debe estar ejecutando PIXEL (GUI) mientras se calibra.Antes de empezar el calibrador tendrá que ‘reiniciar’ el viejo calibración datos entonces ejecutar DISPLAY=:0.0 xinput set-prop "stmpe-ts" 'Coordinate Transformation Matrix' 1 0 0 0 1 0 0 0 1 Ahora tendrá que ejecutar el calibrador mientras se ejecuta también X. Puede hacerlo abriendo el programa terminal y ejecuta el comando xtcal (que es difícil hacerlo en una pequeña pantalla) o se puede hacer lo que hacemos que es crear un shell SSH/Terminal y ejecutar el calibrador de la misma cáscara , que requiere el siguiente comando:DISPLAY=:0.0 xtcal/xtcal -geometry 640x480
  • Tenga en cuenta que el puede variar!geometry .Si está utilizando un 2.4″/2.8″/3.2 “pantalla de 320 x 240 con orientación horizontal, utilizar 640 x 480. Si es retrato, utilizar 640 x 480.Si está utilizando una pantalla de 3.5” con paisaje, utilizar 720 x 480, retrato es 480 x 720   Siga las instrucciones en pantalla
 
  • Ejecute sudo nano /usr/share/X11/xorg.conf.d/20-calibration.conf y copiar la linea número 9 en la opción de TransformationMatrix por lo que parece:
  1. Section “InputClass”
  2. Identifier “STMPE Touchscreen Calibration”
  3. MatchProduct “stmpe”
  4. MatchDevicePath “/dev/input/event*”
  5. Driver “libinput”
  6. Option “TransformationMatrix” “-0.000087 1.094214 -0.028826 -1.091711 -0.004364 1.057821 0 0 1”
  7. EndSection
  • Por ultimo hay que  reiniciar tu Pi para comprobar que está hecho Si esa asi ¡Su pantalla táctil esta ahora super calibrado, Lai lá!
¡No se debe usar con el PiTFT capacitiv pues no funcionara! Encontrara que para el uso más efectivo de la pantalla táctil es necesario llevar a cabo la calibración manual de la pantalla táctil.
Ahora que la pantalla está funcionando muy bien, nos encargamos de la pantalla táctil.

2-Instalar el Daemon

Ya tenemos  una raspberry Pi  con una pantalla táctil  de modo qeu podemos continuar .
En esta etapa es digno  la comprobación que la Raspberry Pi está actualizada antes de continuar, por lo que debe ejecutar el siguiente comando. 

sudo aptget update

Ahora ya podemos instalar el mpc y mpd  y añadir algunas emisoras de radio a tu lista de reproducción.

Las estaciones de ejemplo se enumeran a continuación son canales de la BBC del Reino Unido, pero  existen muchos mas disponibles en otros paises  

  • sudo aptget install mpd mpc
  • mpc add http://bbcmedia.ic.llnwd.net/stream/bbcmedia_intl_lc_radio1_p?s=1365376033&e=1365390433&h=a0fef58c2149248d6bff1f7b7b438931
  • mpc add http://bbcmedia.ic.llnwd.net/stream/bbcmedia_intl_lc_radio2_p?s=1365376067&e=1365390467&h=d43dc8ae0f888809462a6cb7c389b46b
  • mpc add http://bbcmedia.ic.llnwd.net/stream/bbcmedia_intl_lc_radio3_p?s=1365376123&e=1365390523&h=d53cf2a92272f3289b314a2251d23bc8
  • mpc add http://bbcmedia.ic.llnwd.net/stream/bbcmedia_intl_lc_radio4_p?s=1365376126&e=1365390526&h=ed9a0642b30c422b07fbcd8683c52335
  • mpc add http://bbcmedia.ic.llnwd.net/stream/bbcmedia_intl_lc_5live_p?s=1365376271&e=1365390671&h=e0d82133f35ae74d41d5eab6b9c150a6

Usted puede ahora comprobar con el comando mpc funciona a partir de una emisora sin olvidar conectar sus auriculares en el jack de 3 1/2 de  la salida de audio de la raspberry 

mpc play

Una copia de la lista de reproducción se puede guardar con el comando   mpc save my_playlist

La lista de reproducción se guarda en /var/lib/mpd/listas/  y  a lista de reproducción puede ser editada a mano con

sudo nano /var/lib/mpd/playlists/my_playlist

Una vez editada la lista de reproducción se puede cargar en mpc con

mpc load /var/lib/mpd/playlists/my_playlist

De esta forma podemos tener  un número de listas de reproducción guardadas en /var/lib/mpd/playlists con diversos géneros dependiendo del  estado de ánimo

 

3-Instalar Radio Player

El software de front-end Radioplayer se ha escrito en Python con Pygame y es específico para la pantalla TFT de 320 x 240 2,8″. Sin embargo, es relativamente sencillo adaptar el código para trabajar en una ventana de  mayor tamaño

Debe descargar el código de Python y los iconos desde el enlace Descargar el código de Python y los iconos. Extraiga los archivos en un memory stick y copielos  en una carpeta en la Raspberry Pi. (O puede colocarlo en el directorio de tarjeta SD en el ordenador de casa, los archivos en boot al arranca la tarjeta SD en la Pi)

Guardar en una carpeta llamada pi-radio 

Asegúrese de que todos los iconos y python código se guarda en la carpeta /home/pi/pi-radio

¡En esta etapa todo debería estar listo para funciona asi que solo tiene que ejecutar los siguientes comandos

cd /home/pi/piradio

sudo python radioplayer.py

 

 

Uso de Radioplayer

La interfaz ha sido funestamente mantenida simple para que puede accionarse con los dedos en lugar de un lápiz.
projects_Raspberry_Pi_Radio.jpg
  • Play – mpc inicia en la lista de reproducción
  • Pausa – mpc se detiene en la lista de reproducción
  • Bajar volumen – reduce el volumen
  • Subir volumen – aumenta el volumen de
  • Mute – volumen cero
  • Refrescar – para la reproduccion, vuelve a reproducir  y actualiza la pantalla.
  • Exit – cierra radioplayer interfaz pero mantiene mpc ejecutandose

 

Se extrae la información de la estación de la salida  con el comando  mpc status

Muchas estaciones de usan un formato común de  Nombre de emisora: nombre/información del circuito, es decir 

  • Nombre de la estación se muestra en la primera línea de la pantalla.
  • El nombre de la pista se muestra en la segunda línea de la pantalla.
  • Si no hay ningún nombre de la pista se muestra un mensaje de “ninguna información adicional“.

 

 

 

 

 

Mas   información en  https://learn.adafruit.com/raspberry-pi-radio-player-with-touchscreen/

Cámara trasera inteligente con Raspberry Pi. Parte 2


Añadiendo reconocimiento de imágenes

 

En los tutoriales de instalación de OpenCV  se  recomienda compilar desde la fuente; sin embargo, en el último año ha sido posible instalar OpenCV a través de pip, el propio administrador de paquetes de Python. Si bien la instalación desde la fuente le dará el mayor control sobre su configuración de OpenCV, también es la más difícil y la que más tiempo consume. Si está buscando la manera más rápida posible de instalar OpenCV en su sistema, querrá  usar pip para instalar OpenCV, pero hay algunas cosas que pueden hacer que se tropiece en el camino, así que asegúrese de leer el resto de este  post. 

Script  en Python

Ahora  este script    puede  ser nombrado  como  car_detector.py  y lanzarlo desde  la consola  .

Ojo no basta con lanzarlo F5 desde el propio Python pues dará probablemente error a l ahora de importar al libreria cv2, pero no se preocupe situarse en la ruta del scrript  en prython  y   ejecutar

sudo python car_detector.py

IMG_20181113_224935[1].jpg

A partir desde ahí debería funcionar la detección de imágenes  con lo que capte la imagen de  la Raspberry Pi

En el siguiente vídeo podemos ver el script en acción

 

 

Como vemos en elvideo en pequeña escala, lo hizo bastante bien detectando un montón de objetos innecesarios, ( aunque  a veces detecta las sombras como objetos.)En un escenario del mundo real, los resultados fueron sorprendentemente precisos ,pero si es  cerca de las condiciones perfectas, Tenga en cuenta que el código es  básico actualmente y necesitaria muchas más pruebas y depuración)

De los dos métodos,este  método , pero el primer método  es más confiable en múltiples situaciones. Así que si usted fuera a hacer esto para su coche, iría con el método  inicial ( el que usa overlay).

 

 

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ás en 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
  • Podemos ver la imagen de la cámara  ahora desde el propio teléfono

Screenshot_2018-11-13-22-55-52-301_com.realvnc.viewer.android[1]

 

Mas información en :https://www.hackster.io/tinkernut/raspberry-pi-smart-car-8641ca

 

Bot de Telegram con Raspberry Pi


Telegram Messenger como todos sabemos  es una famosa aplicación de mensajería y VoIP  desarrollada por los hermanos Nikolái y Pável Dúrov    con altas  capacidades de  alojamiento de contenido (con historial de las conversaciones y mensajes guardados),6​7​ archivos (hasta 1.5 GB, incluyendo documentos, multimedia y animaciones gráficas), búsqueda global de usuarios, sincronización de contactos, llamadas, canales de difusión, supergrupos, entre otros.

Inicialmente en 2013  fue empleado en smartphones pero al poco tiempo en 2014 comenzo a ser  multi-plataforma para más de 10 sistemas operativos: Android, iOS, macOS, Windows, GNU/Linux, Firefox OS, navegadores web, entre otros y actualmente rivaliza  con Whatsapp al que poco a poco esta intentando arrebatando usuarios.

Además de las características citadas  Telegram ,ofrece la plataforma de bots que además de hacer conversaciones inteligentes y pueden realizar otros servicios y complementar la experiencia en las conversaciones.

En este post precisamente nos vamos a centraros  en el uso del bot Botfather para interactuar desde Telegram  con nuestra Raspberry Pi

En primer lugar,para empezar buscaremos  BotFather seleccionando la opción “Bot”

Ahora pretendemos crear un Bot nuevo ,por lo que pulsaremos en crear nuevo o enviaremos  /newbot
Screenshot_2018-11-06-22-34-27-741_org.telegram.messenger[1]
Enseguida nos pedirá un nombre   , como por ejemplo “soloelectronicos_bot”
ademas tenemos qeuñadir un usuario para nuestro bot ,La regla es que debe terminar en bot , como por ejemplo soloelectronicosbot

 Configurar nuestra Raspberry Pi

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 y  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]ypi:~ $ 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 donde  nos indica la dirección IP para podernos conectarnos  de forma remota, asi  que recomendamos que la anote aparte.

raspberrypi

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

Ahora nos conectaremos  con el vnc ingresando la dirección ip de l aRaspeberry Pi obtenida, anteriormente , el  nombre de usuario ( suele ser pi )   y la password

Ahora por si estamos en una version antigu de Python ( la version ultima ya lo incluye ) deberiamos instalar  el indice de paquetes Python

sudo apt-get install python-pip
 sudo pip install telepot

 Ejecutar el código de Python

Ahora ya tenemos todos los ingredientes faltándonos tan solo el script en python que nos permitirá   transcribir la información enviada por Telegram si corresponde con nuestro Token  ,   hacia   ordenes   qeu pueden ser procesada  por la Raspberry Py

El script en  Python escrito  por Salman Faris es bastante sencillo  pues tras importar los modulos necesarios , define el pin 11  con dos estados (on  y off) y en funcion de las ordenes que reciba del Telegram   pondrá o no a nivel alto dicho pin

Este el código completo del script escrito por Salman:

#coder :- Salman Faris

import sys
import time
import random
import datetime
import telepot
import RPi.GPIO as GPIO

#LED
def on(pin):
            GPIO.output(pin,GPIO.HIGH)
return  def off(pin):
           GPIO.output(pin,GPIO.LOW)
return

# para numerar en  la  placa  Raspberry Pi por el numero de los pines

GPIO.setmode(GPIO.BOARD)

# configurar el canal de salida del GPIO

GPIO.setup(11, GPIO.OUT)

bot = telepot.Bot('TOKEN OBTENIDO DESDE TELEGRAM')

def handle(msg):
chat_id = msg[‘chat’][‘id’]
command = msg[‘text’]

print ‘Got command: %s’ % command

if command == ‘on’:
bot.sendMessage(chat_id, on(11))
elif command ==’off’:
bot.sendMessage(chat_id, off(11))

bot = telepot.Bot(‘Bot Token’)
bot.message_loop(handle)
print ‘I am listening…’

while 1:
time.sleep(10)

 

Podemos sencillamente  clonar el script anterior desde  el respositorio  git de Salman mediante  el siguiente camando  git clone:

git clone https://github.com/salmanfarisvp/TelegramBot.git 

[email protected]:~ $ git clone https://github.com/salmanfarisvp/TelegramBot.git
Cloning into ‘TelegramBot’…
remote: Enumerating objects: 25, done.
remote: Total 25 (delta 0), reused 0 (delta 0), pack-reused 25
Unpacking objects: 100% (25/25), done.
[email protected]:~ $

Ahora  tenemos  que asignar el Token obtenido  en pasos anteriores al script por lo tendremos que editar  desde el editor de texto de Python    y  escribir  ahí su valor

 bot = telepot.Bot('TOKEN OBTENIDO DESDE TELEGRAM') 

Salvaremos los cambios  y ejecutaremos  el código  bien con F5 desde el entorno de programacion de Python o bien desde shell  mediante la siguiente orden:

python telegrambot.py 

Ahora  si conectamos un led entre el pin 11 y masa podremos activarlo o desactivarlo desde Telegram enviando al bot  las frases  “on” y “off”: inmediatamente, estemos donde estemos deberiamos poder encender  el LED  o apagarlo  cuando envíamos “on” y “off” a nuestro bot desde Telegram.

 

Obviamente puede modificar el script base de Salman para activar mas cargas ( de hecho hasta 26)  que obviamente pueden ser mas complejas que un  sencillo led ,  como puede ser  un rele , motor , etc mediante el driver adecuado     y a  traves de ordenes desde Telegram ( por ejemplo on1, off1, on2, etc) 

 

 

Cámara trasera inteligente con Raspberry Pi. Parte 1


El término “Coche inteligente” puede tener miles de significados diferentes dependiendo a quién le preguntemos., así que empecemos con una definición   modesta  de algunos componentes que podemos añadir :

  • Información básica sobre el coche, como la marcha engranada, eficiencia de combustible, horas de conducción ,etc.
  • Ayudas a la conducción de tipo ADAS , siendo   los mas comunes la puesta en marcha del  coche delantero, acceso involuntario a línea de separación de carril o aviso de colisión por vehículo delantero que circula  muy próximo
  • Cámara trasera inteligente que avise si un objeto está demasiado cercano
  • etc

Del primer punto lo hemos comentado en diferentes post , explicando que para automóviles de unos 10 años, es decir que cuentan con interfaz ODB2,  es relativamente simple añadir un HUD con toda esta información  con  un HUD conectado por ODB2

Resumidamente los sistemas ADAS  de ayuda  a  la conducción  mas usuales son las siguientes:

  • FCWS   del ingles  Forward Colission Warning Sytem (advertencia de colisión delantera) ayuda al conductor a mantenerse a una distancia segura del vehículo delantero y alerta a los conductores de una colisión inminente con advertencias visuales y audibles.Este sistema permite al dispositivo detectar cuando no se mantiene una distancia segura entre su vehículo y el vehículo delante de usted. El dispositivo determinará la velocidad de su vehículo calculando una distancia estimada de siguiente segura basada en su velocidad.Normalmente para que esta  función pueda estar habilitada se  debe estar  viajando a más de 48KM/H ( a una velocidad de menos de 32 KM/H, se suele  desactivar la función). Precisamente por esta limitacion el FCWS no puede detectar los vehículos que están  alejados más de 40m  o más cerca de 5m.

fcw.png

  • LDWS  del inglés Lane Departure Warning  System  ( SISTEMA DE  ADVERTENCIA DE SALIDA DE CARRIL) monitorea las marcas del carril y avisa al conductor con advertencias visuales y audibles cuando ocurre una salida involuntaria del carril sin la notificación de la señal de giro.Es un mecanismo diseñado para advertir al conductor cuando el vehículo empieza a moverse fuera de su carril (salvo que una señal de la vuelta en esa dirección) en las autopistas y carreteras de la zona. Este sistema está diseñado para minimizar los accidentes por abordar las principales causas de colisiones: error del conductor , distracción y somnolencia.

ldw

  • HMW( VIGILANCIA Y ADVERTENCIA DEL AVANCE DE PISTA)- Mide la distancia al vehículo que está por delante (“headway”) en segundos. Ayuda al conductor a mantener una distancia segura de conducción. Alerta al conductor al entrar en una zona predefinida de “avance peligroso”

.hmw.png

  • FVSA (ALARMA DE INICIO DEL VEHÍCULO DELANTERO ) Notifica al conductor si el vehículo delantero comienza a avanzar en el estado parado completo y el coche del conductor no se mueve en 2 segundos.

fvsa

Casi todas estas ayudas ADAS  están implementadas  en  numerosas cámaras  disponibles en el mercado como vismo en este post destacando por voz propia  el modelo Dash de Garmin

Respecto al ultimo punto de cámaras traseras  , hay muchos kits para  añadir una cámara  trasera a  nuestro vehículos usando una conexión analógica de video compuesto , lo cual se traduce en  que la mayoría de ellas requieren hacer modificaciones al coche  ,por  ejemplo para ubicar la cámara en el porta-matriculas  , o fijar la pantalla especifica   de modo que no siempre en sencilla su instalación .Además las cámaras traseras comentadas requieren una  fuente de alimentación externa alimentándose con los  cables de las luces de atrás de su coche para que automáticamente se enciendan cuando el coche está en marcha lo cual tampoco le  gusta a muchas personas .

Dado que el mercado no ofrece por  el momento soluciones mas avanzadas una idea es usar la Raspberry Pi pues es la plataforma perfecta  porque básicamente es un mini ordenador con un montón de entradas y salidas.

Al conectar una cámara a la Pi, se puede utilizar prácticamente cualquier webcam USB genérica, o  por supuesto  mejor puede usar una  Cámara Pi conectada al conector DSI pues estas ofrecen una mayor calidad , versatilidad y  no  requiere una fuente de alimentación separada (pero asegúrese de tener un montón de cable para ir a la parte posterior del coche)

Solución con Raspberry Pi

Gracias a una Raspberry Pi  por medio del procesamiento de imágenes en efecto  podemos  hacer más inteligente nuestro vehículo y añadir  nuevas funcionalidades

Para esta idea  podemos  usar  los siguientes componentes:

 

Conexión del módulo de cámara

El modulo de cámara de Pi  tiene un mayor rendimiento que una cámara USB  por lo que lo ideal es usar una cámara del tipo compatibles con Raspberry Pi  (se puede comprar por unos 15€ en Amazon) 

No es  problema  la distancia pues con un cable plano  de 200 cm suele ser suficiente para llevar la cámara  hasta la  posición de conducción (puede comprarlo   aqui en Amazon por unos 7,29€ )

Se puede pues llevar el cable plano al l frente del coche y luego conectado a una pantalla de táctil de 7″ de modo que  la Pi y la pantalla táctil pueden ser alimentados por el adaptador USB en el coche.

Estos  son los pasos para instalar la cámara especifica para su uso , con la Raspberry Pi 

    • Localice el puerto de la cámara y conecte la cámara:Connect the camera
    • Poner en marcha la Raspberry Pi 
    • Abra la Herramienta de configuración de frambuesa Pi desde el menú principal:Raspberry Pi Configuration Tool
    • Asegúrese de que está activado el software de la cámara:Camera software enabled
    • Si no está activado, habilítelo y reinicie su Pi para comenzar. Asimismo si va utilizar una pantalla táctil también necesitara activar I2C  y SPI

Es decir resumidamente;  con la Raspberry Pi apagada, debe conectar el módulo de la cámara al puerto de la cámara de la Raspberry Pi,ahora encienda el Pi  y asegúrese de que se activa el software.

Conexión de un pantalla táctil(opcional)

Existen pantallas TFT para Raspberry Pi con  resolución de 320×240 (16-bits) que además son táctiles con una pantalla resistiva. Se entregan montadas y suelen ser  compatible con los modelos Raspberry Pi Model A+, B+ y Pi 2  disponiendo  además de de un conector de 40 pines para los GPIO.

La pantalla y el digitalizador   utilizan los pines I2C (SDA y SCL), SPI (SCK, MOSI, MISO, CE0) y los pines GPIO #24 y #25. Todos los demás pines GPIO no se utilizan así que podrá conectar más cosas como sensores, LEDs etc. Algunos modelos disponen deposiciones para pulsadores miniatura (no incluidos) por si quiere hacer algún otro tipo de interfaz de usuario.

Puede utilizarla utilizar la librería PyGame u otra librería SDL para dibujar directamente en el frame buffer y hacer interfaces propios.

Tenga en cuenta que para que funcione debe tener activado el I2C en tu Pi o se quedará en blanco. Si utiliza la imagen de Adafruit funcionará sin problema, sino puedes ver su tutorial para ver cómo hacerla funcionar.

La conexión de este tipo de pantallas suele ser por el  propio conector de 25 pines  y por hdmi con un adaptador

Respecto al sw, estos son los pasos  que puede  seguir;

!Ojo el conector plano de la pantalla pues es MUY frágil y debe manejarse con cuidado.!

Montaje final

Una vez montada  la pantalla y la cámara , encender el coche, la Pi y la pantalla . Para ver la camara   de la Pi, abra el terminal y ejecute simplemente  el  siguiente  script:

raspivid -t 0

o

raspivid -t 0 --mode 7

Después de entrar esto ,   la imagen captada por la cámara debería aparecer  en pantalla  completa , pero  !ojo !  no lo veremos  si estamos conectado via VNC!, es decir ,solo si estamos conectados a la propia  Raspberry Pi .

Lo bueno de a Raspberry Pi  es que se puede mejorar  esta forma básica , y tal vez incluso establecer un sistema de alerta si un objeto esta   demasiado cerca , así que, ! vamos a trabajar en ese lado!

 

DETECCIÓN DE OBJETOS

Cuando se trata de aplicaciones de  cámaras de seguridad comerciales, generalmente hay al menos dos versiones  .La primera utiliza una superposición de una imagen estática con gamas de color para que visualmente puede determinarse cuánto de  cerca está un objeto. El segundo método utilizara una cámara junto con sw  que puede detectar un objeto qué tan cerca esta al coche y luego avisa cuando algo está demasiado cerca
Veamos en este post en primer lugar le método de overlay, el cual por cierto es el mas usado en los implementaciones de cámaras traseras de coches actuales.

 

 

Cómo agregar un botón de encendido/apagado a la Raspberry Pi


Siempre debemos apagar con  seguridad nuestra Raspberry Pi ,pues de lo contrario nos exponemos  a perder  el sistema de arranque y  tener que volver  a  crear una  imagen  con todo el trabajo que esto conlleva  respecto a las personalizaciones que tanto nos gustan
Raspberry Pi no cuenta con   un pulsador de encendido para intentar competir con su clones  y de este modo  mantener el precio “bajo”,  aunque  sin embargo, es muy fácil  añadir  el suyo propio  como vamos a ver en este post donde añadiremos un botón de encendido a su Raspberry para que puede encender o  apagar esta con total de seguridad .
No nos bastara añadir el pulsador pues tendremos  que usar unos scripts que vigilen  dos pines GPIO (general entrada/salida) en el Pi para que cuando se presione el botón activar o desactivar el  Pi.

 

raspberrypi

¿Por qué es importante un botón de encendido ?

Como comentábamos  nunca deberíamos “tirar” del cable de alimentación de su Raspberry Pi pues esto puede conducir a la corrupción de los datos graves (y en algunos casos, dañar físicamente tu tarjeta SD) pues para ello se puede cerrar con seguridad el Pi a través de un comando de consola (shutdown)  o por supuesto también  desde el propio interfaz gráfico de Raspian (shutdown)

Veamos  ahora como podemos añadir un pulsador  pero entes tenemos que entender cómo despertar la Raspberry Pi de un estado de suspensión antes de construir la funcionalidad de apagado.

Una manera fácil de comprobarlo es apagando  con sudo shutdown -h now y conectando los pines 5 y 6 con un cable hembra a hembra. Sólo necesitará cortarlo momentáneamente y entonces usted debe encontrar que la Raspberry Pi se “despertó”.

En este punto es interesante destacar que cuando “apaga” el Pi, lo enviará en un estado de suspensión, lo cual significa  que sigue consumiendo una cantidad muy pequeña de  energía ( muy  similar a cómo todos modernos equipos trabajo cunado quedan en stand-bye).

Lógicamente  si  agrega un botón de encendido podrá tanto detener como despertar el Pi de un estado detenido, pero si su Raspberry Pi se ha apagado, usted puede desconectar de forma segura la fuente de alimentación  sin la preocupación de corrupción de datos.

 

El equipamiento hardware como vemos es muy sencillo pues basta dos cablecillos que conectaremos en los pines 5 y 6  de la Raspberry PI del conector de expansión( justos los dos de la tercera columna empezando por la drecha)

IMG_20181018_224306[1].jpg

 

Sencillamente, si se cortocircuitan entre sí los pines 5 y 6 (GPIO3 y GND) se pondrá nivel bajo el pin correspondiente al GPIO y podremos actuaren consecuencia con la Raspberry Pi

Obviamente el cortocircuito lo sustituiremos por un pequeño pulsador normalmente abierto  que conduciremos con dos cablecillo  a los pines 5 y 6  de nuestra Raspbery Pi

 

IMG_20181018_224929[1]

Finalmente sujetaremos el pulsador con cinta de doble cara , pegándolo o practicando un agujero al contenedor de la Raspberry Pi

 

IMG_20181018_225410[1]

 

 

La solución de sleep es bastante sencilla, pero para cerrar con seguridad el Pi vamos a tener que utilizar una solución de software. Ya que sabemos que vamos a utilizar los pines 5 y 6 para el Pi, vamos a usar estos pines para apagarlo tambien . Tanto así que podemos conectar nuestro botón a los alfileres y se concluirá y despertar la Pi.

Vamos a tener que escribir un script que escuche una pulsación y  cierre el Pi. Antes nos fijamos en la secuencia de comandos, vamos a discutir algunos enfoques diferentes. En primer lugar, podríamos escribir un script que inicie un bucle infinito y espere un cambio en el estado de los pines GPIO.

Usando  seudo-código, podría ser algo como:

while True:
    if GPIO3 is pressed:
        shutdown the pi

Mientras que esto funcionaría y probablemente no tenga problema de rendimiento real, hay realmente una manera mejor:podemos escuchar  una interrupción (un cambio de estado de bajo a alto o alto a bajo) que interrumpa  el procesador para qeu realize uan determinada accion .

Afortunadamente la biblioteca de RPi.GPIO proporciona un método llamado wait_for_edge que bloqueará la ejecución de nuestro script hasta que se detecte una interrupción. Así configuramos GPIO3 y una vez que detectamos un borde de caída vamos a apagar el Pi.

Entonces, vamos a usar un script llamado listen-for-shutdown.py.

Para crear el script, podemos usar el editor nano asi  que después de conectar con el Pi, ejecute el siguiente comando para crear este

sudo nano listen-for-shutdown.py

Luego, pegue el código siguiente en el archivo y pulse CTRL-X y salida, Y para guardar cuando se le solicite.

#!/usr/bin/env python


import RPi.GPIO as GPIO
import subprocess


GPIO.setmode(GPIO.BCM)
GPIO.setup(3, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.wait_for_edge(3, GPIO.FALLING)

subprocess.call(['shutdown', '-h', 'now'], shell=False)

A continuación necesitamos poner este script en el arranque por lo que  deberemos copiar el script en lar uta de  usr y hacerlo ejecutable , acciones que haremos con los dos siguintes comandos:

sudo mv listen-for-shutdown.py /usr/local/bin/
sudo chmod +x /usr/local/bin/listen-for-shutdown.py

Pero este script solo apagaria la placa  y nosotros queremso tambien qeu se pueda arrancar pulsando el boton por lo que  añadiremos otro script llamado listen-for-shutdown.py: que e enciende/apaga nuestro servicio.

Para crear el script  escriba  la secuencia de comandos:

sudo nano listen-for-shutdown.sh

Introduzca el código siguiente en el archivo y guárdelo:

#! /bin/sh

### BEGIN INIT INFO
# Provides:          listen-for-shutdown.py
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
### END INIT INFO

# If you want a command to always run, put it here

# Carry out specific functions when asked to by the system
case "$1" in
  start)
    echo "Starting listen-for-shutdown.py"
    /usr/local/bin/listen-for-shutdown.py &
    ;;
  stop)
    echo "Stopping listen-for-shutdown.py"
    pkill -f /usr/local/bin/listen-for-shutdown.py
    ;;
  *)
    echo "Usage: /etc/init.d/listen-for-shutdown.sh {start|stop}"
    exit 1
    ;;
esac

exit 0

 

Ahora necesitamos coloque este archivo en /etc/init.d y hacerlo ejecutable, acciones que haremos con los dos siguientes comandos.

sudo mv listen-for-shutdown.sh /etc/init.d/
sudo chmod +x /etc/init.d/listen-for-shutdown.sh

Ahora registramos la secuencia de comandos para ejecutar en el arranque y le pasaremos el parámetros de arranque con los dos siguientes comandos.

sudo update-rc.d listen-for-shutdown.sh defaults
sudo /etc/init.d/listen-for-shutdown.sh start

 

Seguro querido lector que por lo menos la próxima vez que desconecte su Raspberry de forma violenta recuerda que podría haber puesto un botón para hacer el apagado seguro…  Y por cierto si tiene una Orange Pi u otro clon , este sencillo truco le puede servir tambien..

 

 

Fuente  howchoo.com