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

 

Como crear una cuenta de gmail para su hijo de forma segura de acuerdo con la legalidad


Ahora que su hijo comienza a usar su primer dispositivo Android  o simplemente necesita una cuenta de correo  electrónico robusta  y confiable  la aplicación Family Link de Google puede ayudar a establecer ciertas reglas digitales básicas pues de hecho se puede crear una cuenta de Google para él similar a la suya , y además gestionar sus aplicaciones, supervisar el tiempo que pasa delante de la pantalla o bloquear de forma remota su dispositivo, entre otras opciones.

En el caso de que requiera supervisar la tableta o el terminal  para padres, madres o tutores pueden ejecutar Family Link en dispositivos Android 4.4 (Kit Kat) o versiones posteriores, y en dispositivos iPhone con iOS 9 o versiones posteriores. Sin  embargo para los niños ,estos  pueden ejecutar Family Link en dispositivos Android 7.0 (Nougat) o versiones posteriores aunque . Es posible que los dispositivos con Android 5.0 y 6.0 (Lollipop y Marshmallow) también puedan ejecutar Family Link.

Con esta app  se puede por tanto:

  • Gestionar las aplicaciones que puede utilizar si hijo de  modo que tecibirá una notificación en su dispositivo que le permitira autorizar o bloquear las aplicaciones que su hijo quiere descargar de Google Play Store.
  • Supervisar el tiempo de pantalla limitando el tiempo de uso del dispositivo, definiendo una hora de acostarse y pudiendo comprobar con qué frecuencia usa su hijo sus aplicaciones favoritas.
  • Bloquear el dispositivo de su hijo de forma remota de modo qeu permite bloquear el dispositivo de su hijo u ocultar determinadas aplicaciones cuando sea el momento de jugar, estudiar o dormir.

 

En el caso de que quiera crear una cuenta de gmail, también puedes crear una cuenta de Google para su hijo menor de 13 años o la edad aplicable en tu país, y gestionarla con Family Link. Con las cuentas de Google, los niños pueden acceder a productos de Google, como la Búsqueda, Chrome ,y  Gmail.

Cuando su hijo cumpla 16 años (o la edad que corresponda según la legislación vigente en tu jurisdicción), podrá decidir si quiere cambiar a una cuenta de Google normal. Antes de esa fecha, el padre, la madre o el tutor recibirán un correo electrónico en el que se les notificará que su hijo podrá hacerse cargo de su cuenta el día de su cumpleaños, por lo que ya no podrán seguir gestionándola. El día que cumpla 16 años, el niño podrá elegir si quiere gestionar su propia cuenta de Google o dejar que su padre, madre o tutor sigan haciéndolo.

 

 

Pasos para crear una cuenta de gmail para su hijo

Esta es la url  para crear una nueva cuenta de gmail https://accounts.google.com/signup/v2/webcreateaccount?hl=es-419&flowName=GlifWebSignIn&flowEntry=SignUp

A continuación no saldrá el formulario  para que ingresemos el nombre de la nueva cuenta  y su contraseña

crear.PNG

Rellenados esos campos, si la cuenta no existe aun en los servidores de g-mail  , nos permitirá  dar  a “siguiente” para continuar con el proceso, ,   donde ahora nos pedirá un teléfono (opcional) , la fecha real de nacimiento  y el genero ( opcional)

Creo que en este caso deberíamos ser honestos  y contestar con la fecha real

preuebceilla

Ahora , una vez detectada la edad del menor precisamente nos saltara la vinculación a otra cuenta de gmail de su tutor.

vincular

Una vez pulsemos siguiente   tendremos que introducir nuestra cuenta de correo  vinculada a la cuenta de google ( es decir nuestra cuenta de gmail)

A continuación nos pedirá la clave  de nuestra cuenta de google y si es correcta  ya nos aparecerá información sobre la gestión de la cuenta:

cverifiacion1.png

Le daremos a siguiente, y  nos aparecerá el consentimiento de unir la cuenta del menor a la cuenta el grupo familiar

unira

Como administrador de un grupo familiar en Google, sera el único miembro que puede realizar acciones como las siguientes:

  • Agregar o quitar miembros del grupo familiar
  • Borras el grupo familiar
  • Suscríbirse a los servicios familiares de Google o cancelar la suscripción

Ahora  simplemente daremos Aceptar y  hecho esto  nos repetirá la información para que lo verifiquemos que todo es correcto:

confrimacion.png

Ahora viene el tema  problemático  de la cuenta

previatraejeta.png

Ahora  nos da el texto legal explicando el  consentimiento parental de aviso de divulgación de Family Link para padres

Estas son las primerlas lineas:

divulgacion

Es interesante  marcar  en un principio las condiciones mas restrictivas , es decir:

  • No guardar el “Historial de búsqueda” de YouTube de mi hijo en su cuenta de Google
  • No guardar el “Historial de reproducciones” de YouTube de mi hijo en su cuenta de Google
  • No guardar la “Actividad web y de aplicaciones” de mi hijo en su cuenta de Google

noguardar.PNG

Una vez cumplimentado viene el aspecto mas delicado,pues si quiere crear una cuenta de Google para su hijo, debemos dar el consentimiento parental, mediante una tarjeta de crédito ( Y NO HAY MODO DE SALTARSE ESTE PASO)

Aseguran que no nos cobraran nada pues  la emplearan para generar una autorización temporal en la tarjeta con la que verificaremos que es válida la cual en la mayoría de los casos, las autorizaciones temporales desaparecen de la cuenta en un plazo de 48 horas, es decir es un método por el que quieren asegurarse que somos las personas que decimos ser

Nos pedirá  por tanto una tarjeta  bancaria  (en caso de no tener registrada ninguna)   y  en caso de tenerla registrado  el CVV de la tarjeta

Este código aparece en las tarjetas de crédito, de débito y en las tarjetas prepago cuando se recargan. El CVV se compone de tres dígitos en las tarjetas Visa y MasterCard que aparecen impresos en la banda de la firma, situado en el reverso de la tarjeta.

Por cierto las tarjetas de prepago o   virtuales ( incluso sin saldo) son admitidas  ,

visa

Comprobada la validez de la tarjeta, ya solo queda aceptar

creaste.png

Ya ha terminado el  proceso,  de modo que si va a su correo de gmail podrá comprobar qeu se ha registrado la cuenta de su hijo correctamente.

Solo una cuestión mas ,para que su hijo pueda comprobar su correo , una vez ingrese la cuenta del menor , gmail le pedirá al responsable de la cuenta de google family que también introduzca  su contraseña y ya podrá ver el menor ver su correo el cual obviamente estará protegido  por google dada la casuistica particular

 

Mas información en  https://myaccount.google.com/?pli=1&nlr=1

 

 

Como eliminar protección de escritura en una unidad extraible USB


Después de haber trabajado con versiones Linux utilizando su memoria flash sobrescrita o con varias particiones, es posible que desee volver a una partición única (es decir restaurar la unidad flash a su estado original) para que pueda volver a leerse por todas los ordenadores .Asimismo es relativamente habitual cuando se comparten unidades USB entre sistemas Linux  como Lubuntu   y Windows  terminar dejando estas unidades  inaccesibles.Asimismo  incluso sin haber insertado la unidad en un equipo Linux   puedea que tampoco deje de responder

Casi siempre la unidad extraible USB    o las propias trajestas SD o micro-sd  tanto al conectarlas a un equipo Windows como un equipo Linux o Windows  , no permiten su formateo  desde el propio interfaz, respondiendo del mismo modo:

  • Error de Protección de escritura(Read-only)
  • Introduzca una unidad extraible

Hay una herramienta  para entorno Windows von suerte nos puede ser muy útil para Restaurar una unidad flash utilizando HP USB Format Tool , pues  como se  ve en la pantalla   es bastante intuitiva su modo de funcionamiento:

hpformat.PNG

No obstante como se puede apreciar en la imagen , no siempre podrá resolver el problema , así que antes de tirar la toalla   puede probar  las tres siguientes herramientas:

 

 Método manual a través de Diskpart – Windows

Diskpart es una utilidad de línea de comandos que permite administrar discos. Algunos comandos sólo pueden ser accedidos a través de Diskpart y no mediante el “Administrador de discos” de Window .

Al estar integrada con Windows , su uso es bastante sencillo como vamos a ver;

  1. Ejecute desde el interfaz de Cortana  cmd.exe
  2. Escriba Diskpart y presione Enter
  3. Se abrira  una nueva ventana ademas del la interfaz  comandos
  4. Escriba List Disk y presione Enter. Observe que aparece un numero junto a la palabra “Disco”
  5. Escriba Seleccione Disco X donde X es el número de disco de su unidad USB (en el ejemplo x=1 ) y presione Intro.
  6. Escriba Clean (Limpiar)  y presione Entrar
  7. Escriba Create Partition Primary y presione Enter
  8. Escriba Active y presione Entrar
  9. Escriba Format fs = Fat32 Quick y presione Entrar
  10. Escriba Salir y presione Entrar

diskpart

Aternativamente si Diskpart   no ha servido , los usuarios de Windows pueden usar la herramienta  BOOTICE:

  1. Descargue , extraiga y ejecute la herramienta BOOTICE de Pauly
  2.  Seleccione su unidad flash USB de la lista, (2) Haga clic en Parts Manage( Administrar partes )
  3.  Haga clic en Re-Partitioning ( Reparticionar )
  4.  En Modo disco, elija USB-FDD , USB-HDD , o modo USB-ZIP . Uso USB-HDD ya que funciona con cada BIOS que uso. >(2) Haga clic en Aceptar

 

 SdFormatter :

Los usuarios de Windows y / o Mac OS pueden usar la herramienta SD Formatter para reformatear y restaurar una unidad SD o USB  .Este método no siempre es eficaz para unidades USB pero bastante fiable para SD   así que merece  la pena intentarlo

sdfor

Para aquellos que prefieran   Linux, esta tarea se puede realizar  a través de  linea de comandos ,pero debemos advertir querido lector que si no le ha respondido los métodos anteriores tampoco probablemente le   funcione ,pero si tiene un equipo Linux ( por ejemplo con Lubuntu)  ,tal  vez merzca la pena intentarlo

Primero, debemos eliminar las viejas particiones que permanecen en la llave USB.

    1. Vaya a la consola del sistema
    2. Ejecute sudo su
    3. Escriba la contraseña del administrador
    4. Escriba fdisk -l y anote la letra de su unidad USB.
    5. Escriba fdisk / dev / sd x (reemplazando x con la letra de su unidad)1 para seleccionar la primera partición y presione enter
    6. Escriba d para proceder a eliminar una partición
    7. Escriba d para proceder a eliminar otra partición (fdisk debería seleccionar automáticamente la segunda partición)

Luego, necesitamos crear la nueva partición.

  1. Escriba n para crear una nueva partición
  2. Escriba p para hacer que esta partición sea primaria y presione enter .1 para hacer que esta sea la primera partición y luego presione enter 
  3. Presione enter para aceptar el primer cilindro predeterminado
  4. Presione enter nuevamente para aceptar el último cilindro predeterminado
  5. Escriba w para escribir la nueva información de partición en la llave USB
  6. Escriba umount / dev / sd x 1 (reemplazando x con la letra de su unidad)

El último paso es crear el sistema de archivos .

  1. Escriba mkfs.vfat -F 32 / dev / sd x 1 (reemplazando x con la letra de la unidad de memoria USB)

Eso es todo, ahora deberías tener una llave USB restaurada con una sola partición 32 que se deberia poder leer desde cualquier ordenador

 

Como enviar correos con adjuntos desde Linux desde linea de comandos


Es frecuente   en el manejo de maquinas Linux  usar muchos scripts en bash o c-shell para automatizar tareas  de una forma sencilla, dado  que al contrario de lo que muchas personas piensan,   shell script (o c-shell)  son  bastantes potentes  a la hora de manipular información .

Ante la cuestión de cómo enviar un correo electrónico desde linea de comandos  o desde un script , incluso  con archivos adjuntos desde una máquina Linux ,    lo primero   que pensamos es usar  la utilidad  mailx la cual mejora en muchos aspectos a la utilidad mail de viejos sistemas

La sintaxis básica para enviar correos electrónicos desde una máquina Linux mediante el comando mailx se muestra a continuación:

mailx -vvv -s   $asunto -r   $from  -S   $smtp     $destino

Como vemos , podemos   observar  varios parámetros en la  línea  anterior;

  • -vvv = Verbosity.
  • -s = especifica el asunto (subject).
  • -r = especificar el origen del Email.
  • -S = especifica el  smtp server.

Y lo ideal es usar variables:

  • $asunto: almacenamos el asunto ( subject ) del correo
  • $from : almacenamos el usuario que envía el correo
  • $smtp : almacenamos el servidor de correo
  • $destino : almacenamos  la dirección de correo destinatario  ( pueden poner sucesivas separando con espacios estas)

El comando anterior se puede complementar añadiendo   un cuerpo al contenido del correo  gracias al comando echo redirigiendo con el pipe (|)  hacia mailx

 echo  $cuerpo  | mailx -vvv -s   $asunto -r   $from  -S   $smtp     $destino

Dónde  $cuerpo  es  una variable que almacena el cuerpo del  email

person using macbook pro on brown wooden desk

Photo by rawpixel.com on Pexels.com

Es importante destacar que podemos obviar el servidor  stmp server si está configurado en la máquina así  como el origen del correo obvio , quedando su uso habitual tal como sigue:

 echo  $cuerpo  | mailx  -s   $asunto  -S     $destino1  $destino2  $destino3

Como se aprecia,   se  añade   un cuerpo al contenido del correo  gracias al comando echo redirigiendo con el pipe (|)  hacia mailx y se usan varias variables:

  • $cuerpo  es  una variable que almacena el cuerpo del  email
  • $asunto: almacenamos el asunto ( subject ) del correo
  • $smtp : almacenamos el servidor de correo
  • $destino1 : almacenamos  la dirección de correo destinatario
  • $destino2 : almacenamos  la dirección de correo destinatario
  • $destino3 : almacenamos  la dirección de correo destinatario

Anexando  adjuntos

Si   la versión de mailx que esta usando está por encima  de 12.x,e puede usar el nuevo interruptor adjunto (-a) en mailx para enviar archivos adjuntos con el correo ,  lo cual es una opción más simple  que el comando uuencode.

Como ejemplo mandar un fichero  a un destinatario, es muy sencillo usando el siguiente comando:

mailx -a $file  -s  $asunto  $destino1

En l comando anterior  se usan estas variables :

  • $asunto: almacenamos el asunto ( subject ) del correo
  • $destino1 : almacenamos  la dirección de correo destinatario
  • $file: ruta directa cal fichero a  anexar

El comando anterior imprimirá una nueva línea en blanco en el cuerpo del mensaje  aunque puede escribir el cuerpo del mensaje  presionar [ctrl] + [d] para enviar, lo cual  adjuntará el archivo al correo electrónico saliente correctamente con el Content-Type y encabezados  apropiados.

Para hacer esto más “scriptable”, puede enviar el mensaje sin un cuerpo con el siguiente comando:

mailx -a $file  -s  $asunto  $destino1< /dev/null

Para enviar correos con un cuerpo de mensaje, reemplace / dev / null en el comando anterior con su archivo de cuerpo de mensaje.

mailx -a $file  -s  $asunto  $destino1<   $cuerpo

Donde $cuerpo  es  una variable que almacena el cuerpo del  email

En esta  versión de mailx, los encabezados que se usan en el correo electrónico saliente cambian de:

From:
Date:
To:
Subject:

A la forma siguiente:

From:
Date:
To:
Subject:
User-Agent:
MIME-Version:
Content-Type:
Content-Transfer-Encoding:

Si la versión de mailx está por debajo de 12.x, puede usarse el comando uuencode para enviar correos con archivos adjuntos.

El comando uuencode  se utiliza para codificar un archivo binario.De forma predeterminada, uuencode tiene entrada desde la entrada estándar y escribe en la salida estándar como se muestra a continuación ( esa es la razón por la que se repite el nombre del fichero) utilizando  por defecto el formato de codificación estándar de UU.

 uuencode  $fichero $fichero | mailx -s $asunto  $destino

Usando el formato anterior ,como se aprecia, se  añade   un cuerpo al contenido del correo  gracias al comando echo redirigiendo con el pipe (|)  hacia mailx  , de forma similar a añadir un cuerpo al  correo ,  pero esta vez estamos anexamos un fichero previamente codificado con uuencode

Las variables usadas:

  • $asunto: almacenamos el asunto ( subject ) del correo
  • $destino : almacenamos  la dirección de correo destinatario
  • $fichero : almacenamos  la ruta completa del fichero a adjuntar
  •  $fichero : almacenamos  la misma  ruta completa del fichero a adjuntar ( en efecto se repite y no es un error)

Por cierto, en caso de necesitar adjuntar varios ficheros, puede usar esta receta:

uuencode $fichero1 $fichero1  >/tmp/out.mail

uuencode $fichero2 $fichero2  >/tmp/out.mail

cat email-body.txt >>/tmp/out.mail

Y ahora ya si podemos  enviar el correo:

mailx -s $asunto  $destino </tmp/out.mail

high angle view of paper against white background

Photo by Pixabay on Pexels.com

Correos con anexos y cuerpo

La sintaxis  para enviar correos electrónicos desde una máquina Linux mediante el comando mailx  puede tener problemas a la hora de incluir  además de anexo un cuerpo  en el mensaje, por lo que podemos usar en su lugar el comando mutt usando la siguiente sintaxis:

echo $body | mutt -s $asunto -a $fichero  $destino1  $destino2 $destino3

Como vemos , podemos   observar  varios parámetros en la  línea  anterior;

  • -s = especifica el asunto (subject).
  • -a = especifica el nombre del fichero con la ruta completa

Y como en  los ejemplos anteriores , lo ideal es usar variables:

  • $asunto: almacenamos el asunto ( subject ) del correo
  • $destino1 : almacenamos  la dirección de correo destinatario
  • $destino2 : almacenamos  la dirección de correo destinatario
  • $destino3 : almacenamos  la dirección de correo destinatario
  • $body : almacenamos el cuerpo del correo

Sistema de detección de carril con opencv


Kemal Ficici     nos demuestra  con su proyecto escrito en  python,  que por cierto  ha publicado con su código completo en  github,   como es posible usando la librería  OpenCv    construir un detector de carril   que  incluso  maneja carriles con  curvas.

A pesar del gran avance , sin embargo el autor  reconoce  que la salida de su sistema  todavía se ve afectada por sombras y drásticos cambios en la textura de la carretera  lo cual invalida en gran parte su resultado ,  lo cual  le hace  pensar en futuras actualizaciones de su proyecto  haciendo  uso de técnicas de aprendizaje automático para llegar a desarrollar un sistema de detección de vehículo e increíblemente robusto carril.

En el siguiente video podemos ver el resultado de su trabajo:

En cualquier escenario de conducción, las líneas de carril son un componente esencial de lo que indica el flujo de tráfico y donde se debe conducir un vehículo  así  que también es un buen punto de partida en el desarrollo de  niveles de automatismos de ayuda a la conducción ( Sistemas ADAS).
En un proyecto anterior de detección de carril  Kemal  había implementado un sistema de detección de carril  que funcionaba decentemente en perfectas condiciones, sin embargo no detectaba curvas carriles con precisión y no era robusta a obstrucciones y sombras, de modo que  esta nueva versión mejora su   primera propuesta puesto que ha implementado  detección de lineas  curvas en los carriles , de modo que   funciona mucho mejor y es más robusto para entornos exigentes.

El sistema de detección de carril ha sido  escrito en Python usando la librería OpenCV y ha seguido resumidamente las siguientes etapas en el  procesamiento de imagen:

  • Corrección de distorsión
  • Deformación de la perspectiva
  • Filtro de Sobel
  • Detección de picos del histograma
  • Búsqueda de ventana deslizante
  • Ajuste de curvas
  • Superposición de carril detectado
  • Aplicar el resultado a  la salida  al vídeo

Respecto al hardware utililizado :

  • Nvidia Jetson TX2×1
  • Raspberry Pi 3 Model B×1

 

 

Corrección de distorsión

Las  lentes de las cámaras distorsionan la luz entrante al  enfocarla en el sensor de la cámara o CCD . Aunque esto es muy útil porque nos permite capturar imágenes de nuestro entorno, a menudo terminan distorsionando la luz ligeramente de forma imprecisa lo cual  puede ofrecernos medidas inexactas en aplicaciones de visión por ordenador . No obstante  fácilmente podemos corregir esta distorsión calibrando la imagen de un objeto conocido ( por ejemplo  tablero de ajedrez asimétrico,)y generando un modelo de distorsión que represente las distorsiones de la lente.

La cámara utilizada en la prueba video  fue utilizada para tomar 20 imágenes de un tablero de ajedrez, que fueron utilizados para generar el modelo de distorsión.El autor comenzó por convertir la imagen a escala de grises y  entonces aplico la  función cv2.findChessboardCorners .Como sabemos que este tablero de ajedrez es un objeto tridimensional  con líneas rectas exclusivamente podemos aplicar algunas transformaciones a las esquinas detectadas para alinearlos correctamente utilizando cv2.CalibrateCamera()  obteniendo así  los coeficientes de distorsión y la matriz de cámara  de modo que  así  ya estaba calibrada la cámara

Realizado el proceso anterior se puede utilizar  cv2.undistort()  para corregir el resto de sus datos de entrada.

Como demostración en la imagen se puede ver la diferencia entre la imagen original del tablero de ajedrez y la imagen corregida a continuación:

ajedrez

Aquí está el código exacto que usó el autor para esto:

def undistort_img():
    # Prepare object points 0,0,0 ... 8,5,0
    obj_pts = np.zeros((6*9,3), np.float32)
    obj_pts[:,:2] = np.mgrid[0:9, 0:6].T.reshape(-1,2)
    # Stores all object points & img points from all images
    objpoints = []
    imgpoints = []
    # Get directory for all calibration images
    images = glob.glob('camera_cal/*.jpg')
    for indx, fname in enumerate(images):
        img = cv2.imread(fname)
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        ret, corners = cv2.findChessboardCorners(gray, (9,6), None)
        if ret == True:
            objpoints.append(obj_pts)
            imgpoints.append(corners)
    # Test undistortion on img
    img_size = (img.shape[1], img.shape[0])
    # Calibrate camera
    ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, img_size, None,None)
    dst = cv2.undistort(img, mtx, dist, None, mtx)
    # Save camera calibration for later use
    dist_pickle = {}
    dist_pickle['mtx'] = mtx
    dist_pickle['dist'] = dist
    pickle.dump( dist_pickle, open('camera_cal/cal_pickle.p', 'wb') )
def undistort(img, cal_dir='camera_cal/cal_pickle.p'):
    #cv2.imwrite('camera_cal/test_cal.jpg', dst)
    with open(cal_dir, mode='rb') as f:
        file = pickle.load(f)    mtx = file['mtx']
    dist = file['dist']
    dst = cv2.undistort(img, mtx, dist, None, mtx)
    return dst
undistort_img()
img = cv2.imread('camera_cal/calibration1.jpg')
dst = undistort(img) # Undistorted image

Y ahora podemos ver  la corrección de distorsión aplicada a una imagen de la carretera.

imagencorregida.png

Solo se puede notar  diferencias leves, pero esto como veremos puede tener un impacto enorme en el tratamiento de la imagen.

Deformación de la perspectiva

La detección de carriles con trazados curvas  en espacios de la cámara espacio no es uan tarea  fácil asi que la idea es  conseguir una vista de pájaro de las pistas , lo cual se e puede hacer aplicando una transformación de perspectiva en la imagen. Aquí es lo que parece:

carril

Como vemos nos es nada espectacular debido a que el carril esta sobre una superficie plana en 2D, asi  que podemos encajar un polinomio que puede representar fielmente el carril en el espacio del carril

Puede aplicar estas transformaciones a cualquier imagen usando la función cv2.getPerspectiveTransform()  para obtener la matriz de transformación, y  aplicar la función cv2.warpPerspective() a una imagen.

Aquí está el código que uso el autor para ello:

def perspective_warp(img,
                     dst_size=(1280,720),
                     src=np.float32([(0.43,0.65),(0.58,0.65),(0.1,1),(1,1)]),
                     dst=np.float32([(0,0), (1, 0), (0,1), (1,1)])):
    img_size = np.float32([(img.shape[1],img.shape[0])])
    src = src* img_size
    # For destination points, I'm arbitrarily choosing some points to be
    # a nice fit for displaying our warped result
    # again, not exact, but close enough for our purposes
    dst = dst * np.float32(dst_size)
    # Given src and dst points, calculate the perspective transform matrix
    M = cv2.getPerspectiveTransform(src, dst)
    # Warp the image using OpenCV warpPerspective()
    warped = cv2.warpPerspective(img, M, dst_size)
    return warped

Filtro de Sobel

En otras versiones una opción era filtrar las líneas de carril con el color peor sin embargo, esto no siempre es la mejor opción. Si el camino utiliza luz de color concreta en lugar de asfalto, el camino pasa fácilmente a través del filtro de color, y esta la percibirá como una línea de carril blanco, pero  eso no es correcto.

En su lugar, podemos utilizar un método similar al detector de borde, esta vez para filtrar hacia fuera de la carretera. Las líneas de carril suelen tienen un alto contraste en  la carretera, por lo que podemos utilizar esta peculiaridad para nuestro beneficio. La funcion detector de borde  Canny utilizado anteriormente  hace uso de Operador de Sobel , para obtener el gradiente de una función de la imagen. La documentación de OpenCV tiene una fantástica explicación sobre cómo funciona asi que utilizaremos esto para detectar zonas de alto contraste para las marcas de carril filtro e ignorar el resto del camino .

Todavía utilizaremos el espacio de color HLS nuevamente, esta vez para detectar cambios en la saturación y la ligereza. Los operadores de sobel se aplican a estos dos canales, y extraemos el gradiente con respecto al eje x y añadiremos los píxeles que pasan nuestro umbral de degradado a una matriz binaria que representa a los píxeles de nuestra imagen. Aquí está como se ve en cámara espacio y lane

blancoynegro.PNG:

Tenga en cuenta que las partes de la imagen que estaban más lejos de la cámara no conserven su calidad muy bien. Debido a las limitaciones de resolución de la cámara, datos de los objetos más lejos son muy borrosos y ruidosos  pero no necesitamos concentrarnos en la imagen, para que podamos utilizar sólo una parte de esta.

Detección de picos del histograma

Ahora aplicaremos un algoritmo especial llamado Sliding Window Algorithm ( algo asi como algoritmo  Desplazamiento de Ventana )para detectar nuestras líneas de carril. Sin embargo, antes de que lo podemos aplicar, debemos determinar un buen punto de partida para el algoritmo pues este funciona bien si comienza en un lugar donde haya píxeles de lineas  presentes, pero ¿cómo podemos detectar la ubicación de estos píxeles de carril en primer lugar?

Estará recibiendo un histograma de la imagen con respecto al eje X. Cada parte del histograma siguiente muestra píxeles blancos en cada columna de la imagen. Entonces tomamos los picos más altos de cada lado de la imagen, uno para cada línea de carril y tendríamos resulto esta parte

Aquí vemos como  el histograma parece, al lado de la imagen binaria:

histograma

Búsqueda de ventana deslizante

Ahora  necesitamos  utilizar el algoritmo de ventana deslizante para distinguir entre los límites del carril de la izquierda y derecha para que podemos caber dos curvas diferentes que representan los límites del carril.

El algoritmo sí mismo es muy simple. A partir de la posición inicial, la primera ventana mide cuántos píxeles se encuentran dentro de la ventana. Si la cantidad de píxeles alcanza un cierto umbral, desplaza la siguiente ventana a la posición lateral media de los píxeles detectados. Si no se detectan los suficientes píxeles, comienza la siguiente ventana en la misma posición lateral.

Esto continúa hasta que las ventanas alcanzan el otro borde de la imagen .Asimismo los píxeles que corresponden a las ventanas reciben un marcador.

En las imágenes de abajo, los píxeles marcados azules representan el carril derecho, y los rojos representan la izquierda:

lineas

Ajuste de curvas

El resto del proyecto es ya mas fácil. Aplicamos la regresión polinomial para los pixeles rojos y azules individualmente usando np.polyfit() , y entonces el detector se hace  sobre todo

Esto es lo que parecen las curvas:

 

Superposición de carril detectado

Ya estamos en la parte final del sistema de detección: la interfaz de usuario. Simplemente creamos una superposición que llena en la parte detectada del carril, y luego  finalmente lo aplicamos al vídeo.

Este es el resultado final

 

 

!Sin duda un resultado  realmente espectacular que puede servir de partida para proyectos  mas ambiciosos!

Mas información en www.hackster.io

 

Como crear musica gracias a machine learning con Raspberry Pi


La tecnología siempre ha desempeñado un papel en la creación de nuevos tipos de sonidos que inspiran a los músicos, desde los sonidos de distorsión hasta los sonidos electrónicos de los sintetizadores,sin embargo gracias a los avances en el aprendizaje automático y las redes neuronales han abierto nuevas posibilidades para la generación de sonido  como los demuestra el  grupo Magenta de Google que es el que ha creado NSynth Super,   basandonase en una Raspberry Pi 3  y utilizando Machine Learning con TensorFlow para explorar nuevos sonidos y melodías a músicos y artistas(TensorFlow es una biblioteca de código abierto para aprendizaje automático a través de un rango de tareas, y desarrollado por Google para satisfacer sus necesidades de sistemas capaces de construir y entrenar redes neuronales para detectar y descifrar patrones y correlaciones, análogos al aprendizaje y razonamiento usados por los humanos).

 

El proyecto es  totalmente abierto y “cualquiera” familiarizado con  la electronica debería podérselo construir en su propia casa o en el taller, aunque esto es la teoría pues en la practica todos los componentes son SMD ,lo cual complica las cosas bastante a la hora de ponerse a soldar los diferentes componentes que  constituyen ese proyecto.

Usando TensorFlow , han   construido herramientas e interfaces que permiten a artistas y músicos utilizar el aprendizaje automático en su trabajo. El algoritmo NSynth Super AI usa redes neuronales profundas para investigar el carácter de los sonidos y luego construye nuevos sonidos basados ​​en estas características en lugar de simplemente mezclar los sonidos.

Usando un autoencoder, extrae 16 características temporales definitorias de cada entrada. Estas características se interpolan linealmente para crear nuevas incrustaciones (representaciones matemáticas de cada sonido).

Estas nuevas incrustaciones se decodifican en nuevos sonidos, que tienen las cualidades acústicas de ambas entradas (se pueden encontrar más detalles en la página NSynth: Neural Audio Synthesis ).

 


Open NSynth Super luego toma el audio generado y proporciona una interfaz física o instrumento con:

    • Entrada MIDI para conectar un teclado de piano, un secuenciador o una computadora, etc.
    • Cuatro codificadores giratorios utilizados para asignar instrumentos a las esquinas del dispositivo
    • Pantalla OLED para el estado del instrumento y la información de control
    • Controles finos para:
      • La posición estableciendo la posición inicial de la onda.
      • Attack establece el tiempo necesario para el inicio inicial del nivel.
      • Decay establece el tiempo necesario para el posterior agotamiento.
      • Sustain establece el nivel durante la secuencia principal del sonido.
      • Release establece el tiempo necesario para que el nivel disminuya desde el nivel de sostenido a cero.
      • El volumen establece el volumen de salida.
    • Interfaz táctil para explorar las posiciones entre los sonidos.

Obviamente la Rasbpeberry   es usada  para  administrar las entradas físicas y esto se programa antes del primer uso.

 

 

El equipo publica todos los diseños de hardware y software que son parte de su investigación en curso bajo licencias de código abierto, lo que le permite  que cuaqluiera  que tenga los medios adecuados  puedas construirse  su propio sintetizador usando esta tecnlogia .

 

Utilizando estas herramientas de código abierto, Andrew Black ha producido su propia NSynth Super, mostrada en el video anterior.

La lista de materiales de construcción de Andrew incluye:

    • 1x Raspberry Pi 3 Model B (896-8660)
    • 6x Alps RK09K Series Potentiometers (729-3603)
    • 4x Bourns PEC11R-4315F-N0012 Rotary Encoders
    • 2x Microchip AT42QT2120-XU Touch Controller ICs (899-6707)
    • 1x STMicroelectronics STM32F030K6T6, 32bit ARM Cortex Microcontroller (829-4644)
    • 1x TI PCM5122PW, Audio Converter DAC Dual 32 bit (814-3732)
    • 1x Adafruit 1.3″ OLED display

 

El equipo de Magenta también proporciona archivos de Gerber para que se  pueda fabricar la placa de circuito impreso , de modo que una vez se haya fabricado, se pueda comenzar con el soldado de componetes  em la PCB (incluye una tabla de contenidos para agregar componentes)

Como adelantabmos ,laa construcción no es trea fácil: requiere habilidades de soldadura o acceso a alguien que pueda ensamblar PCB pues la mayoría de los componentes son SMT de modo que el paso de componentes se reduce a alrededor de 0,5 mm, que aun se se pueden soldar a mano si se tiene cuidado. Sin embargo, aunque algunos podrían argumentar que no es absolutamente necesario, es aconsejable tener un microscopio estéreo y una estación de aire caliente disponibles también. ¡Y no hace falta decir que también debería tener suficiente flujo y mecha de soldadura!

Para probar  este diseño , descargamos un archivo MIDI de Internet y luego lo reproducimos a través de una computadora portátil Linux y una interfaz USB / MIDI usando el comando “aplaymidi”. Efectivamente, el NSynth Superarrncara  y  ya podremos asignar instrumentos a cada esquina y luego interpolar a través de la maravilla del aprendizaje automático para crear nuevas, hasta ahora desconocidas, 

 

Puede echar un vistazo a la publicación de blog de Andrew y al informe oficial de NSynth GitHub para ver si está preparado para el desafío.

Aquí información útil para montarlo:https://www.rs-online.com/designspark/building-the-google-open-nsynth-super