Cosillas de Juansal

Material density detection system used to create wet wipes with Arduino 2/2

2017-03-31T08:05:00.000+02:00

Construction of the final prototype

Components used

The components used have been, per module:

Density Bar
- 1 - Arduino Pro Mini 5v
- 4 - LDRs
- 4 - Resistors 1k
- 2 - PCB Terminal Blocks
Communication bar
- 1 - Arduino Pro Mini 5v
- 1 - LM2596s DC-DC step down power supply module
- 2 - PCB Terminal Blocks
- 1 - Voltage regulator TIP220
- 1 - Heat Sink for TIP220
- 1 - Rectangular LED 6W 630lm 6500K COB 170 x 15 mm.
Industruino
- 1 - Industruino PROTO kit
- 1 - Relay module Keyes_SR1
Arduino with screen
- 1 - Arduino UNO R3
- 1 - 16x2 Character LCD module with I2C
- 3 - Resistors 10k
- 2 - Resistors 220
- 1 - LED Red
- 1 - LED Green
- 3 - Buttons
- 1 - Relay module Keyes_SR1

Assembly of the circuit

The Fritzing scheme is as follows:

Density bar

Circuit that manages the density bar

This circuit is responsible for obtaining the measurements and send notifications to the communications bar for redirection.

Communication bar

Circuit that manages the communication bar

This circuit is responsible for the communications of the density bar, in addition to the power supply of the bar and all the components it contains.

Arduino with screen

Arduino with screen

This assembly is the one made to replace the burned Industruino.

Software: Functionality to be implemented and protocol design used

This section discusses the functionality of the software created and the messaging protocol that has been designed so that the communication meets the desired functionality.

The functionality of the implemented software is as follows:

Auto calibration of light sensors. This step must be performed automatically when the density bar is started or when the user asks for it.
From an average value of light that is considered as valid (the quality of the product is correct) you must indicate a higher percentage and a lower percentage, within which the product is considered to contain the desired quality. The valid value is obtained from the auto calibration.
From the data of the 2 previous points send a signal if the product is not within the desired quality.

Each of the bars is responsible for one or several features and the Industruino (and later the Arduino with screen) of others, these are:

Industruino / Arduino with screen:
- Configuration of the percentages to apply to the average value of quality.
- Activate the warning signal if you receive notification that a piece has been found that does not meet the quality.
- Density bar configuration request.
Density bar
- Auto calibration execution, either at startup or when prompted.
- Perform measurements and advise if any is out of range.
Communication bar
- Intermediate between the density bar and the Industruino, within this role is responsible for:
  - Convert the percentages passed by the Industruino to values within the measuring range and communicate them to the density bar.
  - Ask the density bar the values required by the Industruino and transform them if necessary.
  - Filtering the ads from the density bar to the Industruino only alerts the Industruino if there has been a change.

For communication between the bars, the following messaging protocol was designed:

Requests from the Industruino

Request current bar configuration.

Configuration data for the bar (data modified in Industruino and sent to the bars).

Auto calibration request bar.

Shipments to the Industruino, independent of the previous ones in response to a request of this one

Sending information auto calibrated (the first start of the bar always performs a self calibration without being prompted by the Industruino)

Sending data about the readings. It is only sent when there is a change between in or out of range.

Libraries used in each Arduino:

This section lists each of the libraries that have been created and those that have been used for each of the Arduinos that compose the project.

Density bar

EasyTransfer: library used for communications between bars.
Internal libraries: created by us and used to make programming easier.
- CommunicationStructures.h: used to contain the data structures that were sent between Arduinos.
- EEPROMAnything.h: used to manage data stored in the EEPROM. Retrieved from the following URL: http://playground.Arduino.cc/Code/EEPROMWriteAnything
- I2C_Anything.h: Used for read and write management over the I2C port. Retrieved from the following URL: http://forum.Arduino.cc/index.php?topic=104732.0.

Communication bar

Wire: library used for I2C connections.
EasyTransfer: library used for communications between bars.
Internal libraries: created by us and used to make programming easier.
- CommunicationStructures.h: used to contain the data structures that were sent between Arduinos.
- EEPROMAnything.h: used to manage data stored in the EEPROM. Retrieved from the following URL: http://playground.Arduino.cc/Code/EEPROMWriteAnything
- I2C_Anything.h: Used for read and write management over the I2C port. Retrieved from the following URL: http://forum.Arduino.cc/index.php?topic=104732.0.

Industruino

U8glib: library used to paint on the screen of the Industruino. Retrieved from the following URL: https://github.com/olikraus/u8glib
M2tklib: library used to paint the menus on the screen of the Industruino. Retrieved from the following URL: https://github.com/olikraus/m2tklib
Wire: library used for I2C connections.
EasyTransfer: library used for communications between bars.
Internal libraries: created by us and used to make programming easier.
- CommunicationStructures.h: used to contain the data structures that were sent between Arduinos.
- EEPROMAnything.h: used to manage data stored in the EEPROM. Retrieved from the following URL: http://playground.Arduino.cc/Code/EEPROMWriteAnything
- I2C_Anything.h: Used for read and write management over the I2C port. Retrieved from the following URL: http://forum.Arduino.cc/index.php?topic=104732.0.

Arduino with screen

LiquidCrystal: library used to paint on the screen of the Arduino. Retrieved from the following URL: https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads/
Wire: library used for I2C connections.
EasyTransfer: library used for communications between bars.
Internal libraries: created by us and used to make programming easier.
- CommunicationStructures.h: used to contain the data structures that were sent between Arduinos.
- EEPROMAnything.h: used to manage data stored in the EEPROM. Retrieved from the following URL: http://playground.Arduino.cc/Code/EEPROMWriteAnything
- I2C_Anything.h: Used for read and write management over the I2C port. Retrieved from the following URL: http://forum.Arduino.cc/index.php?topic=104732.0.

The Arduino code is as follows:

To verify the I2C address of the elements that used this protocol has been used the called program Arduino I2c Scanner.

Internal library

This is not an Arduino library, otherwise it is a group of utilities and definition of data structures that are used by the other Arduino programs used in the project.

These classes are located inside the folder \\User\Documents\Arduino\libraries, In our case we have created a folder inside with the name utilidades_barras.
The files that compose it are:

CommunicationStructures.h

This file contains the data structures that are used for communications between Arduinos.

#include 

/*
    Las operaciones que se envían entre el Industruino y las barras pueden ser los siguientes:
        1 - Petición de configuración de barra.
        2 - Datos de reconfiguración de barra (datos modificados en Industruino y enviados a las barras).
        3 - Petición de auto calibrado de barra.
*/

// Número de LDR's
#define NUM_LDR 4

/*
    Configuración de un LDR
*/
struct config_LDR
{
  int valorMedio;
  int valorUmbralSup;
  int valorUmbralInf;
};

/*
    Valores de un LDR
*/
struct valores_LDR
{
    int valorActual;
    int valorAnterior;
};

/*
    Estructura de datos para comunicación entre barra de comunicaciones y barra de densidad
*/
struct datos_densidad_barraCom_barraDens
{
  int operacion;
  config_LDR confLDR[NUM_LDR];
  int UmbralSup;
  int UmbralInf;
};

/*
    Estructura de datos para comunicación entre barra de densidad y barra de comunicaciones
*/
struct datos_densidad_barraDens_barraCom
{
  boolean saldo;
  valores_LDR valLDR[NUM_LDR];
  //Para cuando se auto calibra la barra
  boolean cambios; // Indica si se devuelven cambios de configuración o datos.
  config_LDR confLDR[NUM_LDR];
};

/*
    Estructura de datos para comunicación entre Industruino y barra de comunicaciones
*/
struct datos_densidad_Industruino_barraCom
{
  int operacion;
  int UmbralSup;
  int UmbralInf;
};

/*
    Estructura de datos para comunicación entre barra de comunicaciones y Industruino
*/
struct datos_densidad_barraCom_Industruino
{
  int tipo; //Tipo de barra.
  int tipoRespuesta; // Valores posibles: 1 - Respuesta a petición de configuración o a auto calibrado, 2 - Respuesta con datos.
  boolean saldo;
  valores_LDR valLDR[NUM_LDR];
  int UmbralSup;
  int UmbralInf;
};

EEPROMAnything.h

This file is used for the management of data stored in the EEPROM. It has been obtained from the information contained in the following page of the Arduino website: http://playground.Arduino.cc/Code/EEPROMWriteAnything.

#include 
#include   // for type definitions

template <class T> int EEPROM_writeAnything(int ee, const T& value)
{
  const byte* p = (const byte*)(const void*)&value;
  unsigned int i;
  for (i = 0; i < sizeof(value); i++)
    EEPROM.write(ee++, *p++);
  return i;
}

template <class T> int EEPROM_readAnything(int ee, T& value)
{
  byte* p = (byte*)(void*)&value;
  unsigned int i;
  for (i = 0; i < sizeof(value); i++)
    *p++ = EEPROM.read(ee++);
  return i;
}

void EEPROM_clear()
{
  // write a 0 to all 512 bytes of the EEPROM
  for (int i = 0; i < 512; i++)
    EEPROM.write(i, 0);
}

I2C_Anything.h

This file is used for read and write management on the I2C port. It has been obtained from the information contained in the following blog post from Arduino: http://forum.Arduino.cc/index.php?topic=104732.0

// Written by Nick Gammon
// May 2012

#include 
#include 

template <typename T> unsigned int I2C_writeAnything (const T& value)
  {
    const byte * p = (const byte*) &value;
    unsigned int i;
    for (i = 0; i < sizeof value; i++)
          Wire.write(*p++);
    return i;
  }  // end of I2C_writeAnything

template <typename T> unsigned int I2C_readAnything(T& value)
  {
    byte * p = (byte*) &value;
    unsigned int i;
    for (i = 0; i < sizeof value; i++)
          *p++ = Wire.read();
    return i;
  }  // end of I2C_readAnything

Density bar

The files that make up this project / program are:

barra_densidad.ino: This file is the base file of the project and contains the following elements:
- Basic methods of an Arduino program (setup and loop).
- Declaration and initialization of global variables.
- Declaration of data structures internal to the program.
datos_densidad.ino: This file contains the data structures with the information of the density bar and the management of these.
datos_LDR.ino: This file contains the configuration management and data access of the LDRs, additionally when it obtains the data of the LDRs it processes them.

Communication bar

The files that make up this project / program are:

barra_densidad_conector.ino: This file is the base file of the project and contains the following elements:
- Basic methods of an Arduino program (setup and loop).
- Declaration and initialization of global variables.
- Declaration of data structures internal to the program.
datos_densidad.ino: This file contains the data structures with the information of the density bar and the management of these.

Industruino

The files that make up this project / program are:

Industruino.ino: This file is the base file of the project and contains the following elements:
- Basic methods of an Arduino program (setup and loop).
- Declaration and initialization of global variables.
- Declaration of data structures internal to the program.
Industruino_I2c.ino: This file contains the management of I2C communications.
Industruino_Menu.ino: This file contains the painting and management of the program menu.
Industruino_Pantalla.ino: This file contains the management of the screen.
Industruino_datos.ino: This file contains the management of received and sent data.

Arduino with screen

The files that make up this project / program are:

ard_pantalla.ino: This file is the base file of the project and contains the following elements:
- Basic methods of an Arduino program (setup and loop).
- Declaration and initialization of global variables.
- Declaration of data structures internal to the program.
Botones.ino: This file contains the methods used to work with the buttons.
conexion_I2c.ino: This file contains the management of I2C communications.
Menus.ino: This file contains the painting and management of the program menu.
Pantalla.ino: This file contains the management of the screen.
gestion_datos.ino: This file contains the management of received and sent data.

Acknowledgments

To my friend Fran for thinking of me for the realization of this project, without him I would not have had any contact with the Arduino world.

My brother Raul for the creation of the test bench and for giving us some ingenious solution to the structural problems of the bars that we met along the way and blocked us at some point.

To my friend Sergio for his occasional help in the design of electronics.

To Mario and Jose Antonio for helping me to revise the article and to propose improvements in the writing and the form.

To the rest of people who with their encouragement and punctual help helped us to finish this project.

Sistema de detección de la densidad del material usado para crear las toallitas húmedas con Arduino 2/2

2017-03-31T08:00:00.000+02:00

Construcción del prototipo final

Componentes usados

Los componentes usados han sido, por módulo:

Barra de densidad
- 1 - Arduino Pro Mini 5v
- 4 - LDRs
- 4 - Resistencias 1k
- 2 - Bloques Terminales para PCB
Barra de comunicaciones
- 1 - Arduino Pro Mini 5v
- 1 - Reductor voltaje LM2596s
- 2 - Bloques Terminales para PCB
- 1 - Regulador de voltaje TIP220
- 1 - Disipador TIP220
- 1 - LED de 6W 630lm 6500K COB de 170 x 15 mm.
Industruino
- 1 - Industruino PROTO kit
- 1 - Modulo relé Keyes_SR1
Arduino con pantalla
- 1 - Arduino UNO R3
- 1 - Pantalla LCD de 16x2 con I2C
- 3 - Resistencias 10k
- 2 - Resistencias 220
- 1 - LED Rojo
- 1 - LED Verde
- 3 - Botones
- 1 - Modulo relé Keyes_SR1

Montaje del circuito

El esquema en Fritzing es el siguiente:

Barra de densidad

Circuito que gestiona la barra de densidad

Este circuito se encarga de obtener las mediciones y enviar notificaciones a la barra de comunicaciones para que las redirija.

Barra de comunicaciones

Circuito que gestiona la barra de comunicaciones

Este circuito se encarga de las comunicaciones de la barra de densidad, además de la alimentación eléctrica de la barra y todos los componentes que contiene.

Arduino con pantalla

Arduino con pantalla

Este montaje es el realizado para sustituir al Industruino que se quemó.

Software: Funcionalidad a implementar y diseño del protocolo utilizado

En este apartado se comenta la funcionalidad que cumple el software creado y el protocolo de mensajería que se ha diseñado para que la comunicación cumpla con la funcionalidad deseada.

La funcionalidad del software implementado es la siguiente:

Auto calibración de los sensores de luz. Este paso se ha de realizar automáticamente al arrancar la barra de densidad o cuando el usuario lo pida.
A partir de un valor medio de luz que se considere como válido (la calidad del producto es la correcta) se le han de indicar un porcentaje superior y uno inferior, dentro de los cuales el producto se considera que contiene la calidad deseada. El valor válido se obtendrá desde el auto calibrado.
A partir de los datos de los 2 puntos anteriores enviar una señal si el producto no está dentro de la calidad deseada.

Cada una de las barras se encarga de una o varias funcionalidades y el Industruino(y posteriormente el Arduino con pantalla) de otras, estas son:

Industruino / Arduino con pantalla:
- Configuración de los porcentajes a aplicar al valor medio de calidad.
- Activar la señal de aviso si recibe la notificación de que se ha encontrado algún trozo que no cumple la calidad.
- Petición de configuración de la barra de densidad.
Barra de densidad
- Ejecución del auto calibrado, ya sea al arrancar o cuando se le pida.
- Realizar las mediciones y avisar si alguna está fuera de rango.
Barra de comunicaciones
- Intermediario entre la barra de densidad y el Industruino, dentro de este rol se encarga de:
  - Convertir los porcentajes pasados por el Industruino a valores dentro del rango de medición y comunicárselos a la barra de densidad.
  - Pedir a la barra de densidad los valores requeridos por el Industruino y transformándolos si es necesario.
  - Filtrar los avisos de la barra de densidad al Industruino, sólo avisa al Industruino si ha habido un cambio

Para la comunicación entre las barras se diseñó el siguiente protocolo de mensajería:

Peticiones desde el Industruino

Petición de configuración actual de barra.

Datos de reconfiguración para la barra (datos modificados en Industruino y enviados a las barras).

Petición de auto calibrado de barra.

Envíos al Industruino, independientes a los anteriores como respuesta a una petición de éste

Envío de información de auto calibrado (el primer arranque de la barra siempre realiza un auto calibrado, sin que se lo pida el Industruino)

Envío de datos sobre las lecturas. Sólo se envía cuando hay un cambio entre dentro o fuera del rango.

Librerías usadas en cada Arduino:

En este apartado se enumeran cada una de las librerías que se han creado y las que se han usado para cada uno de los Arduinos que componen el proyecto.

Barra de densidad

EasyTransfer: librería usada para las comunicaciones entre barras.
Librerías internas: creadas por nosotros y usadas para facilitar la programación.
- CommunicationStructures.h: usada para contener las estructuras de datos que se enviaban entre Arduinos.
- EEPROMAnything.h: usada para la gestión de datos que se guardaban en la EEPROM. Obtenida a partir de la siguiente URL: http://playground.Arduino.cc/Code/EEPROMWriteAnything
- I2C_Anything.h: usada para la gestión de lectura y escritura sobre el puerto I2C. Obtenida a partir de la siguiente URL: http://forum.Arduino.cc/index.php?topic=104732.0.

Barra de comunicaciones

Wire: librería usada para las conexiones I2C.
EasyTransfer: librería usada para las comunicaciones.
Librerías internas: creadas por nosotros y usadas para facilitar la programación.
- CommunicationStructures.h: usada para contener las estructuras de datos que se enviaban entre Arduinos.
- EEPROMAnything.h: usada para la gestión de datos que se guardaban en la EEPROM. Obtenida a partir de la siguiente URL: http://playground.Arduino.cc/Code/EEPROMWriteAnything
- I2C_Anything.h: usada para la gestión de lectura y escritura sobre el puerto I2C. Obtenida a partir de la siguiente URL: http://forum.Arduino.cc/index.php?topic=104732.0

Industruino

U8glib: librería usada para pintar en la pantalla del Industruino. Obtenida a partir de la siguiente URL: https://github.com/olikraus/u8glib
M2tklib: librería usada para pintar los menús en la pantalla del Industruino. Obtenida a partir de la siguiente URL: https://github.com/olikraus/m2tklib
Wire: librería usada para las conexiones I2C.
EasyTransfer: librería usada para las comunicaciones.
Librerías internas: creadas por nosotros y usadas para facilitar la programación.
- CommunicationStructures.h: usada para contener las estructuras de datos que se enviaban entre Arduinos.
- EEPROMAnything.h: usada para la gestión de datos que se guardaban en la EEPROM. Obtenida a partir de la siguiente URL: http://playground.Arduino.cc/Code/EEPROMWriteAnything
- I2C_Anything.h: usada para la gestión de lectura y escritura sobre el puerto I2C. Obtenida a partir de la siguiente URL: http://forum.Arduino.cc/index.php?topic=104732.0

Arduino con pantalla

LiquidCrystal: librería usada para pintar en la pantalla del Arduino. Obtenida a partir de la siguiente URL: https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads/
Wire: librería usada para las conexiones I2C.
EasyTransfer: librería usada para las comunicaciones.
Librerías internas: creadas por nosotros y usadas para facilitar la programación.
- CommunicationStructures.h: usada para contener las estructuras de datos que se enviaban entre Arduinos.
- EEPROMAnything.h: usada para la gestión de datos que se guardaban en la EEPROM. Obtenida a partir de la siguiente URL: http://playground.Arduino.cc/Code/EEPROMWriteAnything
- I2C_Anything.h: usada para la gestión de lectura y escritura sobre el puerto I2C. Obtenida a partir de la siguiente URL: http://forum.Arduino.cc/index.php?topic=104732.0

El código del Arduino es el siguiente:

Para comprobar la dirección I2C de los elementos que usaban este protocolo se ha usado el programa llamado Arduino I2c Scanner.

Librería interna

Esta no es una librería de Arduino, si no, es un grupo de utilidades y definición de estructuras de datos que se usan por el resto de programas de Arduino que se usan en el proyecto.

Estas clases están situadas dentro de la carpeta \\Usuario\Documentos\Arduino\libraries, en nuestro caso hemos creado una carpeta allí dentro con el nombre utilidades_barras.
Los ficheros que la componen son:

CommunicationStructures.h

Este fichero contiene las estructuras de datos que se usan para las comunicaciones entre Arduinos.

#include 

/*
    Las operaciones que se envían entre el Industruino y las barras pueden ser los siguientes:
        1 - Petición de configuración de barra.
        2 - Datos de reconfiguración de barra (datos modificados en Industruino y enviados a las barras).
        3 - Petición de auto calibrado de barra.
*/

// Número de LDR's
#define NUM_LDR 4

/*
    Configuración de un LDR
*/
struct config_LDR
{
  int valorMedio;
  int valorUmbralSup;
  int valorUmbralInf;
};

/*
    Valores de un LDR
*/
struct valores_LDR
{
    int valorActual;
    int valorAnterior;
};

/*
    Estructura de datos para comunicación entre barra de comunicaciones y barra de densidad
*/
struct datos_densidad_barraCom_barraDens
{
  int operacion;
  config_LDR confLDR[NUM_LDR];
  int UmbralSup;
  int UmbralInf;
};

/*
    Estructura de datos para comunicación entre barra de densidad y barra de comunicaciones
*/
struct datos_densidad_barraDens_barraCom
{
  boolean saldo;
  valores_LDR valLDR[NUM_LDR];
  //Para cuando se auto calibra la barra
  boolean cambios; // Indica si se devuelven cambios de configuración o datos.
  config_LDR confLDR[NUM_LDR];
};

/*
    Estructura de datos para comunicación entre Industruino y barra de comunicaciones
*/
struct datos_densidad_Industruino_barraCom
{
  int operacion;
  int UmbralSup;
  int UmbralInf;
};

/*
    Estructura de datos para comunicación entre barra de comunicaciones y Industruino
*/
struct datos_densidad_barraCom_Industruino
{
  int tipo; //Tipo de barra.
  int tipoRespuesta; // Valores posibles: 1 - Respuesta a petición de configuración o a auto calibrado, 2 - Respuesta con datos.
  boolean saldo;
  valores_LDR valLDR[NUM_LDR];
  int UmbralSup;
  int UmbralInf;
};

EEPROMAnything.h

Este fichero se usa para la gestión de datos que se guardan en la EEPROM. Ha sido obtenida a partir de la información contenida en la siguiente página de la web de Arduino: http://playground.Arduino.cc/Code/EEPROMWriteAnything.

#include 
#include   // for type definitions

template <class T> int EEPROM_writeAnything(int ee, const T& value)
{
  const byte* p = (const byte*)(const void*)&value;
  unsigned int i;
  for (i = 0; i < sizeof(value); i++)
    EEPROM.write(ee++, *p++);
  return i;
}

template <class T> int EEPROM_readAnything(int ee, T& value)
{
  byte* p = (byte*)(void*)&value;
  unsigned int i;
  for (i = 0; i < sizeof(value); i++)
    *p++ = EEPROM.read(ee++);
  return i;
}

void EEPROM_clear()
{
  // write a 0 to all 512 bytes of the EEPROM
  for (int i = 0; i < 512; i++)
    EEPROM.write(i, 0);
}

I2C_Anything.h

Este fichero se usa para la gestión de lectura y escritura sobre el puerto I2C. Ha sido obtenida a partir de la información contenida en la siguiente entrada del blog de Arduino: http://forum.Arduino.cc/index.php?topic=104732.0

// Written by Nick Gammon
// May 2012

#include 
#include 

template <typename T> unsigned int I2C_writeAnything (const T& value)
  {
    const byte * p = (const byte*) &value;
    unsigned int i;
    for (i = 0; i < sizeof value; i++)
          Wire.write(*p++);
    return i;
  }  // end of I2C_writeAnything

template <typename T> unsigned int I2C_readAnything(T& value)
  {
    byte * p = (byte*) &value;
    unsigned int i;
    for (i = 0; i < sizeof value; i++)
          *p++ = Wire.read();
    return i;
  }  // end of I2C_readAnything

Barra de densidad

Los ficheros que componen este proyecto/programa son:

barra_densidad.ino: Este fichero es el fichero base del proyecto y contiene los siguientes elementos:
- Métodos básicos de un programa en Arduino (setup y loop).
- Declaración e inicialización de variables globales.
- Declaración de estructuras de datos internas al programa.
datos_densidad.ino: Este fichero contiene las estructuras de datos con la información de la barra de densidad y la gestión de estas.
datos_LDR.ino: Este fichero contiene la gestión de configuración y acceso a datos de los LDRs, adicionalmente cuando obtiene los datos de los LDRs los procesa.

Barra de comunicaciones

Los ficheros que componen este proyecto/programa son:

barra_densidad_conector.ino: Este fichero es el fichero base del proyecto y contiene los siguientes elementos:
- Métodos básicos de un programa en Arduino (setup y loop).
- Declaración e inicialización de variables globales.
- Declaración de estructuras de datos internas al programa.
datos_densidad.ino: Este fichero contiene las estructuras de datos con la información de la barra de densidad y la gestión de estas.

Industruino

Los ficheros que componen este proyecto/programa son:

Industruino.ino: Este fichero es el fichero base del proyecto y contiene los siguientes elementos:
- Métodos básicos de un programa en Arduino (setup y loop).
- Declaración e inicialización de variables globales.
- Declaración de estructuras de datos internas al programa.
Industruino_I2c.ino: Este fichero contiene la gestión de las comunicaciones I2C.
Industruino_Menu.ino: Este fichero contiene el pintado y gestión del menú del programa.
Industruino_Pantalla.ino: Este fichero contiene la gestión de la pantalla.
Industruino_datos.ino: Este fichero contiene la gestión de los datos recibidos y a enviar.

Arduino con pantalla

Los ficheros que componen este proyecto/programa son:

ard_pantalla.ino: Este fichero es el fichero base del proyecto y contiene los siguientes elementos:
- Métodos básicos de un programa en Arduino (setup y loop).
- Declaración e inicialización de variables globales.
- Declaración de estructuras de datos internas al programa.
Botones.ino: Este fichero contiene los métodos utilizados para trabajar con los botones.
conexion_I2c.ino: Este fichero contiene la gestión de las comunicaciones I2C.
Menus.ino: Este fichero contiene el pintado y gestión del menú del programa.
Pantalla.ino: Este fichero contiene la gestión de la pantalla.
gestion_datos.ino: Este fichero contiene la gestión de los datos recibidos y a enviar.

Agradecimientos

A mi amigo Fran por pensar en mí para la realización de este proyecto, sin el no hubiera tenido ningún contacto con el mundo de Arduino.

A mi hermano Raul por la creación del banco de pruebas y por darnos alguna solución ingeniosa a los problemas estructurales de las barras que nos encontramos por el camino y nos bloquearon en algún momento puntual.

A mi amigo Sergio por sus ayudas puntuales en el diseño de la electrónica.

A Mario y a Jose Antonio por ayudarme a revisar el artículo y proponerme mejoras en la redacción y la forma.

Al resto de gente que con sus ánimos y ayudas puntuales nos ayudaron a acabar este proyecto.

Material density detection system used to create wet wipes with Arduino 1/2

2017-03-30T08:05:00.000+02:00

Bars mounted inside the demo case

Bars mounted on the test bench

Introduction

This adventure began when my friend Fran came to find me to tell me the need he had detected in a company and wanted me to lend a hand to get it to good port.
Although in the end the project was not implemented in the company, we decided to finish it, we had spent too much time in it not to do it.

The project was to create a system to detect the density of a material to detect if it met the expected quality.
In case of failure to comply, a relay must be activated.
The solution that was chosen had to be applied to 9 machines, to be able to be working 24 hours a day and to perform the tasks at the speed of operation of the machine.

The product to be analyzed consisted of the reels of material used to create the wet wipes.

The cases that had to produce the activation of the relay were the following:

Product density less than expected.
Product density higher than expected.
Binding tapes on the product.
Breakage and deformation of the product.

Side of the machines on which the bars were to be mounted

Detail of the place where one of the bars had to be mounted

Measures of the gap to the entrance of the material in the machine

Measurements of the hole in which it was believed best to fit the bars

To address the problem it was decided to create several brainstorming sessions and information search to try to find the best solutions to this problem.
The ideas that occurred to us and that were studied as possible solutions to the problem, in order, are the following:

Using a camera and study the product from the information received.

The idea was, from the information obtained from a camera that was pointing directly to the product, using an image analysis software to detect each of the cases described above.

The detection of joints, breaks and deformations consisted of using artificial vision libraries such as OpenCV or SimpleCV to analyze the received images , and from certain rules to obtain if these cases were fulfilled.
The measurement of the density of the product should be made by analyzing the color of the product when it is crossed by a light, with a color to study.

This idea was discarded by the high cost of hardware needed to do it, in addition to the complexity of the software to be created.

Illuminate with infrared light and analyzing light passing through the product.

The idea was, with an infrared light to illuminate the product and analyze the temperature of the light through this one.
The best way to perform the measurements was studied for a time, but any changes in the temperature or light intensity of the room in which the machines were found affected the measurements.

It was discarded because the temperature of the product can change due to external effects and beyond our control, therefore, it complicated the measurement of this temperature greatly and forced the system to detect changes of temperature and light intensity in the room and forced that the system will calibrate itself by detecting a minimum change of one of these two parameters.

Illuminate with normal light and analyze the amount of light that passes through the product.

This was the idea that was put into practice.

The idea was to illuminate the product on one side and the opposite measure the amount of light that passed through.

After studying what color to use it was decided to use white, this was the best information could be obtained and the least affected by having to pass through the product.

This system could detect the 4 cases that the system had to comply with:

Product density lower than expected: It would be detected if the light intensity was higher than an upper limit value of light intensity.
Product density higher than expected: It would be detected if the light intensity was less than a lower limit value of light intensity.
Bonding tapes on the product: It would be detected if the light intensity was zero or almost null.
Product breakages and deformations: It would be detected if the light intensity was the maximum possible or near maximum.

Iterations / Phases through which the project passed to reach the final solution.

After deciding how to solve the problem, he decided how to put it into practice.
The conclusion reached was as follows:

They had to create 2 bars that should be aligned and the product should pass between them.
One bar should illuminate the product evenly and the other should be the LDR’s (Light Dependent Resistor) to analyze the amount of light that passes through it.
To control both bars would use an Arduino. It was decided to use the Arduino Pro Mini because of its small size.
To activate the relays and send the configuration parameters to the Arduinos that handled the bars would use another Arduino. We searched the internet for one that could be used in an electrical panel or a carcass for the same one that fulfilled the same purpose and we found the [Industruino] (https://Industruino.com/).
The communication between the Arduinos of the bars and the Industruino would be realized by the bus I2C.

From the solution that was decided to follow was created 3 iterations. Each of the iterations generated a different prototype and brought us closer to the final solution of the problem.

In order to carry out the tests, it was necessary to use the ingenuity of my brother Raúl, who built us a bank to be able to carry out the tests, this one was modified according to the necessities in each one of the tests that were realized.

Initial test bench

Iteration 1

Matrix without LEDs or LCDs

Position of the LEDs

Distribution of LCDs

Mounting on test bench

In this iteration was considered to create 1 matrix of holes of 5x9 squares, in which an LED would be introduced, but taking into account that the LEDs could not be placed in consecutive holes. In this way we avoided that the light of an LED would affect a LDR that was not its own, in addition to trying to prevent the ambient light from affecting the light measurements performed by the LDR.

First, it started with LED bulbs, but it was not possible to get enough light to make the measurements correctly and efficiently.
We continued with some car headlight LEDs, but the result was the same as with previous LEDs.
We continued the search for LEDs that were powerful enough to take the measurements correctly and we found some 10w, they made a lot of light and had to regulate its intensity, the amount of light they emitted at maximum power was so great which traversed the product and the measurements were close to the maximum light that LDRs could measure.

As last test was placed a row of 10w LEDs and a row of car LEDs. After the test was concluded that the LEDs to be used were 10w, but with their intensity regulated. These bars were able to meet all the detection objectives, but their size was too large and therefore discarded.

Iteration 2

Interior of the LED bar

Interior of the LDR bar

Bars - inner faces

Bars - outer faces

Bars - sides

Bars mounted on test bench

In this iteration rectangular aluminum bars were used, which allowed the bars to be thinner than those designed with wood in the previous iteration.

To avoid that some LEDs did not affect the others and the LDR were not affected by the light of the other LEDs were all withdrawn a little towards the interior of the bar of LEDs, in this way it was avoided that the non-direct light received by the LDRs of the LDRs bar will affect the measurements.

In this iteration one had the problem that each of the LEDs emitted a slightly different intensity of light and in some cases a slightly different color, this complicated the code enough, since this forced that the LEDs and the LDRs had to be calibrated in an independent way. In addition to the above, it was found that the bars were still a little large for the available space.

Iteration 3

9w definitive LEDs

Parts used for bars

Hole Testing for LEDs

Mounted bars - bar detail LDRs

Mounted Bars - LED Bar Detail

Bars mounted on test bench

Detail power input circuit and Arduino communications

Detail circuit with Arduino of reading of LDRs and decision making

The beginning of this iteration began with the search for smaller bars and that allowed to reduce the total size of the bars, of this form to be able to use them in the final solution. As a result of this search were found profiles used for outdoor lighting that allowed us to have the desired size for the bars, in addition to a rather large capacity of heat dissipation, 10w LEDs emitted a fairly high amount of heat.
During the search process of the previous bars and by chance were found rectangular LED 6W COB 170 x 15 mm, which allowed to illuminate all the product of uniform form, of this form it avoided to have to hide the LDR so that the light of a different LED than the one assigned will affect the measurement of this one. This allowed all previous LEDs to be replaced with only one COB.

The finding of these LEDs also made it possible to simplify the calibration process, since from then only the measurements to be taken by each of the LDRs had to be calibrated and the calibration of the LED was unnecessary since only one COB LED was needed. In addition to this, it simplified the circuit necessary for the control of the bars, this allowed that this circuit could be placed in the same bars and did not have to place it in a box outside these.

During this phase was a mishap and an error in the connection of a power supply, connected to the Industruino in an unregulated input a voltage higher than the one supported and it was burned, being unusable, therefore, it was decided to create a similar assembly to Industruino, but with an Arduino UNO, a LCD 16x2 and 3 buttons, this way could be finished this phase.

Sistema de detección de la densidad del material usado para crear las toallitas húmedas con Arduino 1/2

2017-03-30T08:00:00.000+02:00

Barras montadas dentro del maletín de demo

Barras montadas en el banco de pruebas

Introducción

Esta aventura comenzó cuando mi amigo Fran vino a buscarme para contarme la necesidad que había detectado en una empresa y quería que le echara una mano para llevarla a buen puerto.
Aunque al final el proyecto no se aplicó en la empresa, decidimos terminarlo, habíamos dedicado demasiado tiempo en él como para no hacerlo.

El proyecto consistía en crear un sistema de detección de la densidad de un material para detectar si este cumplía con la calidad esperada.
En caso de no cumplirla se debía de activar un relé.
La solución que se eligiera debía de aplicarse a 9 máquinas, ser capaz de estar funcionando las 24 horas del día y realizar las tareas a la velocidad de funcionamiento de la máquina.

El producto a analizar consistía en las bobinas de material usado para crear las toallitas húmedas.

Los casos que debían producir la activación del relé eran los siguientes:

Densidad del producto inferior a la esperada.
Densidad del producto superior a la esperada.
Cintas de unión sobre el producto.
Roturas y deformaciones del producto.

Lateral de las máquinas sobre las que se tenía que montar las barras

Detalle del lugar en el que se tenían que montar una de las barras

Medidas del hueco a la entrada del material en la máquina

Medidas del hueco en el que se creía mejor para estar montadas las barras

Para abordar el problema se decidió crear varias sesiones de brainstorming y de búsqueda de información para intentar encontrar las mejores soluciones a este problema.
Las ideas que se nos ocurrieron y que se estudiaron como posibles soluciones al problema, por orden, son las siguientes:

Usar una cámara y estudiar el producto a partir de la información recibida.

La idea consistía en, a partir de la información obtenida de una cámara que estaba apuntando directamente al producto, usar un software de análisis de imágenes para detectar cada uno de los casos descritos antes.

La detección de cintas de unión, roturas y deformaciones consistía en usar librerías de visión artificial como OpenCV o SimpleCV para analizar las imágenes recibidas, y a partir de ciertas reglas obtener si se cumplían estos casos.
La medición de la densidad del producto se debía de realizar analizando el color del producto al ser atravesado por una luz, con un color a estudiar.

Esta idea se descartó por el alto coste de hardware necesario para realizarlo, además de por la complejidad del software que se debía crear.

Iluminar con una luz infrarroja y analizar la luz que atraviesa el producto.

La idea consistía en, iluminar con una luz infrarroja el producto y analizar la temperatura de la luz que atravesaba a éste.
Se estudió durante un tiempo la mejor forma de realizar las mediciones, pero se descubrió que cualquier cambio mínimo en la temperatura o en la intensidad de la luz de la sala en la que se encontraban las máquinas afectaba a las mediciones.

Se descartó porque la temperatura del producto puede cambiar por efectos externos y fuera de nuestro control, por tanto, complicaba sobremanera la medición de esta temperatura y obligaba a que el sistema detectara cambios de temperatura e intensidad de la luz en la sala y obligara a que el sistema se auto calibrara al detectar un mínimo cambio de uno de estos dos parámetros.

Iluminar con una luz normal y analizar la cantidad de luz que atraviesa al producto.

Esta fue la idea que se llevó a la práctica.

La idea consistía en iluminar el producto por una cara y por la opuesta medir la cantidad de luz que lo traspasaba.

Después de estudiar qué color usar se decidió usar el blanco, éste era del que mejor información se podía obtener y el menos afectado por tener que traspasar el producto.

Mediante este sistema se podrían detectar los 4 casos que debía de cumplir el sistema:

Densidad del producto inferior a la esperada: Se detectaría si la intensidad de luz era superior a un valor límite superior de intensidad de luz.
Densidad del producto superior a la esperada: Se detectaría si la intensidad de luz era inferior a un valor límite inferior de intensidad de luz.
Cintas de unión sobre el producto: Se detectaría si la intensidad de luz era nula o casi nula.
Roturas y deformaciones del producto: Se detectaría si la intensidad de luz era la máxima posible o casi la máxima.

Iteraciones/Fases por las que pasó el proyecto para llegar a la solución final.

Después de decidir cómo solucionar el problema, tocó decidir cómo llevarlo a la práctica.
La conclusión a la que se llegó fue la siguiente:

Se debían de crear 2 barras que deberían de estar alineadas y el producto debería de pasar entre ambas.
Una barra debería de iluminar el producto de forma uniforme y en la otra deberían de estar los LDR’s (Light Dependent Resistor - fotorresistencia) para analizar la cantidad de luz que atraviesa a éste.
Para controlar a ambas barras se usaría un Arduino. Se decidió usar el Arduino Pro Mini por su reducido tamaño.
Para activar los relés y enviar los parámetros de configuración a los Arduinos que manejaban las barras se usaría otro Arduino. Se buscó por internet uno que pudiera usarse en un cuadro eléctrico o una carcasa para éste que cumpliera el mismo cometido y encontramos el Industruino.
La comunicación entre los Arduinos de las barras y el Industruino se realizaría por el bus I2C.

A partir de la solución que se decidió seguir se crearon 3 iteraciones. Cada una de las iteraciones generó un prototipo diferente y que nos acercó más a la solución final del problema.

Para poder realizar las pruebas se tuvo que echar mano del ingenio de mi hermano Raúl, quien nos construyó un banco para poder realizar las pruebas, éste fue modificándose según las necesidades en cada una de las pruebas que se realizaron.

Banco de pruebas inicial

Iteración 1

Matriz sin LEDs ni LCDs

Posicionado de los LEDs

Distribución de los LCDs

Montaje sobre banco de pruebas

En esta iteración se consideró crear 1 matriz de agujeros de 5x9 cuadros, en los que se introduciría un LED, pero teniendo en cuenta que los LEDs no podían estar colocados en agujeros consecutivos. De esta forma evitábamos que la luz de un LED afectara a un LDR que no fuera el suyo, además de que se intentaba evitar que la luz ambiente afectara a las medidas de luz que realizaban los LDR.

Primero se empezó con unos LED de bombillas, pero no se conseguía obtener la suficiente luz para poder realizar las mediciones de forma correcta y eficiente.
Continuamos con unos LEDs de faros de coche, pero el resultado era el mismo que con los anteriores LEDs.
Se continuó con la búsqueda de LEDs que fueran lo suficiente potentes para tomar las mediciones de forma correcta y se encontraron unos de 10w, estos hacían muchísima luz y se tuvo que regular su intensidad, la cantidad de luz que emitían a máxima potencia era tan grande que atravesaba el producto y las mediciones se aproximaban al máximo de luz que podían medir los LDRs.

Como última prueba se colocó una fila de LEDs de 10w y una fila de los LEDs de coche. Una vez realizada la prueba se llegó a la conclusión de que los LEDs a utilizar eran los de 10w, pero con su intensidad regulada. Estas barras conseguían cumplir todos los objetivos de detección, pero su tamaño era demasiado grande, por tanto, se descartaron.

Iteración 2

Interior de la barra de LEDs

Interior de la barra de LDRs

Barras - caras interiores

Barras - caras exteriores

Barras - laterales

Barras montadas sobre banco de pruebas

En esta iteración se usaron barras rectangulares de aluminio, lo que permitió que las barras fueran más finas que las diseñadas con madera en la iteración anterior.

Para evitar que unos LEDs no afectaran a los otros y los LDR no estuvieran afectados por la luz de los otros LEDs fueron todos retirados un poco hacia el interior de la barra de LEDs, de esta forma se evitaba que la luz no directa recibida por los LDRs de la barra de LDRs afectara a las mediciones.

En esta iteración se tuvo el problema de que cada uno de los LEDs emitía una intensidad ligeramente diferente de luz y en algunos casos un color ligeramente diferente, esto complicaba bastante el código, ya que esto obligaba a que los LEDs y los LDRs tenían que calibrarse de forma independiente. Además de lo anterior se comprobó que las barras continuaban siendo un poco grandes para el hueco disponible.

Iteración 3

LEDs 9w definitivos

Piezas usadas para las barras

Pruebas de agujeros para los LEDs

Barras montadas - detalle de barra de LDRs

Barras montadas - detalle de barra de LEDs

Barras montadas sobre banco de pruebas

Detalle circuito de entrada de alimentación y Arduino de comunicaciones

Detalle circuito con Arduino de lectura de LDRs y toma de decisiones

El inicio de esta iteración comenzó con la búsqueda de unas barras más pequeñas y que permitieran reducir el tamaño total de las barras, de esta forma poder usarlas en la solución final. Como resultado de esta búsqueda se encontraron unos perfiles usados para iluminación de exteriores que nos permitían tener el tamaño deseado para las barras, además de una capacidad bastante grande de disipación de calor, los LEDs de 10w emitían una cantidad bastante grade de calor.

Durante el proceso de búsqueda de las barras anteriores y de casualidad se encontraron unos LED COB de 6w rectangulares de 170 x 15mm, lo que permitía iluminar todo el producto de forma uniforme, de esta forma se evitaba tener que esconder los LDR para que la luz de un LED diferente al asignado afectara a la medición de este. Esto permitió que se sustituyeron todos los LEDs anteriores un uno sólo COB.

El encontrar estos LEDs también permitió simplificar el proceso de calibrado, ya que a partir de entonces sólo se tenía que calibrar las medidas a tomar por cada uno de los LDRs y hacía innecesario el calibrado del LED, ya que sólo era necesario un LED COB. Además de esto simplificó el circuito necesario para el control de las barras, esto permitió que este circuito pudiera colocarse en las mismas barras y no tener que colocarlo en una caja exterior a estas.

Durante esta fase se tuvo un percance y por un error en la conexión de una alimentación, se conectó al Industruino en una entrada no regulada una tensión superior a la soportada y éste se quemó, quedando inutilizable, por tanto, se decidió crear un montaje similar al Industruino, pero con un Arduino UNO, una pantalla LCD de 16x2 y 3 botones, de esta forma se pudo acabar esta fase.

Recreacion del sistema de backup online usando el Resilio Sync y una Cubietruck (Cubieboard 3)

2017-02-15T22:24:00.002+01:00

Finalidad del artículo

La finalidad inicial del artículo ha sido la de cómo actualizar el linux de la Cubietruck y después migrar de Bittorrent Sync a Resilio Sync, pero por descuido no he creado una copia de seguridad de la tarjeta y actualizando el linux éste ha dejado de funcionar. Por tanto el artículo he tenido que cambiarlo de una actualización y migración a una creación total de la máquina desde cero, pero en este caso he añadido, además del Resilio Sync, el monitor creado con AngularJs y NodeJs para controlar la máquina.

Por si a alguien le interesa y desea intentar actualizar el linux indico a continuación los pasos que he seguido, hasta que me ha fallado, pero le recomiendo encarecidamente que haga una copia de seguridad de la tarjeta por si acaso le pasa lo mismo que a mí.

Actualización del linux:

Antes que nada indicar que hace tiempo pude hacer una actualización del sistema operativo y ejecuté los siguientes pasos:

Primero actualicé las librerías a su última versión.

sudo apt-get update
sudo apt-get upgrade

Depués actualicé el gestor de paquetes apt.

apt-get check
apt-get install apt

Por último subí la versión del linux.

do-release-upgrade

apt update
apt dist-upgrade

Esta última vez he seguido los siguientes pasos.

Primero he actualizado las librerías a su última versión:

sudo apt-get update
sudo apt-get upgrade

Después he subido la versión del linux.

do-release-upgrade

La ejecución del anterior paso me ha dado como resultado el siguiente error: The required dependency 'apt (>= 1.0.1ubuntu2.13)' is not installed..
Para solucionarlo he bajado el paquete deb que pide desde la siguiente url: https://launchpad.net/ubuntu/trusty/armhf/apt/1.0.1ubuntu2.13.

wget http://launchpadlibrarian.net/254525360/apt_1.0.1ubuntu2.13_armhf.deb

Una vez descargado el fichero lo he instalado ejecutando el siguiente comando.

dpkg -i apt_1.0.1ubuntu2.13_armhf.deb

He vuelto a ejecutar el comando de actualización:

do-release-upgrade

He vuelto a obtener otro error, en este caso ha sido el siguiente: Error: The required dependency 'dpkg (>= 1.17.5ubuntu5.6)' is not installed.
Para solucionarlo he bajado el paquete deb que pide desde la siguiente url: https://launchpad.net/~ubuntu-security/+archive/ubuntu/ppa/+build/9631646

wget https://launchpad.net/~ubuntu-security/+archive/ubuntu/ppa/+build/9631646/+files/dpkg_1.17.5ubuntu5.6_armhf.deb

Una vez descargado el fichero lo he instalado ejecutando el siguiente comando.

dpkg -i dpkg_1.17.5ubuntu5.6_armhf.deb

He vuelto a ejecutar el comando de actualización:

do-release-upgrade

Si después de ejecutar el comando anterior y reiniciar la máquina, esta arranca (en mi caso no lo ha hecho), se han de ejecutar los siguientes comandos para actualizar las librerías a la versión final.

apt update
apt dist-upgrade

Consideraciones iniciales sobre el artículo

En este artículo se detallan los pasos seguidos para instalar el Lubuntu Server en una Cubietruck (Cubieboard 3) y el Resilio Sync.
Los pasos detallados son los que yo he seguido y que a mí me han funcionado.
En mi caso en la tarjeta SD está el sistema operativo y las aplicaciones, en el disco duro sólo se encuentran los ficheros del BitTorrent Sync.
He aprovechado para instalar el Linaro Server y no el Linaro, como tenía la máquina anterior, de esta forma he conseguido que ocupe menos en la tarjeta sd.

Instalación del sistema operativo en la SD

Desde su página oficial y partir de esta ruta Home › Model › cubieboard3(cubietruck) he descargado la siguiente imagen: linaro-server-ct-card0-hdmi&vga-v1.0.img.7z

Después de descargarla la he grabado en la tarjeta SD.

Configuración del sistema operativo

Para la configuración del sistema operativo he seguido los siguientes pasos.

Configuración del teclado en español:

Para esto ejecutamos el siguiente comando:

sudo dpkg-reconfigure keyboard-configuration

Este comando se encarga de lanzar la aplicación de reconfiguración del teclado.
Seleccionamos Generic 105 key (Intl PC), el idioma Spanish y luego las opciones predeterminadas con OK.

Configuración de red:

En mi caso no la he tocado, ya que uso el DHCP, que es la configuración que viene por defecto.

Configuración de la zona horaria:

Para esto ejecutamos el siguiente comando:

sudo dpkg-reconfigure tzdata

Este comando se encarga de lanzar la aplicación de reconfiguración de la zona horaria.
Seleccionamos la zona geográfica Europe y la zona horaria Madrid.

Cambio del nombre a la cubieboard:

Para esto tenemos que crear/modificar el fichero /etc/hosts y añadir el nombre que deseemos que tenga la cubieboard.
Para ello ejecutaremos el siguiente comando:

sudo vi /etc/hosts

Y cambiaremos los nombres de la máquina en las siguientes líneas, quedando de la siguiente forma:

127.0.0.1       CUBIEBOARD
127.0.1.1       CUBIEBOARD

y el fichero /etc/hostname

sudo vi /etc/hostname

Cambiando el nombre que allí se encuentra por el de la máquina:

CUBIEBOARD

Montado del disco duro:

En mi caso el disco duro es /dev/sda1.
El disco duro se va a montar sobre la carpeta /media/hdd.
Para montar el disco duro y que la configuración se guarde entre arranques del sistema operativo se ha de modificar el fichero /etc/fstab, usando el siguiente comando:

sudo vi /etc/fstab

Para ello añadiremos la siguiente línea a dicho fichero.

/dev/sda1 /media/hdd ext4 defaults 0 2

Actualización del sistema operativo

Para actualizar los paquetes del sistema operativo se han ejecutado los siguientes comandos:

sudo apt-get update
sudo apt-get upgrade

Instalación de Resilio Sync

Para instalar el programa desde apt-get, he seguido la información del siguiente enlace: https://www.resilio.com/blog/official-linux-packages-for-sync-now-available

Preparación del repositorio

Para preparar el repositorio se crea el fichero /etc/apt/sources.list.d/resilio-sync.list, ejecutando el siguiente comando:

sudo vi /etc/apt/sources.list.d/resilio-sync.list

Se añade la siguiente linea:

wget -qO - https://linux-packages.resilio.com/resilio-sync/key.asc | sudo apt-key add -

Instalación

Para instalar la aplicación se ejecuta el siguiente comando.

sudo apt-get update
sudo apt-get install resilio-sync

Configuración

Para configurar el Resilio Sync y poder aprovechar lo que ya tenía del Bittorrent Sync he realizado los siguientes pasos:

Nos movemos a la carpeta de configuración del Resilio Sync.

cd /etc/resilio-sync

Creamos variables del sistema para ayudarnos en este proceso:

config="/etc/resilio-sync/config.json"
user="root"

Extraemos el fichero de configuración por defecto del Resilio Sync:

rslsync --dump-sample-config > $config

Reconfiguramos el fichero de configuración por defecto. Para ello se lanzan los siguientes comandos.

sed -i 's/"device_name"\s*:\s*"My Sync Device"/"device_name": "CUBIEBOARD"/g' $config
sed -i 's/"storage_path"\s*:\s*"\/home\/user\/\.sync"/"storage_path": "\/media\/hdd\/btsync"/g' $config
sed -i 's/"login"\s*:\s*"admin",//g' $config
sed -i 's/"password"\s*:\s*"password"//g' $config
sed -i 's/:8888",/:8888"/g' $config

Después editamos el fichero de configuración por defecto

vi /etc/resilio-sync/config.json

y descomentamos las líneas que contengan device_name y storage_path si estaban comentadas en el fichero.

Uso datos anteriores de BitTorrnent Sync

Para que pueda tener acceso al disco duro anterior hay que cambiar que el usuario que arranca el servicio, en nuestro caso es root y no rslsync, para ello hay que modificar el fichero /etc/init.d/resilio-sync.

vi /etc/init.d/resilio-sync

y cambiamos

SYNC_USER=rslsync

por

SYNC_USER=root

y además cambiamos

start-stop-daemon --start --quiet -b -o -c $SYNC_USER -u $SYNC_USER --exec $DAEMON --umask 0002 -- --config $CONFIG

por

start-stop-daemon --start --quiet -b -o -c $SYNC_USER -u $SYNC_USER --exec $DAEMON --umask 0007 -- --config $CONFIG

Después de esto ya podemos reiniciar la cubietruck.

sudo shutdown -h 0

Información adicional

Pasos seguidos para crear un sistema de backup online usando el BitTorrent y una Cubietruck (Cubieboard 3)
Upgrade on dekstops (BitTorrent Sync -> Resilio Sync)
Official Linux Packages for Sync Now Available

Instalación del monitor basado en AngularJs y NodeJs

Basándome en el siguiente artículo Monitor basado en AngularJs y NodeJs para la Cubietruck (Cubieboard 3) he instalado el monitor.

Software instalado

Git

Este es el cliente usado para descargar la web desde github.
Para la instalación he ejecutado los siguientes comandos:

sudo apt-get install git

NodeJS

Para la instalación de NodeJS he elegido la última versión (en el momento de escribir el artículo es la 6.x) y he ejecutado los siguientes comandos:

sudo apt-get install curl
curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -
sudo apt-get install -y nodejs

Información adicional

Installing Node.js via package manager

Librerías adicionales que he instalado en la Cubieboard para poder realizar la monitorización

lm-sensors

Para poder detectar la temperatura de la CPU he usado la herramienta lm-sensors.
Los pasos que he seguido para instalarla han sido los siguientes:

Primero he ejecutado el siguiente comando para instalarla:

sudo apt-get install lm-sensors

Una vez instalada he ejecutado los siguientes comandos para configurarla y arrancarla:

sudo sensors-detect
sudo service kmod start

Información adicional

lm-sensors
Repositorio Github
How do I get the CPU temperature?

smartmontools

Para obtener la información de los discos se puede utiliar el paquete smartmontools:

apt-get install smartmontools

hddtemp

Para obtener la información de los discos se puede utilizar el paquete hddtemp:

apt-get install hddtemp

Instalación de la web de monitorización

Instalación de la web

Los pasos para instalar el proyecto en la Cubieboard son los siguientes:

Configurar git, sólo la primera vez:

git config --global user.email "correo"
git config --global user.name "usuario"

Bajar el proyecto desde github a la carpeta ~/cubieboard-monitor:

cd
git clone https://github.com/juaalta/cubieboard-monitor.git cubieboard-monitor

Entrar en la carpeta en la que se ha descargado e instalar las dependencias necesarias:

cd cubieboard-monitor

npm install

Una vez seguidos los pasos anteriores, si queremos probar la aplicación sólo tenemos que lanzar el siguiente comando:

nodejs server.js

También puede ejecutarse:

npm start

Step detection system by a way with Arduino

2017-02-01T08:30:00.000+01:00

Description

The purpose of the project is to detect the passing of cars and people at the entrance to an orchard and a warning beep inside this house.
For this project it consists of 2 modules:

Module detection step, either of people or cars.
Module warning step.

The requirements are:

The step detection module, being in the garden, must have a separate power supply, in this case we have put a solar panel and a battery.
The module must sound warning when the detection module warn you.
The detection module is at the entrance of the garden.
The warning module is inside the house.

Detection module with solar panel

Instructions

Components used

The components used have been:

Detection module
Warning module
- Arduino Nano
- PCB 5x7 cm
- APC220 RF wireless modules
- Passive buzzer / relay.

Assembly of the circuit

The Fritzing scheme is as follows:

Detection module

Detection module

In this scheme has not been added to the connection part of the Lipo Rider Pro, battery and solar panel, I not to have the designs for Fritzing.

Warning module

Warning module

Images of the system mounted inside the laboratory:

Detection module

Solar panel with Lipo Rider Pro and battery

Detection module mounted on a breadboard with initial ultrasound detector

Detection module mounted on a breadboard with final ultrasound detector

Top of the PCB detection module without connected components

Top of the PCB detection module with connected components

Detection module inside his waterproof case

Warning module

Warning module mounted on a breadboard

Top of the PCB warning module without connected components

Top of the PCB warning module with connected components

Warning module inside his waterproof case

Software

The libraries used have been:

HCSR04Ultrasonic

The code of the Arduino is the following:

Detection module

/*
  Título: Modulo_RF_APC220 --> Puerto serie
*/

#include <Ultrasonic.h>

//Pins ultrasonido
const int TRIG_PIN = 12;
const int ECHO_PIN = 13;

Ultrasonic ultrasonic(TRIG_PIN, ECHO_PIN);

void setup()
{
  Serial.begin(9600); // Establecemos la velocidad del puerto serie (Igual que APC220)
}

void loop()
{

  float cmMsec;
  long microsec = ultrasonic.timing();
  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);

  Serial.print(int(cmMsec));
  Serial.println("=");

  delay(1000);

}

Warning module


// create notes for our song
int C = 131;
int D = 147;
int E = 165;
int F = 175;
int G = 196;

// create an array to hold note values
int songNotes[] = {E, E, E, E, E, E, E, G, C, D, E, F, F, F, F, F, E, E, E, G, G, F, D, C};
// create another array to hold note lengths
int noteDurations[] = {4, 4, 2, 4, 4, 2, 4, 4, 4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1};

byte byteRead;  //Datos leídos por el puerto serie
long longitud;  //Longitud recibida por el puerto serie

long longitudMaxima = 100;

String inString = "";                          //This string is used to store the incoming data
unsigned int pitch;                            //This is the variable we will use to store the buzzers p

void setup()
{
  Serial.begin(9600);

  longitud = 0;
}

void loop()
{

  while (Serial.available() > 0)
  {
    byteRead = Serial.read();

    //listen for numbers between 0-9
    if (byteRead > 47 && byteRead < 58) {
      //number found
      longitud = (longitud * 10) + (byteRead - 48);
    }

    if (byteRead == 61)
    {
      Serial.println(longitud);

      if (longitud <= longitudMaxima)
      {
        melodia();
      }

      longitud = 0;
    }

  }

}

void melodia()
{
  // iterate through arrays to play each note for its duration
  // plays our jingle once
  for (int i = 0; i < 24; i ++)
  {
    // calculate note duration
    // 1 second divided by note length
    // adjusting value of 1000 can change tempo
    int noteDuration = 1000 / noteDurations[i];
    // sends tone to pin 8
    tone(8, songNotes[i], noteDuration);

    // pause between notes a little to hear them better
    // this can also be used to adjust tempo
    int pauseBetweenNotes = noteDuration * 1.3;
    delay(pauseBetweenNotes);
    // once note is done, stop playing it
    noTone(8);
  }
}

Sistema de detección de paso por un camino con Arduino

2017-02-01T08:00:00.000+01:00

Descripción

La finalidad del proyecto es detectar el paso de coches y personas a la entrada de un huerto y avisar con una señal sonora dentro de la casa de este.
Por esto este proyecto está compuesto por 2 módulos:

Módulo de detección de paso, ya sea de personas o de coches.
Módulo de aviso de paso.

Los requerimientos son los siguientes:

El módulo de detección de paso, al estar en el huerto, ha de tener una fuente de alimentación independiente, en este caso le hemos puesto una placa solar y una batería.
El módulo de aviso ha de sonar cuando el módulo de detección le avise.
El módulo de detección está a la entrada del huerto.
El módulo de aviso está dentro de la casa.

Módulo de detección con placa solar

Instrucciones

Componentes usados

Los componentes usados han sido, por módulo:

Módulo de detección
Módulo de aviso
- Arduino Nano
- PCB 5x7 cm
- Módulos inalámbricos RF APC220
- Buzzer pasivo / relé.

Montaje del circuito

El esquema en Fritzing es el siguiente:

Módulo de detección

Módulo de detección

En este esquema no se ha añadido la parte de conexión al Lipo Rider Pro, la batería y la placa solar, por no tener los diseños para el Fritzing.

Módulo de aviso

Módulo de aviso

Imágenes del sistema montado dentro del laboratorio:

Módulo de detección

Placa solar con Lipo Rider Pro y batería lipo conectados

Módulo de detección montado sobre una breadboard con detector de ultrasonidos inicial

Módulo de detección montado sobre una breadboard con detector de ultrasonidos final

Parte superior de la PCB del módulo de detección sin componentes conectados

Parte superior de la PCB del módulo de detección con componentes conectados

Módulo de detección dentro de su caja estanca

Módulo de aviso

Módulo de aviso montado sobre una breadboard

Parte superior de la PCB del módulo de aviso sin componentes conectados

Parte superior de la PCB del módulo de aviso con componentes conectados

Módulo de aviso dentro de su caja estanca

Software

Las librerías usadas han sido:

HCSR04Ultrasonic

El código del arduino es el siguiente:

Módulo de detección

/*
  Título: Modulo_RF_APC220 --> Puerto serie
*/

#include <Ultrasonic.h>

//Pins ultrasonido
const int TRIG_PIN = 12;
const int ECHO_PIN = 13;

Ultrasonic ultrasonic(TRIG_PIN, ECHO_PIN);

void setup()
{
  Serial.begin(9600); // Establecemos la velocidad del puerto serie (Igual que APC220)
}

void loop()
{

  float cmMsec;
  long microsec = ultrasonic.timing();
  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);

  Serial.print(int(cmMsec));
  Serial.println("=");

  delay(1000);

}

Módulo de aviso


// create notes for our song
int C = 131;
int D = 147;
int E = 165;
int F = 175;
int G = 196;

// create an array to hold note values
int songNotes[] = {E, E, E, E, E, E, E, G, C, D, E, F, F, F, F, F, E, E, E, G, G, F, D, C};
// create another array to hold note lengths
int noteDurations[] = {4, 4, 2, 4, 4, 2, 4, 4, 4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1};

byte byteRead;  //Datos leídos por el puerto serie
long longitud;  //Longitud recibida por el puerto serie

long longitudMaxima = 100;

String inString = "";                          //This string is used to store the incoming data
unsigned int pitch;                            //This is the variable we will use to store the buzzers p

void setup()
{
  Serial.begin(9600);

  longitud = 0;
}

void loop()
{

  while (Serial.available() > 0)
  {
    byteRead = Serial.read();

    //listen for numbers between 0-9
    if (byteRead > 47 && byteRead < 58) {
      //number found
      longitud = (longitud * 10) + (byteRead - 48);
    }

    if (byteRead == 61)
    {
      Serial.println(longitud);

      if (longitud <= longitudMaxima)
      {
        melodia();
      }

      longitud = 0;
    }

  }

}

void melodia()
{
  // iterate through arrays to play each note for its duration
  // plays our jingle once
  for (int i = 0; i < 24; i ++)
  {
    // calculate note duration
    // 1 second divided by note length
    // adjusting value of 1000 can change tempo
    int noteDuration = 1000 / noteDurations[i];
    // sends tone to pin 8
    tone(8, songNotes[i], noteDuration);

    // pause between notes a little to hear them better
    // this can also be used to adjust tempo
    int pauseBetweenNotes = noteDuration * 1.3;
    delay(pauseBetweenNotes);
    // once note is done, stop playing it
    noTone(8);
  }
}

Monitor basado en AngularJs y NodeJs para la Cubietruck (Cubieboard 3)

2016-07-19T00:48:00.000+02:00

Finalidad del artículo

La finalidad de este artículo es mostrar de forma gráfica e intuitiva la información mostrada en el anterior artículo sobre la Cubietruck.
Para ello he creado una web con AngularJS atacando a servicios REST hechos con NodeJS. Para mejorar la parte gráfica he utilizado una plantilla web gratuita llamada AdminLTE.
El desarrollo de la página y de los servicios REST los he realizado utilizando la máquina virtual que he creado para tal efecto.

Software instalado en la Cubieboard

Git

Este es el cliente usado para descargar la web desde github.
Para la instalación he ejecutado los siguientes comandos:

apt-get install git

NodeJS

Para la instalación de NodeJS he elegido la última versión (en el momento de escribir el artículo es la 6.x) y he ejecutado los siguientes comandos:

curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -
sudo apt-get install -y nodejs

Información adicional

Installing Node.js via package manager

Librerías adicionales que he instalado en la Cubieboard para poder realizar la monitorización

lm-sensors

Para poder detectar la temperatura de la CPU he usado la herramienta lm-sensors.
Los pasos que he seguido para instalarla han sido los siguientes:

Primero he ejecutado el siguiente comando para instalarla:

sudo apt-get install lm-sensors

Una vez instalada he ejecutado los siguientes comandos para configurarla y arrancarla:

sudo sensors-detect
sudo service kmod start

Información adicional

lm-sensors
Repositorio Github
How do I get the CPU temperature?

Software adicional instalado en la máquina de desarrollo

less

Como requerimiento de la plantilla usada para generar la web se necesita el preprocesador de css less.
Para instalarlo he ejecutado los siguientes comandos:

sudo npm install -g less

Proceso de creación de la web en la máquina virtual de desarrollo

Preparación de la plantilla

Para esta web he utilizado una plantilla gratuita llamada AdminLTE de la página de Almsaeed Studio.
La he descargado desde la página principal pulsando sobre el link Download, la versión en el momento en que descargué la plantilla era la 2.3.3.
La he descomprimido en $HOME y copiado al directorio cubieboard-monitor, de esta forma siempre tengo una copia completa de la plantilla para poder consultarla.
Los comandos ejecutados han sido los siguientes:

cd
unzip ~/Descargas/AdminLTE-2.3.3.zip
cp -R AdminLTE-2.3.3 cubieboard-monitor

Una vez realizados los pasos anteriores creo en github un repositorio llamado cubieboard-monitor y preparo la carpeta local para atacar a este repositorio.
Los comandos ejecutados han sido los siguientes:

git config --global user.email "correo"
git config --global user.name "usuario"

git init
git add .
git commit -m "Commit inicial"
git remote add origin https://github.com/juaalta/cubieboard-monitor.git
git remote -v
git add .
git push -u origin master

Después de los pasos anteriores ejecuto la instalación de dependencias por parte de NodeJS, mediante el siguiente comando:

npm install

Creación de los servicios REST

Para la creación de los servicios REST he usado NodeJS, por su capacidad para ejecutar comandos de shell de Linux. Todo el código se concentra dentro del fichero server.js.
Los servicios que allí se encuentran están están nombrados, dependiendo para que parte del sistema monitorizan, estas partes (en el momento de redacción del documento v.1.1.0) son las siguientes:

Servicios que empiezan por HDD: estos servicios se encargan de obtener la información sobre los discos duros y sus particiones.
Servicios que empiezan por CPU: estos servicios se encargan de obtener la información sobre la CPU y sus cores.
Servicios que empiezan por SYS: estos servicios se encargan de obtener información sobre el sistema.

Cada servicio llama a un script cuyo nombre es el mismo que el del servicio. Estos scripts se encuentran dentro de la carpeta scripts de la web.

Diseño e implementación de la web

Basándome en la plantilla instalada, he creado 3 secciones para la web, estas son:

Visión General: en esta sección se encuentra información general sobre el estado de la Cubieboard.
CPU: en esta sección se encuentra toda la información sobre el estado de la CPU.
HDD: en esta sección se encuentra toda la información sobre el estado de los discos duros y sus particiones.

Visión general

CPU

HDD

Instalación en la Cubieboard

Los pasos para instalar el proyecto en la Cubieboard son los siguientes:

Configurar git, sólo la primera vez:

git config --global user.email "correo"
git config --global user.name "usuario"

Bajar el proyecto desde github a la carpeta ~/cubieboard-monitor:

cd
git clone https://github.com/juaalta/cubieboard-monitor.git cubieboard-monitor

Entrar en la carpeta en la que se ha descargado e instalar las dependencias necesarias:

cd cubieboard-monitor

npm install

Una vez seguidos los pasos anteriores, si queremos probar la aplicación sólo tenemos que lanzar el siguiente comando:

nodejs server.js

También puede ejecutarse:

npm start

Arranque automático

Para que la web arranque de forma automática al arrancar/reiniciar la cubieboard he seguido los siguientes pasos:

Primero he creado un script que se encargue de arrancar la web, el script se llama /usr/local/bin/cubieboardMonitor.sh y su contenido es:

#! /bin/sh

cd /root/cubieboard-monitor
nodejs server.js &

Después de esto le he dado permisos de ejecución, ejecutando el siguiente comando:

chmod +x /usr/local/bin/cubieboardMonitor.sh

Después he creado el script de arranque como servicio, para esto he creado una copia de un script plantilla dentro de la carpeta /etc/init.d. Para esto he ejecutado el siguiente comando:

cp /etc/init.d/skeleton /etc/init.d/cubieboardMonitor

Después he modificado su contenido para que arranque el script anterior, quedando de la siguiente forma:

#! /bin/sh
### BEGIN INIT INFO
# Provides:          skeleton
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Example initscript
# Description:       This file should be used to construct scripts to be
#                    placed in /etc/init.d.
### END INIT INFO

# Author: Foo Bar 
#
# Please remove the "Author" lines above and replace them
# with your own name if you copy and modify this script.

# Do NOT "set -e"

# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="Monitor de la cubieboard"
NAME=cubieboardMonitor
DAEMON=/usr/local/bin/cubieboardMonitor.sh
DAEMON_ARGS=""
PIDFILE=/var/run/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME

# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0

# Read configuration variable file if it is present
[ -r /etc/default/$NAME ] && . /etc/default/$NAME

# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.2-14) to ensure that this file is present
# and status_of_proc is working.
. /lib/lsb/init-functions

#
# Function that starts the daemon/service
#
do_start()
{
        # Return
        #   0 if daemon has been started
        #   1 if daemon was already running
        #   2 if daemon could not be started
        start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \
                || return 1
        start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON -- \
                $DAEMON_ARGS \
                || return 2
        # Add code here, if necessary, that waits for the process to be ready
        # to handle requests from services started subsequently which depend
        # on this one.  As a last resort, sleep for some time.
}

#
# Function that stops the daemon/service
#
do_stop()
{
        # Return
        #   0 if daemon has been stopped
        #   1 if daemon was already stopped
        #   2 if daemon could not be stopped
        #   other if a failure occurred
        start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
        RETVAL="$?"
        [ "$RETVAL" = 2 ] && return 2
        # Wait for children to finish too if this is a daemon that forks
        # and if the daemon is only ever run from this initscript.
        # If the above conditions are not satisfied then add some other code
        # that waits for the process to drop all resources that could be
        # needed by services started subsequently.  A last resort is to
        # sleep for some time.
        start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
        [ "$?" = 2 ] && return 2
        # Many daemons don't delete their pidfiles when they exit.
        rm -f $PIDFILE
        return "$RETVAL"
}

#
# Function that sends a SIGHUP to the daemon/service
#
do_reload() {
        #
        # If the daemon can reload its configuration without
        # restarting (for example, when it is sent a SIGHUP),
        # then implement that here.
        #
        start-stop-daemon --stop --signal 1 --quiet --pidfile $PIDFILE --name $NAME
        return 0
}

case "$1" in
  start)
        [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
        do_start
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  stop)
        [ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
        do_stop
        case "$?" in
                0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
                2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
        esac
        ;;
  status)
        status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $?
        ;;
  #reload|force-reload)
        #
        # If do_reload() is not implemented then leave this commented out
        # and leave 'force-reload' as an alias for 'restart'.
        #
        #log_daemon_msg "Reloading $DESC" "$NAME"
        #do_reload
        #log_end_msg $?
        #;;
  restart|force-reload)
        #
        # If the "reload" option is implemented then remove the
        # 'force-reload' alias
        #
        log_daemon_msg "Restarting $DESC" "$NAME"
        do_stop
        case "$?" in
          0|1)
                do_start
                case "$?" in
                        0) log_end_msg 0 ;;
                        1) log_end_msg 1 ;; # Old process is still running
                        *) log_end_msg 1 ;; # Failed to start
                esac
                ;;
          *)
                # Failed to stop
                log_end_msg 1
                ;;
        esac
        ;;
  *)
        #echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
        echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
        exit 3
        ;;
esac

:

Después de modificarlo le he dado permisos de ejecución:

chmod +x /etc/init.d/cubieboardMonitor

Para que este script arranque como demonio se ha de ejecutar el siguiente comando:

update-rc.d cubieboardMonitor defaults

Links con información adicional y complementaria

Para la creación de este proyecto me he basado en la información publicada en este artículo: Tutorial de AngularJS. Ejemplo de aplicación web conectada a una API REST con Node

Links con información y descarga del tema AdminLTE

Almsaeed Studio
Documentación
Preview
Repositorio de github

Páginas con temas para AngularJS

Start Angular
20 Free Bootstrap 3 Admin Dashboard Templates For Your Web App 2016
15 Best Responsive HTML5 & CSS3 AngularJS Admin Templates To Build Awesome Web Apps 2016

Máquina virtual de desarrollo para proyectos de AngularJS y NodeJS

2016-06-30T01:47:00.000+02:00

Intentando afianzar mis conocimientos de AngularJS y NodeJS me he creado esta máquina virtual. En ella crearé todos los proyectos que usen estos frameworks de Javascript.

Información sobre máquina virtual

Esta máquina virtual la he creado con el VMware Player 12.

Características del hardware

La configuración del hardware usada ha sido la siguiente:

Memoria: 4Gb RAM.
Procesador: 1 procesador con 2 cores
Disco duro: disco SCSI de 40Gb, con fichero único autoexpandible.
CD-ROM: Usando unidad física, salvo en el momento de la instalación que se le ha asignado la imagen ISO del sistema operativo.
Adaptador de red: NAT.
Un controlador USB.
Pantalla.

El resto de hardware que se hubiera añadido de forma automática lo he eliminado.

Información sobre el sistema operativo

He instalado la distribución Fedora 23 de 64 bits con el escritorio LXDE.
Adicionalmente he actualizado el gestor de paquetes de yum a dnf, para esto he ejecutado los siguientes comandos:

sudo dnf install python-dnf-plugins-extras-migrate && dnf-2 migrate

Después de esto he actualizado el sistema operativo, para esto he ejecutado los siguientes comandos:

sudo dnf update

Instalación de utilidades que yo considero necesarias.

Las utilidades que considero necesarias dentro del sistema operativo y que no son las que permiten trabajar directamente con los frameworks son las siguientes:

Terminator

Como terminal he instalado esta herramienta, la cual me permite trabajar tanto a pantalla partida como con diferentes pestañas.
Para la instalación he ejecutado los siguientes comandos:

sudo dnf install terminator

Información adicional

Terminator

Navegadores

Para navegar y poder visualizar los proyectos generados he decidido instalar Firefox y Chrome.

Firefox

Para la instalación he ejecutado los siguientes comandos:

sudo dnf install firefox

Chrome

Para la instalación he seguido los siguientes pasos:

Cambiar a root:

su -

Después de esto he ejecutado el siguiente comando:

cat << EOF > /etc/yum.repos.d/google-chrome.repo
[google-chrome]
name=google-chrome - \$basearch
baseurl=http://dl.google.com/linux/chrome/rpm/stable/\$basearch
enabled=1
gpgcheck=1
gpgkey=https://dl-ssl.google.com/linux/linux_signing_key.pub
EOF

Para completar la instalación he ejecutado el siguiente comando:

dnf install google-chrome-stable

Información adicional

Install Google Chrome on Fedora 24/23, CentOS/RHEL 7.2

Filezilla

Como cliente de FTP he elegido el FileZilla.
Para la instalación he ejecutado los siguientes comandos:

sudo dnf install filezilla

Haroopad

Para mí es el editor que uso a diario y con el que genero la mayoría de la documentación.

Requerimientos previos

Se ha de instalar la siguiente librería:

sudo dnf install systemd-libs.i686 -y

Instalación de haroopad

El paquete de instalación lo he descarado desde la página de Haroopad.
El link de descarga que he utilizado es: Linux Binary (64bit) y la descarga la he realizado dentro del directorio ~/Descargas

Los comandos que he utilizado para realizar la instalación son:

cd ~/Descargas

tar zxvf haroopad-v0.13.1-x64.tar.gz

tar -zxvf data.tar.gz
sudo cp -R ./usr /

tar zxf control.tar.gz
chmod 755 postinst
sudo ./postinst

Para solucionar el problema de que no se ve el icono se han de realizar las siguientes modificaciones en el fichero /usr/share/applications/Haroopad.desktop.
Se ha de reemplazar la linea Icon=haroopad por Icon=/usr/share/icons/hicolor/128x128/apps/haroopad.png.

atom

Como editor de código he elegido a atom por su simplicidad y su capacidad de ampliarse con plugins.

Instalación:

El paquete de instalación lo he descarado desde la página de atom.
El link de descarga que he utilizado es: https://atom.io/download/rpm y la descarga la he realizado dentro del directorio ~/Descargas

Los comandos que he utilizado para realizar la instalación son:

cd ~/Descargas
sudo rpm -ivh atom.x86_64.rpm

En caso de error por dependencias se puede instalar ejecutando los siguientes comandos:

cd ~/Descargas
sudo dnf install atom.x86_64.rpm

plugins atom

Los plugins que he instalado dentro de atom han sido los siguientes:

AngularJS support in Atom
atom-beautify
atom-formatter-jsbeautify
Markdown preview

Control de versiones

Como control de versiones voy a usar git, ya que mi intención es publicar sobre github.

Para acceder a los proyectos guardados en GitHub he instalado los siguientes clientes de Git.

Git

Este es el cliente usado para cuando quiera trabajar por línea de comandos.
Para la instalación he ejecutado los siguientes comandos:

sudo dnf install git

SmartGit

Como cliente gráfico he elegido SmartGit.

Requerimientos

Se ha de instalar java:

sudo dnf install java

Instalación:

El paquete de instalación lo he descarado desde la página de SmartGit.
El link de descarga que he utilizado es: http://www.syntevo.com/smartgit/download?file=smartgit/smartgit-linux-7_1_2.tar.gz y la descarga la he realizado dentro del directorio ~/Descargas

Los comandos ejecutados para la instalación han sido

cd ~/Descargas
tar zxvf smartgit-linux-7_1_2.tar.gz -C /tmp/
sudo mv /tmp/smartgit /opt/
sudo ln -s /opt/smartgit/bin/smartgit.sh /usr/local/bin/smartgit

sudo /opt/smartgit/bin/add-menuitem.sh

Información adicional:

http://tutorialforlinux.com/2014/12/10/how-to-install-smartgit-client-on-fedora-32-64bit-linux/
http://tutorialforlinux.com/2014/12/10/how-to-create-a-smartgit-linux-desktop-menu-launcher-easy-guide/

Instalación de AngularJS y NodeJS

AngularJS

No requiere instalación.

Información adicional

https://angularjs.org/
https://carlosazaustre.es/blog/empezando-con-angular-js/
https://carlosazaustre.es/blog/tutorial-ejemplo-de-aplicacion-web-con-angular-js-y-api-rest-con-node/

NodeJS

Para la instalación de NodeJS he elegido la última versión (en el momento de escribir el artículo es la 6.x) y he ejecutado los siguientes comandos:

su -
curl --silent --location https://rpm.nodesource.com/setup_6.x | bash -
dnf -y install nodejs npm gcc-c++ make

Información adicional

Installing Node.js via package manager

bower

Los comandos que he utilizado para realizar la instalación de Bower son:

npm install -g bower

Grunt

Los comandos que he utilizado para realizar la instalación de Grunt son:

npm install -g grunt-cli

Información sobre la CPU de la cubietruck (cubieboard 3)

2016-06-23T00:34:00.000+02:00

Finalidad de artículo

La finalidad de este artículo es ampliar la información sobre el estado de la cubietruck que creé anteriormente y ampliar la información a mostrar en la web generada en el artículo anterior.

Nuevos comandos instalados

htop

htop es un visor de procesos interactivo para Linux. Es una aplicación en modo texto (para consola o terminales X) y requiere ncurses.

apt-get install htop

Scripts adicionales con información de CPU y memoria

Información del uso de CPU global:

El nombre usado para el script ha sido val_CPU.sh y se ha guardado dentro de /home/linaro/scripts.

El script realiza 2 lecturas del fichero /proc/stat con una diferencia de tiempo de 1 segundo, de esta forma resta las dos lecturas y devuelve el uso de CPU durante el último segundo. La variable que consulta es cpu.

Contenido del script

#!/bin/bash

function valor_USUARIO ()
{
    CPU_AUX=$2
    echo $CPU_AUX
}

function valor_NICE ()
{
    CPU_AUX=$3
    echo $CPU_AUX
}

function valor_SISTEMA ()
{
    CPU_AUX=$4
    echo $CPU_AUX
}

function valor_IDLE ()
{
    CPU_AUX=$5
    echo $CPU_AUX
}

INT_CPU1=$(cat /proc/stat | grep cpu | head -n1)
sleep 1
INT_CPU2=$(cat /proc/stat | grep cpu | head -n1)

CPU_USUARIO1=`valor_USUARIO $INT_CPU1`
CPU_USUARIO2=`valor_USUARIO $INT_CPU2`

CPU_NICE1=`valor_NICE $INT_CPU1`
CPU_NICE2=`valor_NICE $INT_CPU2`

CPU_SISTEMA1=`valor_SISTEMA $INT_CPU1`
CPU_SISTEMA2=`valor_SISTEMA $INT_CPU2`

CPU_IDLE1=`valor_IDLE $INT_CPU1`
CPU_IDLE2=`valor_IDLE $INT_CPU2`

CPU_USUARIO=`expr $CPU_USUARIO2 - $CPU_USUARIO1`
CPU_NICE=`expr $CPU_NICE2 - $CPU_NICE1`
CPU_SISTEMA=`expr $CPU_SISTEMA2 - $CPU_SISTEMA1`
CPU_IDLE=`expr $CPU_IDLE2 - $CPU_IDLE1`

CPU_TOTAL=`expr $CPU_USUARIO + $CPU_SISTEMA + $CPU_NICE`
CPU_MAXIMA=`expr $CPU_TOTAL + $CPU_IDLE`

# RATIO_CPU_USUARIO=`expr $CPU_USUARIO \* 100 / $CPU_MAXIMA`
# RATIO_CPU_SISTEMA=`expr $CPU_SISTEMA \* 100 / $CPU_MAXIMA`
RATIO_CPU_TOTAL=`expr $CPU_TOTAL \* 100 / $CPU_MAXIMA`

echo "$RATIO_CPU_TOTAL"

Ejemplo de llamada

/home/linaro/scripts/var_CPU.sh

Ejemplo de resultado

Información del uso de uno de los cores de la CPU:

El nombre usado para el script ha sido val_CPU_id.sh y se le pasa un parámetro con el identificador del core.
El identificador de core empieza en 0.

Contenido del script

#!/bin/bash

function valor_USUARIO ()
{
    CPU_AUX=$2
    echo $CPU_AUX
}

function valor_NICE ()
{
    CPU_AUX=$3
    echo $CPU_AUX
}

function valor_SISTEMA ()
{
    CPU_AUX=$4
    echo $CPU_AUX
}

function valor_IDLE ()
{
    CPU_AUX=$5
    echo $CPU_AUX
}

INT_CPU1=$(cat /proc/stat | grep cpu$1)
sleep 1
INT_CPU2=$(cat /proc/stat | grep cpu$1)

CPU_USUARIO1=`valor_USUARIO $INT_CPU1`
CPU_USUARIO2=`valor_USUARIO $INT_CPU2`

CPU_NICE1=`valor_NICE $INT_CPU1`
CPU_NICE2=`valor_NICE $INT_CPU2`

CPU_SISTEMA1=`valor_SISTEMA $INT_CPU1`
CPU_SISTEMA2=`valor_SISTEMA $INT_CPU2`

CPU_IDLE1=`valor_IDLE $INT_CPU1`
CPU_IDLE2=`valor_IDLE $INT_CPU2`

CPU_USUARIO=`expr $CPU_USUARIO2 - $CPU_USUARIO1`
CPU_NICE=`expr $CPU_NICE2 - $CPU_NICE1`
CPU_SISTEMA=`expr $CPU_SISTEMA2 - $CPU_SISTEMA1`
CPU_IDLE=`expr $CPU_IDLE2 - $CPU_IDLE1`

# CPU_USUARIO=$(cat /proc/stat | grep cpu0 | cut -f2 -d " ")
# CPU_NICE=$(cat /proc/stat | grep cpu0 | cut -f3 -d " ")
# CPU_SISTEMA=$(cat /proc/stat | grep cpu0 | cut -f4 -d " ")
# CPU_IDLE=$(cat /proc/stat | grep cpu0 | cut -f5 -d " ")

CPU_TOTAL=`expr $CPU_USUARIO + $CPU_SISTEMA + $CPU_NICE`
CPU_MAXIMA=`expr $CPU_TOTAL + $CPU_IDLE`

# RATIO_CPU_USUARIO=`expr $CPU_USUARIO \* 100 / $CPU_MAXIMA`
# RATIO_CPU_SISTEMA=`expr $CPU_SISTEMA \* 100 / $CPU_MAXIMA`
RATIO_CPU_TOTAL=`expr $CPU_TOTAL \* 100 / $CPU_MAXIMA`

echo $RATIO_CPU_TOTAL

Ejemplo de llamada

/home/linaro/scripts/var_CPU_id.sh 0

Ejemplo de resultado

Página web modificada para mostrar la nueva información obtenida

<?php

echo '<Hr /><H2>CPU</H2>';

echo '<Hr /><h3>Uso CPU</h3> <hr />';
echo '<pre>';
echo 'CPU total: ';
echo exec('/home/linaro/scripts/var_CPU.sh');
echo ' % ';
echo 'CPU 0: ';
echo exec('/home/linaro/scripts/var_CPU_id.sh 0');
echo ' % ';
echo 'CPU 1: ';
echo exec('/home/linaro/scripts/var_CPU_id.sh 1');
echo ' %';
echo '</pre>';

echo '<Hr /><h3>Temperatura CPU</h3><hr />';
echo '<pre>';
$ultima_linea = system('/home/linaro/scripts/temperatura.sh', $retval);
echo '</pre>';

echo '<Hr />';


echo '<br/>';
echo '<br/>';


echo '<Hr /><H2>DISCO DURO</H2>';

echo '<Hr /><h3>Temperatura disco duro</h3><hr />';
echo '<pre>';
$ultima_linea = system('sudo hddtemp /dev/sda', $retval);
echo '</pre>';

echo '<Hr /><h3>Espacio en disco</h3><hr />';
echo '<pre>';
$ultima_linea = system('df -h', $retval);
echo '</pre>';

echo '<Hr /><h3>SMART disco duro</h3><hr />';
echo '<pre>';
$ultima_linea = system('sudo smartctl -A /dev/sda', $retval);
echo '</pre>';

echo '<Hr />';
?>

Opening system of a showcase with arduino

2016-04-11T23:49:00.002+02:00

Description

The purpose of the project is to create a system of selective opening of shop windows.

The requirements are:

There are a total of 8 windows.
They must be able to open each of the 8 windows independently.
They must be able to open all the windows at once.
The time during which the locks must be opened is 1 minute.
There are 3 bolts for window.

Instructions

Components used

The components used have been:

Assembly of the circuit

The Fritzing scheme is as follows:

As can be seen in the following images, the system has been mounted on a pcb board 9x15.
The power supply has been chosen of 30A because each of the bolts uses 900 mA and there are 24 of these.
The LM2596S module has been used to reduce the input voltage to the Arduino from 12V to 6V.

Images of the system mounted inside the laboratory:

Upper detail of the assembled PCB.

Bottom detail of the assembled PCB.


Keyboard and relay block.

Connection of the relay block.

Complete system.

Software

To verify the address I2C of the relay block has been used the program called Arduino I2c Scanner.

The libraries used have been:

I2C_RL8xxM: library used to access the relay block.
Wire: library used to I2C connections and is a dependenciy of the I2C_RL8xxM library.
keypad: library used to manage the membrane keypad 4x3.

The code of the Arduino is the following:

Complementary and additional places in which the article has been published:

Máquina virtual para trabajar con documentos en Markdown - Nueva versión

2016-03-06T20:38:00.000+01:00

Después de estar trabajando con markdown durante un tiempo he ido actualizando y renovando las aplicaciones que utilizo. Por esto me he decido a volver a crear la máquina virtual desde cero, de esta forma aprovecho para actualizar tanto el sistema operativo, como las aplicaciones que utilizo.

Información sobre el sistema operativo.

He instalado la distribución Fedora 23 con el escritorio LXDE.

Adicionalmente he actualizado el gestor de paquetes de yum a dnf, para esto he ejecutado los siguientes comandos:

sudo dnf install python-dnf-plugins-extras-migrate && dnf-2 migrate

Instalación de utilidades que yo considero necesarias.

Las utilidades que considero necesarias dentro del sistema operativo y que no son las que permiten trabajar directamente con Markdown son las siguientes:

Yumex

Como gestor de paquetes he elegido a Yumex.
Para esto he ejecutado los siguientes comandos:

sudo dnf install yumex

Firefox

Para navegar y poder visualizar los documentos generados como web o website he elegido Firefox.
Para esto he ejecutado los siguientes comandos:

sudo dnf install firefox

Gimp

Como editor de imágenes he elegido Gimp.
Para esto he ejecutado los siguientes comandos:

sudo dnf install gimp

Servidor FTP

Como servidor de FTP para subir y bajar los ficheros a la máquina virtual he elegido el vsftp.
Para esto he ejecutado los siguientes comandos:

sudo dnf install vsftpd

Después de instalar el servidor de ftp se ha de activar en el firewall el servicio ftp, para que este sea accesible desde fuera de la máquina.

Los cambios realizados en el fichero de configuración del vsftpd (/etc/vsfptd/vsftpd.conf) son:

anonymous_enable=NO

También he desactivado el selinux (/etc/selinux/config), por que voy a trabajar en local y dentro de una máquina virtual.

SELINUX=disabled

Después de esto hay que reiniciar para que el selinux se desactive.

Cliente FTP

Como cliente de FTP he elegido el FileZilla.
Para esto he ejecutado los siguientes comandos:

sudo dnf install filezilla

GIT

Para acceder a los documentos guardados en GitHub he instalado el cliente de Git.
Para esto he ejecutado los siguientes comandos:

sudo dnf install git

Sublime text

Como editor general de textos he elegido el Sublime Text.
Para esto he seguido los siguientes pasos:

He descargado la versión 2 de: http://www.sublimetext.com/2

Después he ejecutado los siguientes comandos:

tar vxjf Sublime\ Text\ 2.0.2\ x64.tar.bz2
sudo mv Sublime\ Text\ 2 /opt/
sudo ln -s /opt/Sublime\ Text\ 2/sublime_text /usr/bin/sublime

Para la creación del fichero de acceso directo he seguido los siguientes pasos:

He creado el siguiente fichero desde el mismo sublime, ejecutando el siguiente comando:

sudo sublime /usr/share/applications/sublime.desktop

Dentro del fichero he insertado los siguientes dagos:

[Desktop Entry]
Version=2.0.2
Name=Sublime Text 2
# Only KDE 4 seems to use GenericName, so we reuse the KDE strings.
# From Ubuntu's language-pack-kde-XX-base packages, version 9.04-20090413.
GenericName=Text Editor

Exec=sublime
Terminal=false
Icon=/opt/Sublime Text 2/Icon/48x48/sublime_text.png
Type=Application
Categories=TextEditor;IDE;Development
X-Ayatana-Desktop-Shortcuts=NewWindow

[NewWindow Shortcut Group]
Name=New Window
Exec=sublime -n
TargetEnvironment=Unity

Instalación y uso de las utilidades de Markdown

Haroopad

Para mí es el editor que uso a diario, con el que genero la mayoría de la documentación.

Requerimientos previos

Se ha de instalar la siguiente librería:

sudo dnf install systemd-libs.i686 -y

Instalación de haroopad

El paquete de instalación lo he descarado desde la página de Haroopad.
El link de descarga que he utilizado es: Linux Binary (64bit)

Los comandos que he utilizado para realizar la instalación son:

tar zxvf haroopad-v0.13.1-x64.tar.gz

tar -zxvf data.tar.gz
sudo cp -R ./usr /

tar zxf control.tar.gz
chmod 755 postinst
sudo ./postinst

Uso

Es un cliente gráfico, no necesita usar la línea de comandos para su funcionamiento.

Información adicional

Página oficial de haroopad
Blog con información de como instalar el Haroopad en Fedora

Gitbook

Es el editor que uso para tener todo el contenido del blog o parte de el de forma offline y de libro.
La versión en el momento de la redacción del documento es la 2.5.2.

Requerimientos previos

Node.js

Para poder instalar el Gitbook se ha de instalar el gestor de paquetes de Node.js npm. Para instalarlo he ejecutado el siguiente comando:

sudo dnf install npm

Calibre

Para poder generar los libros en cualquier formato no web se necesita Calibre. Para instalarlo he ejecutado el siguiente comando:

sudo dnf install calibre

Instalación de gitbook desde npm

Para instalar el Gitbook desde el npm se ha de ejecutar el siguiente comando:

sudo npm install gitbook-cli -g

Uso

Para trabajar con los documentos con gitbook he creado la siguiente carpeta:

/home/juansal/gitbook

Inicializar un libro vacío:

Para inicializar un libro vacío se puede hacer de 2 formas diferentes:

Crear una carpeta para contener el libro, entrar en ella y ejecutar el siguiente comando:
```
gitbook init
```
Ejecutar el siguiente comando que crea la carpeta directamente:
```
gitbook init ./carpeta
```

Opciones disponibles:

  init [directory]      create files and folders based on contents of SUMMARY.md

Previsualizar y servir un libro:

Para previsualizar y servir un libro se puede hacer de 2 formas diferentes:

Desde dentro de la carpeta del libro:
```
gitbook serve
```
Desde fuera de la carpeta del libro:
```
gitbook serve ./repository
```

Opciones disponibles:

  serve [book]      Build then serve a gitbook from a directory
    --port      Port for server to listen on (Default is 4000)
    --lrport      Port for livereload server to listen on (Default is 35729)
    --watch      Enable/disable file watcher (Default is true)
    --format      Format to build to (Default is website; Values are website, json, ebook)
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

Generar web estática:

Desde dentro de la carpeta del libro:
```
gitbook build
```
Desde fuera de la carpeta del libro:
```
gitbook build ./repository
```

Opciones disponibles:

  build [book] [output]      build a book
    --format      Format to build to (Default is website; Values are website, json, ebook)
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

Generar pdf:

Desde dentro de la carpeta del libro:
```
gitbook pdf
```
Desde fuera de la carpeta del libro:
```
gitbook pdf ./repository
```

Opciones disponibles:

  pdf [book] [output]      build a book to pdf
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

Generar epub:

Desde dentro de la carpeta del libro:
```
gitbook epub
```
Desde fuera de la carpeta del libro:
```
gitbook epub ./repository
```

Opciones disponibles:

  epub [book] [output]      build a book to epub
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

Generar mobi:

Desde dentro de la carpeta del libro:
```
gitbook mobi
```
Desde fuera de la carpeta del libro:
```
gitbook mobi ./repository
```

Opciones disponibles:

  mobi [book] [output]      build a book to mobi
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

Ayuda completa de gitbook desde línea de comandos

Comando ejecutado:

gitbook

Resultado obtenido:

  Usage: gitbook [options] [command]

  Commands:

    versions                          list installed versions
    versions:print                    print current version to use in the current directory
    versions:available                list available versions on NPM
    versions:install [version]        force install a specific version of gitbook
    versions:link [folder] [version]  link a version to a local folder
    versions:uninstall [version]      uninstall a specific version of gitbook
    versions:update [tag]             update to the latest version of gitbook
    help                              list commands for a specific version of gitbook
    *                                 run a command with a specific gitbook version

  Options:

    -h, --help               output usage information
    -V, --version            output the version number
    -v, --gitbook [version]  specify GitBook version to use
    -d, --debug              enable verbose error

Comando ejecutado:

gitbook help

Resultado obtenido:

  build [book] [output]      build a book
    --format      Format to build to (Default is website; Values are website, json, ebook)
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

  pdf [book] [output]      build a book to pdf
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

  epub [book] [output]      build a book to epub
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

  mobi [book] [output]      build a book to mobi
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

  serve [book]      Build then serve a gitbook from a directory
    --port      Port for server to listen on (Default is 4000)
    --lrport      Port for livereload server to listen on (Default is 35729)
    --watch      Enable/disable file watcher (Default is true)
    --format      Format to build to (Default is website; Values are website, json, ebook)
    --log      Minimum log level to display (Default is info; Values are debug, info, warn, error, disabled)

  install [book]      install plugins dependencies

  init [directory]      create files and folders based on contents of SUMMARY.md

Información adicional

https://github.com/GitbookIO/gitbook/

Gitbook Editor Legacy

Este editor está descontinuado, pero funciona perfectamente para la versión de Gitbook indicada en este documento. Este editor me permite ver como quedaran los documentos antes de generarlos y de esta forma evitar tener que generar el documento para ver como quedará después de generado.

Requerimientos previos

Calibre

Para poder generar los libros en cualquier formato no web se necesita Calibre. Para instalarlo he ejecutado el siguiente comando:

sudo dnf install calibre

Instalación de gitbook editor legacy

Descargar el instalable desde la siguiente ruta: https://github.com/GitbookIO/editor-legacy/releases
Descomprimir usando:
```
tar zxvf gitbook-linux64.tar.gz
```

Renombrar y mover la carpeta de gitbook editor:

mv linux64 gitbook-editor
mv gitbook-editor ..

Por un bug en la referencia a una librería se ha de ejecutar el siguiente comando:
```
sudo ln -sf /lib64/libudev.so.1 /lib64/libudev.so.0
```

Arranque del script de instalación:

cd gitbook-editor
chmod +x *.sh
./install.sh

Ahora hay un icono en el menú inicio
Abrirlo y empezar

Uso

Es un cliente gráfico, no necesita usar la línea de comandos.

Información adicional

Página de github de Gitbook Editor Legady

Gitbook Editor

Este editor es la evolución del anterior y tiene conexión con los libros publicados en GitBook. Lo que no me gusta es la necesidad de git para poder crear libros que no desees subir a GitBook y tenerlos solamente en local.

Este editor no lo he instalado en mi máquina por no tener paquetes rpm para su instalación.

Información adicional

Página de github de Gitbook Editor

Leanpub

Esta herramienta es completamente web y no tiene cliente por línea de comandos ni offline.
Aunque es anterior a Gitbook la conocí después y la uso para lo mismo que ésta, para poder tener el blog de forma offline y de libro.
En mi caso genero los documentos en local y los subo mediante github. Después desde la web pido la generación del documento.

Información adicional

Página oficial de Leanpub
Manual online de Leanpub

Easybook

Este es el último de los generadores de documentos, a partir de Markdown, que conocí. En mi caso me gusta bastante para generar documentación compleja en formato web, me permite generar esta en un sólo documento html o en formato página web.

Requerimientos previos

Los requerimientos previos son los siguientes:

PHP
Composer

Los requerimientos complementarios son los siguientes:

PrinceXML
Kindlegen

PHP

Para instalar el php se ha de ejecutar el siguiente comando:

sudo dnf install php

Composer

Para instalar composer he ejecutado los siguientes comandos:

curl -sS https://getcomposer.org/installer | php -- --install-dir=/home/juansal --filename=composer
sudo cp composer /usr/bin

Información adicional de composer en su página oficial.

PrinceXML

Para instalar PrinceXML he descargado desde el navegador el siguiente fichero: CentOS 7 / 64-bit rpm y le he indicado a este que lo abra con el yumex, de esta forma este último instalará el paquete con sus dependencias.

Información adicional de PrinceXML en su página oficial

Kindlegen

Para descargar Kindlegen me he conectado a la página de este y desde ella he descargado el link: KindleGen v2.9 for Linux 2.6 i386 sobre la carpeta ~/Descargas/.

Después de descargar el fichero he creado la carpeta ~/kindlegen.

mkdir ~/kindlegen

He entrado en la carpeta creada y descomprimido el fichero descargado.

cd ~/kindlegen
tar zxvf ~/Descargas/kindlegen_linux_2.6_i386_v2_9.tar.gz

Instalación de Easybook

Para instalar Easybook se ha de lanzar el siguiente comando:

composer create-project easybook/easybook easybook

Una forma de saber si se ha instalado de forma correcta el programa se puede lanzar el siguiente comando:

./book

Si no dá un error el resultado de la ejecución de éste es similar a lo siguiente:

                     |              |    
 ,---.,---.,---.,   .|---.,---.,---.|__/ 
 |---',---|`---.|   ||   ||   ||   ||  \ 
 `---'`---^`---'`---|`---'`---'`---'`   `
                `---'

easybook is the easiest and fastest tool to generate
technical documentation, books, manuals and websites.

Available commands:
  benchmark   Benchmarks the performance of book publishing
  customize   Eases the customization of the book design
  help        Displays help for a command
  list        Lists commands
  new         Creates a new empty book
  publish     Publishes an edition of a book
  version     Shows installed easybook version

Uso

Para trabajar con los documentos con easybook he creado la siguiente carpeta:

/home/juansal/easybook

Inicializar un libro vacío:

Para inicializar un libro vacío se ha de lanzar el siguiente comando:

./book new "Titulo del libro"

Generar un libro en formato html

Para generar el libro en formato html se ha de ejecutar el siguiente comando:

./book publish Titulo-del-libro web

Generar un libro en formato web

Para generar el libro en formato várias páginas en html se ha de ejecutar el siguiente comando:

./book publish Titulo-del-libro website

Generar un libro en formato epub

Para generar el libro en formato epub se ha de ejecutar el siguiente comando:

./book publish Titulo-del-libro ebook

Generar un libro en formato mobi

Para generar el libro en formato mobi se ha de ejecutar el siguiente comando:

./book publish Titulo-del-libro kindle

Generar un libro en formato pdf

Para generar el libro en formato pdf se ha de ejecutar el siguiente comando:

./book publish Titulo-del-libro print

Información adicional

Página oficial de easybook
Página de github de easybook

Instalación de las vmware tools en linux, a partir de la versión 12 de VMware

2015-11-26T22:46:00.001+01:00

Información sobre la instalación de las vmware tools

A partir de esta versión de vmware, si intentas instalar las vmware tools lo primero que te recomienda el instalador es que no instales las que lleva el entorno y que te instales las open-vm-tools.

Página de VMware con la información

Página del proyecto en sourceforge
Página del proyecto en github

Comandos para realizar la instalación

UBUNTU / DEBIAN

El comando a ejecutar para realizar la instalación es el siguiente:

sudo apt-get install open-vm-tools

Si se dispone de entorno gráfico instalado, se ha de ejecutar también el siguiente comando:

sudo apt-get install open-vm-tools-desktop

CENTOS / FEDORA / RED-HAT

El comando a ejecutar para realizar la instalación es el siguiente:

sudo yum install open-vm-tools

Si se dispone de entorno gráfico instalado, se ha de ejecutar también el siguiente comando:

sudo yum install open-vm-tools-desktop

Sistema de apertura de un escaparate con arduino

2015-11-03T00:29:00.000+01:00

Descripción

La finalidad del proyecto es crear un sistema selectivo de apertura de escaparates.

Los requerimientos son los siguientes:

Hay un total de 8 escaparates.
Se han de poder abrir cada uno de los 8 escaparates de forma independiente.
Se han de poder abrir todos los escaparates a la vez.
El tiempo durante el cual los cerrojos deben de estar abiertos es de 1 minuto.
Hay 3 cerrojos por escaparate.

Instrucciones

Componentes usados

Los componentes usados han sido:

Montaje del circuito

El esquema en Fritzing es el siguiente:

Como puede observarse en las siguientes imágenes, el sistema ha sido montado sobre una placa pcb de 9x15.
La fuente de alimentación se ha elegido de 30A porque cada uno de los cerrojos usa 900 mA y hay 24 de estos.
El móldulo LM2596s ha sido usado para reducir el voltaje de entrada a el arduino de 12V a 6V.

Imágenes del sistema montado dentro del laboratorio:

Detalle superior de la placa montada.

Detalle inferior de la placa montada.


Teclado y bloque de relés.

Conexión del bloque de relés.

Sistema completo.

Software

Para comprobar la dirección I2C del bloque de relés se ha usado el programa llamado Arduino I2c Scanner.

Las librerías usadas han sido:

I2C_RL8xxM: librería usada para acceder al bloque de relés.
Wire: librería usada para las conexiones I2C y dependencia de la librería I2C_RL8xxM.
keypad: librería usada para la gestión del teclado 4x3.

El código del arduino es el siguiente:

Lugares complementarios y adicionales en los que se ha publicado el artículo:

Construcción de máquina recreativa - Agradecimientos

2015-09-21T16:00:00.000+02:00

A mi padre y a mi hermano por ayudarme con la parte de cortado y chapado de los tableros, además de ayudarme en el montaje del mueble.

A mi amigo Sergio por enseñarme a usar el soldador y echarme una mano con el monitor.

A la gente de los foros de máquinas de arcade de la que he obtenido ideas para poder montar la mía.

Al resto de gente que con sus ánimos y ayudas puntuales me han ayudado a acabar este proyecto.

Construcción de máquina recreativa - El Sonido

2015-09-20T16:00:00.000+02:00

Para el sonido de la máquina he utilizado unos altavoces viejos que tenía por casa y que hace tiempo usaba para el ordenador.

Altavoces desmontados

Una vez desmontados los he posicionado sobre la marquesina a ver como los repartía.

Altavoz situado sobre marquesina

Cuando he encontrado la posición en la que quería situarlos he hecho los agujeros pertinentes.

Agujeros altavoces realizados

Después de realizar los agujeros he montado los altavoces y el tubo de luz.

Altavoces y el tubo de luz de la marquesina

Una vez montado todo lo anterior he montado los embellecedores de los altavoces.

Embellecedores de los altavoces montados

Construcción de máquina recreativa - Los Controles

2015-09-19T16:00:00.000+02:00

Para el panel de control me he basado en el siguiente modelo:

Plantilla usada para posicionamiento de botones y palanca

Este modelo lo he obtenido del foro de ZonaArcade, del siguiente link:
http://zonaarcade.forumcommunity.net/?t=13788157

Los pasos que he seguido para diseñar y construir el panel de controles han sido los siguientes:

Primero he creado una plantilla de cartón para realizar las pruebas de distribución de botones y palancas.

Plantilla de cartón del planel de control

Plantilla sobre panel de control

Después de esto he hecho los agujeros del panel de control sobre un trozo de aglomerado de igual tamaño que este, para ver como quedaba y comprobar que estaba todo correcto.

Prueba panel de control

Después de comprobar que estaba todo correcto he hecho los agujeros sobre el panel real.

Panel de control - Agujeros realizados

Después de realizar los agujeros he procedido montar los botones y las palancas.

Botones y palancas montados

Después de montar los botones y palancas he montado el cableado de estos. Al mismo tiempo que estaba cableando los botones los etiqueté.

Detalle del cableado del panel de control

El panel de control, una vez montado, ha quedado de esta forma:

Panel de control acabado

Además de los botones de los controles le he añadido un botón frontal negro, puede apreciarse en la imagen anterior, para salir de los juegos, además de 2 botones para pinball (uno a cada lado de la máquina) y un monedero.

Botonera y monedero

Botón pinball izquierdo

Botón pinball derecho

Construcción de máquina recreativa - El Vídeo

2015-09-18T16:00:00.000+02:00

Para el vídeo de la máquina he utilizado un monitor viejo de 19 pulgadas de 4:3.

Monitor

Este monitor tiene el problema de que cuando se le alimenta no recuerda el estado anterior y siempre está apagado, para que se encienda se le ha de pulsar siempre el botón.
Para solucionar el problema he tenido que desmontarlo y meterle 2 cables para poder enchufarlo desde el exterior de la máquina.

Los pasos que he seguido para meter los cables han sido:

Lo primero que he hecho ha sido quitarle el marco al monitor y buscar en el panel de botones el botón de encendido

Monitor sin su marco

Después de encontrar el botón de encendido le he soldado 2 cables para poder conectar a un botón del frontal de la máquina.

Detalle de la botonera con los 2 cables soldados

Después de soldar los cables he hecho un agujero en la parte posterior del monitor para sacar los cables

Detalle del agujero hecho para sacar los cables

Una vez sacados los cables por el agujero he situado la botonera en su sitio y he cerrado el monitor.

Detalle de la botonera en su sitio con los cables ya soldados

Para que el monitor no se mueva he construido un soporte para este. El monitor y el soporte van unidos por un soporte de monitor vesa.

El soporte está formado por una pieza de madera que tiene la anchura de la máquina y de altura es un poco mayor que la del soporte del monitor vesa. Este ha sido fijado a la máquina con 4 escuadras, 2 a cada lado.

Soporte monitor

Conexión del monitor al soporte

Construcción de máquina recreativa - Mueble - Bezel

2015-09-17T16:00:00.000+02:00

Para el bezel he usado una chapa de 4 milímetros de grosor forrada en su parte visible con cartulina negra.

El agujero del monitor lo he hecho exactamente en el centro de la chapa y es del tamaño del interior del marco del monitor, de esta forma se evita que se vea.

Se ha dejado una pequeña solapa de cartulina dentro del agujero del monitor para que no se vea el marco de este.

Bezel con la parte de abajo forrada

Bezel acabado y montado

Construcción de máquina recreativa - Mueble - Botones de encendido y apagado de la máquina

2015-09-16T16:00:00.000+02:00

Para encendido y apagado de la máquina (ordenador y monitor) he incluido 5 pequeños botones en una zona no muy visible del frontal de la máquina.
Los 3 primeros botones son los encargados del encendido y apagado, y los 2 restantes son usados para simular la inserción de monedas.

Botones de encendido y apagado de la máquina

La funcionalidad de estos 5 botones es (de izquierda a derecha):

Encender / Apagar el PC
Resetear el PC
Encender / Apagar el monitor
Insertar monedas monedero 1
Insertar monedas monedero 2

Para el cableado encargado del PC he usado un cable de los que se usan en las cajas de ordenador para este propósito. A este cable le he quitado los botones que llevaba y le he empalmado un trozo de cable del usado para la máquina para alargarlo hasta el botón del frontal. El lado opuesto del cable lo he conectado a la placa base del PC (desconectando los de la caja actual).

Cable usado para conectar al PC los botones de arranque y reset de este

Para no equivocarme al conectar los cables, además de etiquetar a estos, he etiquetado cada uno de los botones en el interior de la caja.

Interior de la caja con el etiquetado de los botones del PC

Construcción de máquina recreativa - Mueble - Cableado

2015-09-15T17:00:00.000+02:00

Para el cableado de la máquina he usado 2 tipos de cable.

Manguera de 3 hilos.
- Entrada de alimentación eléctrica hasta la regleta.
- Alimentación luz marquesina.
Cable de 2 hilos usado para altavoces (rojo y negro).
- Resto de cableado de la máquina.

Dentro de la máquina he puesto una regleta para poder enchufar allí el ordenador y el monitor.

El resto de componentes de la máquina que requieren alimentación lo hacen directamente desde la fuente de alimentación del ordenador. Para esto me hice un cable en el que en la punta que va hacia el ordenador es un conector molex y la punta a la que se le conectan los cables es una ficha de empalme con 4 secciones.

Gran parte de los cables han sido puestos dentro de regletas de luz, separando los que van a 220v., del resto.

Entrada luz, subida alimentación marquesina, alimentación ventiladores y cables altavoces

Alimentación regleta, subida alimentación marquesina, cables conectados a ordenador

Detalle cable botón encendido monitor

Cables conectados a IPAC, alimentación luces, botones mapeados del ordenador y del monitor

Detalle cables conectados al PC

Construcción de máquina recreativa - Mueble - Entrada de alimentación y ventilación

2015-09-14T18:06:00.001+02:00

La ventilación se encuentra en la parte superior trasera y está formada por 2 ventiladores de PC de 8x8 cm., con sus correspondientes embellecedores, tanto por fuera como por dentro.

Para la entrada de corriente he usado una muy parecida a la original de la máquina.

Exterior entrada alimentación y ventilación

Interior entrada alimentación y ventilación

Construcción de máquina recreativa - Mueble - Construcción del mueble

2015-09-13T22:55:00.000+02:00

Para la construcción del mueble he utilizado tableros de aglomerado de melamina negra de 19 mm de grueso.

Los cantos han sido chapados con canto de PVC de color negro.

Los laterales han sido marcados y contados a partir de la plantilla de cartón que he hecho de la máquina original, añadiéndole los 10 cm. de más.

Plantilla usada para la máquina

La unión de las piezas se ha realizado utilizando listones cuadrados de 2 cm. x 2 cm., consiguiendo que de esta forma no se vean los tornillos desde fuera.

El montaje se ha realizado encima de una mesa y la máquina colocada en posición horizontal, para su mejor montaje.

Laterales

Resto de piezas

He empezado por la parte de abajo, que es la que más clara tenía.

Inicio del montaje

Montaje

Después he montado la balda sobre la que se apoyará el monitor y los cristales del bezel.

Montaje, parte trasera

He acabado con la parte de arriba, que es la que menos clara tenía.

Montaje, frontal

Para la puerta he utilizado una bisagra de piano, la cual da robustez a la puerta.

Puerta montada

Detalle de la bisagra de la puerta

Puerta cerrada.

Para poder mover la máquina he montado 4 ruedas locas con bloqueo.

Ruedas

Para el panel de control también he utilizado una bisagra de piano.

Detalle de la bisagra usada para el panel de control

Construcción de máquina recreativa - Introducción

2015-09-12T21:24:00.000+02:00

Esta recreativa está basada en una VideoVal, ésta la conseguimos entre tres amigos, pero ante la imposibilidad de quedar para arreglarla, decidí hacerme yo una desde cero.

De esta máquina hice una plantilla del lateral con cartón y a partir de la plantilla obtuve las medidas y la forma.

He de resaltar que mi máquina es un poco más alta que la original, le di 10 cm. más de alto, ya que me parecía un poco baja la original. Aunque de pequeño recuerdo que a veces teníamos que subir a las banquetas para poder jugar bien, en ese momento parecían muy altas.

Recreativa original

Mi recreativa

Organizar fotos por fecha usando Zoner Photo Studio

2015-07-07T23:38:00.000+02:00

En mi caso me gusta organizar las fotografías que hago por fechas. La estructura de carpetas que uso es la de Año-Mes-Dia, de esta forma se quedan lar carpetas ordenadas de forma cronológica.
Para hacer esto de forma automática utilizo el Zoner Photo Studio, este programa me permite hacer esto de forma automática.
Lo que cuento el los siguientes puntos es válido tanto para las versiones gratis como para las versiones de pago.

Programa en Inglés

Se ha de estar en la pestaña Manager, dentro de la carpeta a organizar.
Se selecciona el menú: Organize > Sort Pictures o se pulsa directamente ctrl + o.
Dentro de la pantalla:

Enter source drive or paht: -> se deja como está el programa ha dejado el nombre de la carpeta en la que estamos.
Select picture sorting method -> se selecciona Custom y en la casilla de abajo se introduce {TM#FD:"yyyy-MM-dd"}
Choose a target folder for the pictures: -> Se selecciona la carpeta destino.
Se pulsa Next.

En la siguiente pantalla:

Se selecciona lo siguiente:
- Bitmap
- Vector
- Video
- Sound
Se deselecciona lo siguiente:
- Only sort files larger than
Se pulsa Next.

En la siguiente pantalla:

Se seleccionan todas las carpetas que se quieran escanear y ordenar
Se selecciona la opción Include subfolders in selection.
Se pulsa finish.

Programa en castellano

Se ha de estar en la pestaña Administrador, dentro de la carpeta a organizar.
Se selecciona el menú: Organizar > Ordenar fotografías o se pulsa directamente ctrl + o.
Dentro de la pantalla:

Introduzca la unidad de origen o la ruta: -> se deja como está el programa ha dejado el nombre de la carpeta en la que estamos.
Seleccione el método de ordenación de fotografías -> se selecciona Personalizado y en la casilla de abajo se introduce {TM#FD:"yyyy-MM-dd"}
Elija una carpeta de destino para sus fotografías: -> Se selecciona la carpeta destino.
Se pulsa Siguiente.

En la siguiente pantalla:

Se selecciona lo siguiente:
- Mapa de bits
- Vector
- Vídeo
- Audio
Se deselecciona lo siguiente:
- Sólo ordenar archivos más grandes de:
Se pulsa Siguiente.

En la siguiente pantalla:

Se seleccionan todas las carpetas que se quieran escanear y ordenar
Se selecciona la opción Incluir subcarpetas en la selección.
Se pulsa finish.