Control de terminales Android


Family Link de  Google puede ayudar a configurar determinadas reglas básicas sobre el uso de la tecnología pues tenga en cuenta que las aplicaciones de Google no se han diseñado teniendo en mente a los menores,  de modo que si quiere ayudar a su  hijo a tomar decisiones acertadas cuando utilice su dispositivo  Android , esta app  que vamos a ver , y  que ya esta disponible en España ,sin duda es una interesante opción , aunque  debe  saber    que el tutor o padre es quien decide finalmente las aplicaciones y los servicios que puede utilizar el menor.

 

 

 

En efecto desde hace unos  días ya esta disponible en España ( y pronto en el resto de países  que usan la lengua española  )    la  app para instalar en nuestros terminales Google Family Link, una   aplicación  de control parental oficial de Google  disponible  gratuitamente  en Google Play que permite a los padres supervisar el uso que los menores   hacen de sus terminales móviles  o tabletas.

 

Con Family Link se puede crear una cuenta de Google para un menor similar a la suya, con acceso a la mayoría de los servicios de Google, y, al mismo tiempo, establecer algunas normas básicas sobre la experiencia digital de su familia:

  •  Gestionando las aplicaciones que puede usar el menor: aprobando o bloqueando las  apps  que quiera descargar de Google Play Store.
  •  Controlando el tiempo de conexión permitiendo consultar cuánto tiempo usa el menor  sus aplicaciones favoritas mediante los informes de actividad semanal o mensual, y configurando  límites de tiempo de conexión diarios.
  •  Configurando  horas para  dormir en el dispositivo: con esta función puede bloquear los dispositivos de manera remota cuando sea la hora de dormir o de hacer un descanso.

 

bloqueo.PNG

Ademas una de las características clave de Google Play Family (razon por las que nos pide  una tarjeta de credito al instalar la app por primer a vez ) es es que podremos compartir apps y contenidos,  que hayamos comprado, con nuestra familia ( hasta un grupo de seis personas)

Ademas de las apps  es  extensible a las películas  y música  que compramos, que podrán ser descargadas y utilizadas por los otros cinco componentes del plan, por lo que nos ahorraremos mucho dinero con determinadas aplicaciones o juegos que, en lugar de tener que comprar todos, podremos comprar solo una única vez.

Para poder usar Family Link  se necesita :

  • Un dispositivo Android compatible para el menor con  Android 7.0 (Nougat) o versiones posteriores. Algunos dispositivos con Android 5.0 y 6.0 (Lollipop y Marshmallow) también puedan ejecutar Family Link.

  • Una cuenta de Google para el menor  que se gestione con Family Link: No deja usar cuentas ya creadas porque  los menores en  cada  país  tienen una política de privacidad distinta, así que hay que aceptarla y generar un usuario nuevo. La  edad mínima para usar YouTube  en USA es 13 años razón por la que no  deja instalar esta app pero para usar otras aplicaciones de redes sociales lógicamente  también existe una edad mínima en este caso de 14 años, aunque también depende del país. Todo esto viene en el disclaimer, aviso legal de la app cuando la instalas. En algo tan serio como a que se exponen nuestros hijos en Internet creo que merece la pena leerte por una vez lo que estas aceptando.

  • Para los padres, madres y tutores  un dispositivo Android 4.4 (Kit Kat) o versiones posteriores, o  un  iPhone con iOS 9 o versiones posteriores.

  • Una cuenta de Google

  • Encontrarse  en un país donde la aplicación esté disponible:en Estados Unidos, México, Argentina, Chile o Brasil, Europa, y los usuarios españoles pueden empezar a utilizarla desde hoy.

 

Como vemos un  gran inconveniente  es que  se requiere  un terminal muy actual pues se recomienda un android 7.0  para los menores,  mientras  que el del tutor   puede ser  uno mas antiguo(Android 4.4)   o incluso un Iphone

La  app  es técnicamente  gratuita pero es posible que Google verifique su tarjeta de crédito para confirmar que estás dando su consentimiento como padre, madre o tutor al crear una cuenta de Google para su hijo o hija aunque donan todos los fondos de estas transacciones a una organización para la protección de los niños.

Su gran limitación , ademas de la versión de Android para los menores, es como puede suponerse, que requiere  cuentas  de gmail  para los menores   nuevas , es decir no sirven cuentas facilitadas en el trabajo o centro educativo u otras que se tengan  pues  Family Link solo funciona con cuentas de Google creadas a través de esta aplicación para niños menores de 13 años (o la edad que corresponda según la legislación vigente en su jurisdicción). Cuando el niño cumpla esta edad, podrá seguir utilizando Family Link si quiere

 

 

Pasos para Instalar y configurar Google Family link

En el terminal paterno ,lo primero es descargar desde Google Play Store  desde el link oficial  ( o buscando Google Family Link)

También es posible instalar la aplicación paterna de control en un terminal iOS ( para los menores por el momento no , es decir solo Android 7)

Rápidamente  le aparecerá un breve asistente para guiarle en el  proceso completo   que solo tiene  tres  pasos:

Enseguida nos va  a preguntar la cuestión  principal sobre el terminal del menor ya que se aconseja este  sea Android 7.0 (Nougat) o versiones posteriores.

Algunos dispositivos con Android 5.0 y 6.0 (Lollipop y Marshmallow) también puedan ejecutar Family Link. pero no esta asegurado su funcionamiento

 

 

 

Ahora   tendremos que aceptar las condiciones contractuales si estamos de acuerdo  , por  lo que debemos que aceptar esta pantalla  vinculando la nueva cuenta que se cree al menor  con la cuenta del tutor

 

Ahora   ya lo siguientes  toca crear la cuenta del menor por  lo que tendremos que darle nuevamente a siguiente

Vamos por el segundo paso,  así que   volveremos a  dar a  siguiente:

 

Finalmente desde la propia app nos va a permitir crear la cuenta del menor

 

Ahora ya solo tenemos que seleccionar el nombre  y apellidos del hijo

 

 

Lo siguiente que nos pedirá es a la  fecha de nacimiento del menor así como  un nombre de usuario para su cuenta de Gmail (que debe ser único ) y una contraseña.

 

 

Finalmente de cara al terminal del tutor  tendrá que facilitar los datos de una  tarjeta bancaria ( se recomienda de delito   y a ser posible virtual o de prepago)    para otorgar el consentimiento parental para crear la cuenta.

 

Una vez configurado la app toca ir al terminal Android del menor   donde tendremos  que introducir la cuenta que se  haya creado para él de modo que  Android identificará que este forma parte de Family Link  asi que que tendremos que introducir las credenciales de tutor para avanzar en la configuración del terminal del menor

En este el proceso puede restringir las aplicaciones que no se quiere  que pueden utilizar y el asistente  irá guiando por los distintos pasos.

 

Revise detenidamente las aplicaciones del dispositivo de su hijo e inhabilite aquellas que no quiera que use. En  muchos casos   es posible que no pueda inhabilitar algunas aplicaciones preinstaladas en determinados terminales.

Se puede asimismo en este paso personalizar los controles de Google Play, crear filtros de contenido y de búsqueda, ver qué aplicaciones ha instalado y restringir las que no  parezcan apropiadas, ver su ubicación en tiempo real y configurar el tiempo en pantalla.

 

 

 

La actividad de algunas aplicaciones, como las de reproducción de música y las de mensajería que se ejecutan en segundo plano, no se registra por completo en los informes de actividad semanal o mensual.

Aunque Family Link  ayuda a gestionar las compras y las descargas de los menores, este no necesitará la  aprobación del tutor para instalar actualizaciones de aplicaciones (incluidas aquellas que amplían permisos), las aplicaciones que haya aprobado anteriormente ni las que se hayan compartido en la colección familiar,  así que los padres, madres o tutores deben revisar de manera periódica qué aplicaciones tiene instaladas su hijo y los permisos de las aplicaciones en Family Link.

 

 

 

Anuncios

Open sw para analítica y monitorizacion


En efecto vamos  a   hablar de Grafana ,un software de  código abierto, rico en muchas características, potente, elegante ideal par analytics  y monitorizacion  que se puede ejecutar en Linux, Windows y MacOS.

Tal es su aceptación  que de hecho es un software de facto para el análisis de datos,  utilizado  en DStack overflow, eBay, PayPal, Uber y Digital  Ocean – sólo por mencionar algunos.

Soporta más  de 30 código abierto así como fuentes de datos bases de datos comerciales incluyendo MySQL, PostgreSQL, Graphite, Elasticsearch, OpenTSDB, Prometheus y InfluxDB . Le permite  digerir profundamente en grandes volúmenes de datos en tiempo real, datos operativos; visualizaciones, consultas, establecer alertas y obtener ideas de sus métricas desde ubicaciones de almacenamiento diferentes.

Es de destacar  que, Grafana permite la creación de múltiples configuraciones   independientes  teniendo su propio entorno de uso (administradores, fuentes de datos, paneles y usuarios).

Grafana Analytics Monitoring Software

Algunas características de Grafana

  • Elegantes gráficos para visualización de datos.
  • Gráficos rápidos y flexibles con muchas opciones.
  • Cuadros de mando dinámicos y reutilizables.
  • Es altamente extensible en cientos de paneles de control y plugins de la biblioteca oficial.
  • Ayudas de alimentación las preferencias del usuario.
  • Soporta multi tenancy, configuración de múltiples organizaciones independientes.
  • Compatible con la autenticación via LDAP, Google Auth, Grafana.com y Github.
  • Soporta notificaciones via Slack, PagerDuty y mas
  • Apoya notable colaboración que permite compartir datos y cuadros de mando a través de equipos y mucho más.
  • Una demostración en línea está disponible para probar antes de instalar Grafana en tu distribución Linux.: Demo URL: http://play.grafana.org/

 

En este post vamos a explicar cómo instalar software Grafana – visualización de datos y monitoreo en las distribuciones CentOS, Debian y Ubuntu .

Instalar Grafana en sistemas Linux

1. Vamos a instalar Grafana desde sus repositorios YUM o APT para que usted pueda actualizar con su administrador de paquetes predeterminado.

Instalar Grafana en Debian y Ubuntu

$ echo "deb https://packagecloud.io/grafana/stable/debian/ stretch main" | sudo tee -a /etc/apt/sources.list
$ curl https://packagecloud.io/gpg.key | sudo apt-key add -
$ sudo apt-get update
$ sudo apt-get install grafana

Instalar Grafana en RHEL, CentOS y Fedora

# echo "[grafana]
name=grafana
baseurl=https://packagecloud.io/grafana/stable/el/7/$basearch
repo_gpgcheck=1
enabled=1
gpgcheck=1
gpgkey=https://packagecloud.io/gpg.key https://grafanarel.s3.amazonaws.com/RPM-GPG-KEY-grafana
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt" | sudo tee /etc/yum.repos.d/grafana.repo
# yum install grafana

2. Después de instalar Grafana, puede encontrar archivos importantes en las siguientes ubicaciones:

  • El Binario se instala en /usr/sbin/grafana-server
  • Instala el script de Init.d para /etc/init.d/grafana-server
  • Crea archivo predeterminado (entorno vars) a /etc/default/grafana-server
  • Instala el archivo de configuración para /etc/grafana/grafana.ini
  • Instala servicio systemd service  grafana-server.service
  • La configuración predeterminada establece el archivo de registro en /var/log/grafana/grafana.log
  • La configuración predeterminada especifica un db de sqlite3 en /var/lib/grafana/grafana.db
  • Instala JS/HTML/CSS y otros archivos de Grafana en /usr/share/grafana

3. A continuación, iniciar el servicio Grafana , y  comprobar si esta levantado  y funcionando, habitándolo  para el inicio automático en el arranque siguiente. De forma predeterminada, el proceso se ejecuta como el usuario grafana (creado durante el proceso de instalación) y escucha en el puerto HTTP  3000.

Iniciar servidor de Grafana (a través de Systemd)

# systemctl daemon-reload
# systemctl start grafana-server
# systemctl status grafana-server
# systemctl enable grafana-server

Iniciar servidor de Grafana (a través de init.d)

# service grafana-server start
# service grafana-server status
# sudo update-rc.d grafana-server defaults  [On Debian/Ubuntu]
# /sbin/chkconfig --add grafana-server      [On CentOS/RHEL/Fedora]

4. Si su sistema tiene un firewall activado por defecto, necesita abrir el puerto 3000 en el firewall para permitir las solicitudes de cliente para el proceso de grafana.

-----------  [On Debian/Ubuntu] -----------
$ sudo ufw allow 3000/tcp
$ sudo ufw reload
-----------  [On CentOS/RHEL/Fedora] -----------  
# firewall-cmd --permanent --add-port=3000/tcp
# firewall-cmd --reload

5. Ahora utilice la siguiente URL para acceder a la Grafana, que le redirigirá a la página de inicio de sesión, las credenciales de usuario como username: admin y contraseña: admin)

http://Your-Domain.com:3000
OR
http://IP-Address:3000

Grafana Admin Login

6. Después del inicio de sesión, usted accederá a la consola casera, como se muestra en la imagen de abajo.

Grafana Home Dashboard

7. A continuación, agregar un origen de datos o base de datos, haga clic en “Agregar origen de datos“. Por ejemplo vamos a añadir una base de datos MySQL ; especificar los parámetros de nombre, tipo y conexión de fuente de datos. Haga clic en Guardar y probar.

Add Grafana Data Source

Se le notificará si la conexión de base de datos es exitosa o ha fracasado, como se muestra en la captura de pantalla.

Luego volver a la consola Inicio para añadir un panel nuevo.

Grafana Data Source Connection

8. En el panel de Inicio , haga clic en tablero de instrumentos nuevo para añadir un nuevo panel para visualizar parámetros de origen de datos.

Add Grafana New Dashboard

Desde aquí, puede agregar más fuentes de datos, dashboards, invitar a los miembros de su equipo, instalar aplicaciones y plugins para extender las funcionalidades por defecto y hacer más.

Puede encontrar más información de la Grafana Homepage: https://grafana.com/

 

Fuente tecmint.com

Datalogger de posicionamiento con Raspberry Pi y Azure


CÓDIGO

AzureIoTRegistryManagerApp C #
Este es el código de acceso y gestión Azure Registro Hub IO, haciendo uso de la clase RegistryManager.
////The MIT License(MIT)
////Copyright(c) 2016 BardaanA

////Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

////The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

////THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

using System;
using System.Threading.Tasks;

// These are the Microsoft's recommended libraries to access
// and make changes to Azure IoT Hub's Registry
using Microsoft.Azure.Devices;
using Microsoft.Azure.Devices.Common.Exceptions;

// This namespace which also dictates the name of the Assembly can be anything you desire.
namespace AzureIoTRegistryManagerApp
{
    class Program
    {
        // RegistryManager object which is going to do most of the work for our application
        static RegistryManager registryManager;
        // This here is the Connection String that you copied from the IoT Hub Shared Access Policies > iothubowner > Shared access keys; remember??
        static string connectionString = "Don't forget to replace this with your own connection string";
        // Keeps track of the registry access status
        static string registryAccessStatus = "";

        static void Main(string[] args)
        {
            try
            {
                // Let's try and create a Registry Manager using our connection string, shall we?
                registryManager = RegistryManager.CreateFromConnectionString(connectionString);
                registryAccessStatus = "Successfuly connected to the IoT Hub registry"; // Yay!
            }
            catch(Exception ex)
            {
                Console.WriteLine("Registry access failed!  {0}",ex.Message);  // Bummer!!
            }
            // Check if RegistryManager was created successfully
            if(registryManager != null)
            {
                Console.WriteLine("*****************************************************");
                Console.WriteLine("===== Welcome to the Azure IoT Registry Manager =====");
                Console.WriteLine();
                Console.WriteLine("++ {0} ++",registryAccessStatus);
                Console.WriteLine();
                int menuSelection = 0;
                while(menuSelection != 3)  // Loop to keep you going...
                {
                    Console.WriteLine("  1) Add device into registry");
                    Console.WriteLine("  2) Remove device from the registry");
                    Console.WriteLine("  3) Close this application");
                    Console.WriteLine("------------------------------------");
                    Console.Write("Enter your selection: ");
                    menuSelection = int.Parse(Console.ReadLine());
                    Console.WriteLine();
                    switch(menuSelection)
                    {
                        case 1:
                            Console.Write("Enter device name that you want to register: ");
                            string deviceName = Console.ReadLine();
                            Console.WriteLine();
                            if(deviceName.Length > 0 && !deviceName.Contains(" "))  // Weak validation :)
                            {
                                // Calling method that actually adds the device into the registry
                                AddDevice(deviceName).Wait();
                            }
                            else
                            {
                                Console.WriteLine("---");
                                Console.WriteLine("Enter valid name!");
                                Console.WriteLine("---");
                            }
                            break;
                        case 2:
                            Console.Write("Enter name of the device to be removed: ");
                            string deviceRemoveName = Console.ReadLine();
                            Console.WriteLine();
                            if(deviceRemoveName.Length > 0 && !deviceRemoveName.Contains(" "))  // Weak validation :(
                            {
                                // Calling method that actually removes the device from the registry
                                RemoveDevice(deviceRemoveName).Wait();
                            }
                            else
                            {
                                Console.WriteLine("---");
                                Console.WriteLine("Enter valid name!");
                                Console.WriteLine("---");
                            }
                            break;
                        case 3:
                            // Breaks out of the loop
                            break;
                        default:
                            Console.WriteLine("---");
                            Console.WriteLine("Choose valid entry!");
                            Console.WriteLine("---");
                            break;
                    }
                }
                // Closes the RegistryManager access right before exiting the application
                registryManager.CloseAsync().Wait();
            }
        }

        // Method used to add device into the Registry, takes in a string as a parameter
        private static async Task AddDevice(string deviceId)
        {
            // A Device object
            Device device;
            try
            {
                // Lets try and create a Device into the Device Registry
                device = await registryManager.AddDeviceAsync(new Device(deviceId));
                if(device != null)
                {
                    Console.WriteLine("Device: {0} added successfully!",deviceId); // Hooray!
                }
            }
            catch(DeviceAlreadyExistsException)  // What?
            {
                Console.WriteLine("---");
                Console.WriteLine("This device has already been registered...");// When did I do that??
                Console.WriteLine("---");
                device = await registryManager.GetDeviceAsync(deviceId);
            }
            Console.WriteLine();
            Console.WriteLine("Generated device key: {0}",device.Authentication.SymmetricKey.PrimaryKey);  // Now you're talking!
            Console.WriteLine();
        }

        // Method used to remove a device from the Device Registry, takes a string as a parameter
        private static async Task RemoveDevice(string deviceId)
        {
            try
            {
                // Lets try and get rid of the Device from our registry, using the device id.
                await registryManager.RemoveDeviceAsync(deviceId);
                Console.WriteLine("Device: {0} removed successfully!",deviceId);  // Yup!
            }
            catch(DeviceNotFoundException)
            {
                Console.WriteLine("---");
                Console.WriteLine("This device has not been registered into this registry!");  // Are you sure??
                Console.WriteLine("---");
            }
        }
    }
}

Fuente aqui

Controle su Roomba con Arduino y Android


 

iRobot Roomba Create2 es una a  plataforma grande y muy asequible para el desarrollo de la robótica, costando alrededor de US$ 200 permitiendo  una variedad de métodos de programación. Como  comienzo mjrovi usó  un Arduino y una aplicación Android para mover el robot  por puerto serie  consiguiendo asi controlar  sus motores, LEDS y sonido.

Como uno de los ganadores de 2016 del concurso de robótica   en Instructables, mjrovi recibió como premio un iRobot Roomba Create2.

 

 

La Roomba es un robot de impulsión diferenciada, con 2 ruedas motrices y una rueda  central  guía. Su velocidad va hasta 500 mm/s y puede ser mandado a ir hacia arriba o hacia atrás.
Para señalización, contamos con cuatro 7 segmentos display y 5 LEDs :

  • Limpiar
  • Punto
  • Muelle
  • ADVERTENCIA/Check
  • Suciedad/escombros

Como sensores internos, tenemos entre otros:

  • Detector de acantilado (4 en el frente)
  • Detectores Bump (frente 2)
  • Codificadores de rueda

Para la programación, el documento: iRobot® Create® 2 abierto interfaz (OI) debe ser utilizado.El Roomba puede ser programado en 3 modos:

  1. Modo pasivo:Al enviar el comando de Start o cualquiera de los comandos de modo de limpieza (por ejemplo, punto limpio, muelle buscar), la OI entra en modo pasivo. Cuando la OI está en modo pasivo, puede solicitar y recibir datos de los sensores usando cualquiera de los comandos del sensor, pero no puede cambiar los parámetros de comando actuales para los actuadores (motores, altavoces, luces, controladores de lado de baja, salidas digitales) a otra cosa.
  2. Modo seguro :Le da un control completo de Roomba, con excepción de las siguientes condiciones relacionadas con la seguridad:
    Cargador conectado y alimentado:detección de una caída de rueda (en cualquier rueda),detección de un acantilado mientras se mueve hacia adelante (o hacia atrás con un pequeño radio de torneado, menos de un radio de robot) o si ocurre una de las condiciones relacionadas con la seguridad mientras que el OI es en modo seguro, Roomba detiene todos los motores y vuelve al modo pasivo.
  3. Modo completo:Le da un control completo sobre Roomba, todos de sus actuadores y todas las condiciones relacionadas con la seguridad que están restringidas cuando la OI en modo seguro, como el modo completo se apaga el acantilado, caída de rueda y características de seguridad cargador interno.

Comunicaciones

Para  programar la Romba  la lista de  materiales  usada es la siguiente:

  • iRobot Create2
  • Arduino UNO
  • Módulo Bluetooth HC-06
  • Pulsador

Para la comunicación entre la Roomba y Arduino, se utilizará el puerto Serial. Por defecto, Roomba comunica a 115.200 baudios, pero para comunicarse con Arduino, se cambiará a 19.200.

Hay 2 formas de establecer la tasa de baudios de Roomba:

  1. Mientras que apagar Roomba, continúan mantenga pulsado el botón de encendido o limpiar después de que la luz se ha apagado. Después de unos 10 segundos, Roomba juega una melodía descendente de las echadas. Roomba se comunicará a 19.200 baudios hasta que el procesador pierde energía de la batería o la tasa de baudios se modifica explícitamente a través de la OI.
  2. Utilizar el pin de cambio de tasa de baudios (pin 5 del conector mini-DIN) para cambiar la velocidad en baudios de Roomba. Después de encender la Roomba, esperar 2 segundos y luego pulso el cambio de la tasa de baudios baja tres veces. Cada impulso debe durar entre 50 y 500 milisegundos. Roomba se comunicará a 19200 baudios hasta que el procesador pierde energía de la batería o la tasa de baudios se modifica explícitamente a través de la OI.

 

El diagrama de arriba muestra cómo la Arduino debe conectarse al conector mini-DIN de Roomba

 

 

Lo primero creo que debe hacerse cuando un Roomba de programación es “Despertar” el robot y  Definir el modo (segura o completa)

Nosotros podemos  hacer  un “wake-up”, enviar un poco de pulso al pin mini-DIN 5 (detección de dispositivo de entrada) como se muestra en la siguiente función:
void wakeUp (void)
{
setWarningLED(ON);
digitalWrite(ddPin, HIGH);
delay(100);
digitalWrite(ddPin, LOW);
delay(500);
digitalWrite(ddPin, HIGH);
delay(2000);
}

Para empezar a Roomba deberán enviarse 2 códigos de siempre: «START» [128] y el modo, en nuestro caso “Modo seguro” [131]. Si usted quiere un “modo completo”, debe enviarse en su lugar el código [132].
void startSafe()
{
Roomba.write(128); //Start
Roomba.write(131); //Safe mode
delay(1000);
}

 

Como se describe en la introducción, el Roomba tiene 5 LEDs:

  • Energía/limpiar (bicolor rojo/verde e intensidad controladas)
  • Punto (verde, intensidad fija)
  • Muelle (verde, intensidad fija)
  • ADVERTENCIA/Check (naranja, intensidad fija)
  • Suciedad/escombros (azul, fija la intensidad)

 

Control de leds

Todos los LEDs pueden ser ordenados mediante código [139]
Para controlar el LED de encendido, debe enviar dos bytes de datos a Roomba: “color” y la “intensidad”.
Color:

  • Verde = 0
  • Naranja = 128
  • rojo = 255

Intensidad:

  • Bajo = 0
  • Max = 255

La función setPowerLED (colores bytes, setIntensity bytes) lo hace:

void setPowerLED(byte setColor, byte setIntensity)
{
color = setColor;
intensity = setIntensity;
Roomba.write(139);
Roomba.write((byte)0x00);
Roomba.write((byte)color);
Roomba.write((byte)intensity);
}

Por ejemplo, para encender el LED de POWER de color naranja en la mitad de su intensidad, usted puede llamar a la función como bramido:setPowerLED (128, 128);

Encender los 4 LEDs restantes, deberán utilizarse las siguientes funciones:
setDebrisLED(ON);
setDockLED(ON);
setSpotLED(ON);
setWarningLED(ON);

Todas las funciones anteriores tiene un código similar a este:
void setDebrisLED(bool enable)
{
debrisLED = enable;
Roomba.write(139);
Roomba.write((debrisLED ? 1 : 0) + (spotLED ? 2 : 0) + (dockLED ? 4 : 0) + (warningLED ? 8 : 0));
Roomba.write((byte)color);
Roomba.write((byte)intensity);
}

Básicamente, la diferencia será la línea: debrisLED = habilitar;  debe modificarse permitiendo a cada uno de los otros LEDs (spotLED, dockLED, warningLED).

 

Envío de mensajes

Roomba tiene cuatro 4 displays de 7 segmentos que puede utilizar para enviar mensajes de dos maneras::
[163] código: Dígitos LED crudo (numérico)
[164] código: Dígitos LED de ASCII (aproximación de letras y códigos especiales)
Para mostrar números  debe enviar el código [163], siguiendo las 4 digitas a mostrar. La función: setDigitLEDs (bytes digit1 digit2 bytes, digit3 bytes, digit4 bytes) lo hace para usted:

void setDigitLEDs(byte digit1, byte digit2, byte digit3, byte digit4)
{
Roomba.write(163);
Roomba.write(digit1);
Roomba.write(digit2);
Roomba.write(digit3);
Roomba.write(digit4);
}

Por ejemplo, para mostrar “1, 2, 3, 4”, debe llamar a la función: setDigitLEDs (1, 2, 3, 4);

Con el código [164], es posible enviar aproximación de ASCII.

La función setDigitLEDFromASCII (dígitos de byte, char letra) hace esto para nosotros:
void setDigitLEDFromASCII(byte digit, char letter)
{
switch (digit){
case 1:
digit1 = letter;
break;
case 2:
digit2 = letter;
break;
case 3:
digit3 = letter;
break;
case 4:
digit4 = letter;
break;
}
Roomba.write(164);
Roomba.write(digit1);
Roomba.write(digit2);
Roomba.write(digit3);
Roomba.write(digit4);
}

Para simplificar, crear una nueva función para enviar los 4 dígitos al mismo tiempo:
void writeLEDs (char a, char b, char c, char d)
{
setDigitLEDFromASCII(1, a);
setDigitLEDFromASCII(2, b);
setDigitLEDFromASCII(3, c);
setDigitLEDFromASCII(4, d);
}

Por ejemplo, para mostrar “STOP”, usted debe llamar a la función: writeLEDs (‘s’, ‘ t ‘, ‘ o ‘, ‘p’);

Mover la  Roomba

Para la movilidad, Roomba tiene 2 motores independientes que pueden programarse para ejecutar 500mm/s. Hay varios comandos que pueden utilizarse para controlar el robot. Los principales son:

  • Código [137]: Unidad == > debe enviar +-velocidad en mm/s y +-radio en mm
  • Codigo [145] de código: Impulsión directa == > debe enviar izquierda velocidad en mm/s (+ para adelante y para atrás)
  • Código [146]: Unidad PWM == > debe enviar +-datos PWM para la izquierda y derecha las ruedas

 

A continuación el código para estas 3 opciones:

void drive(int velocity, int radius)
{
clamp(velocity, -500, 500); //def max and min velocity in mm/s
clamp(radius, -2000, 2000); //def max and min radius in mm

Roomba.write(137);
Roomba.write(velocity >> 8);
Roomba.write(velocity);
Roomba.write(radius >> 8);
Roomba.write(radius);
}

//—————————————————————

void driveWheels(int right, int left)
{
clamp(right, -500, 500);
clamp(left, -500, 500);

Roomba.write(145);
Roomba.write(right >> 8);
Roomba.write(right);
Roomba.write(left >> 8);
Roomba.write(left);
}

//—————————————————————
void driveWheelsPWM(int rightPWM, int leftPWM)
{
clamp(rightPWM, -255, 255);
clamp(leftPWM, -255, 255);

Roomba.write(146);
Roomba.write(rightPWM >> 8);
Roomba.write(rightPWM);
Roomba.write(leftPWM >> 8);
Roomba.write(leftPWM);
}

Tenga en cuenta que la función de “fijar” define los valores máximos y mínimos que se permitieron la entrada. Esta función se define en el archivo rombaDefines.h:

#define abrazadera (valor, min, max) (valor < min? min: valor > max? max: valor)
Utilizando el código anterior, se pueden crear funciones más simples para Roomba alrededor de:
/—————————————————————
void turnCW(unsigned short velocity, unsigned short degrees)
{
drive(velocity, -1);
clamp(velocity, 0, 500);
delay(6600);
drive(0,0);
}

//—————————————————————
void turnCCW(unsigned short velocity, unsigned short degrees)
{
drive(velocity, 1);
clamp(velocity, 0, 500);
delay(6600);
drive(0,0);
}

//—————————————————————
void driveStop(void)
{
drive(0,0);
}

//—————————————————————
void driveLeft(int left)
{
driveWheels(left, 0);
}

//—————————————————————
void driveRight(int right)
{
driveWheels(0, right);
}

Tenga en cuenta que para girar en ángulo, debe calcularse el argumento de “retraso” específicamente para una velocidad dada

A continuación algunos ejemplos que pueden utilizar para probar los motores:

turnCW (40, 180); girar 180 grados hacia la derecha y parada
driveWheels (20, -20); vuelta
driveLeft(20); girar a la izquierda

Para las pruebas de los motores, es bueno añadir un pulsador externo (en mi caso conectado al Arduino pin 12), para que puedan descargar el código de Arduino, a partir de la Roomba, pero parando la ejecución hasta que se pulsa la tecla. Generalmente, para los motores de prueba lo puedes hacer en la parte de configuración del código.

Como ejemplo, consulte el código de Arduino simple abajo (nota que el código usa funciones y definiciones desarrollaron antes):

#include “roombaDefines.h”
#include

// Roomba Create2 connection
int rxPin=10;
int txPin=11;
SoftwareSerial Roomba(rxPin,txPin);

//———————————————
void setup()
{
Roomba.begin(19200);

pinMode(ddPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP); // connected to Arduino pin 12 and used for “starting”

delay(2000);

wakeUp (); // Wake-up Roomba
startSafe(); // Start Roomba in Safe Mode

while (digitalRead(buttonPin)) { } // wait button to be pressed to continous run code

turnCW (40, 180); //test Roomba spin clock-wise 180 degrees and stop
}

//———————————————
void loop()
{

}

 

Controlar la Roomba a través de Bluetooth

Para controlar  Roomba de modo inalambrico   vamos a instalar un módulo Bluetooth (HC-06) a nuestro Arduino. El diagrama de arriba muestra cómo hacerlo. Suele ser el HC-06 settle up de fábrica con una velocidad de 9.600. Es importante cambiarlo a 19.200 para ser compatible con la velocidad de la comunicación de Arduino-Roomba. Usted puede hacer que el envío un comando AT para el módulo (AT + BAUD5 donde “5” es el código de 19.200).

Para controlar la Roomba, utilizaremos una aplicación genérica que fue desarrollada por jrovai   para el control de robots móviles, con el MIT AppInventor 2: “MJRoBot BT Remote Control”. La aplicación puede descargarse gratuitamente de la tienda de Google a través del enlace: aplicación: MJRoBot BT Remote Control.

La aplicación tiene una interfaz sencilla, lo que le permite enviar comandos al módulo de BT en ambos, modo de texto o directamente a través de botones preprogramados (cada vez que se pulsa un botón, un carácter se envía):

  • w: hacia adeñante
  • S: hacia atras
  • d: derecho
  • a: izquierda
  • f: parada
  • p: ON / OFF (no usado en esta primera parte)
  • m: manual / automático (se utiliza para reiniciar Roomba si un obstáculo como un acantilado se encuentra en modo seguro)
  • +: Velocidad +
  • -: Velocidad –

También puede enviar otros comandos como texto si es necesario. También hay una ventana de texto para los mensajes recibidos desde el módulo de BT. Esta característica es muy importante durante la fase de prueba, puede ser utilizado en la misma forma que el “Serial Monitor”.

El loop() parte del código será “escuchando” el dispositivo bluetooth y dependiendo del comando recibido, tomar una acción:

void loop()
{
checkBTcmd(); // verify if a comand is received from BT remote control
manualCmd ();
}
La función checkBTcmd() se muestra a continuación:

void checkBTcmd() // verify if a command is received from BT remote control
{
if (BT1.available())
{
command = BT1.read();
BT1.flush();
}
}
Una vez que se recibe un comando, la función manualCmd() tomará la acción apropiada:
void manualCmd()
{
switch (command)
{

case ‘m’:
startSafe();
Serial.print(“Roomba in Safe mode”);
BT1.print(“Roomba BT Ctrl OK – Safe mode”);
BT1.println(‘\n’);
command = ‘f’;
playSound (3);
break;

case ‘f’:
driveStop(); //turn off both motors
writeLEDs (‘s’, ‘t’, ‘o’, ‘p’);
state = command;
break;

case ‘w’:
drive (motorSpeed, 0);
writeLEDs (‘ ‘, ‘g’, ‘o’, ‘ ‘);
state = command;
break;

case ‘d’:
driveRight(motorSpeed);
writeLEDs (‘r’, ‘i’, ‘g’, ‘h’);
break;

case ‘a’:
driveLeft(motorSpeed);
writeLEDs (‘l’, ‘e’, ‘f’, ‘t’);
break;

case ‘s’:
drive (-motorSpeed, 0);
writeLEDs (‘b’, ‘a’, ‘c’, ‘k’);
state = command;
break;

case ‘+’:
if (state == ‘w’)
{
motorSpeed = motorSpeed + 10;
if (motorSpeed > MAX_SPEED)
{
motorSpeed = MAX_SPEED;
}
command = ‘w’;
} else {command = state;}
break;

case ‘-‘:

if (state == ‘w’)
{
motorSpeed = motorSpeed – 10;
}
if (motorSpeed < MIN_SPEED )

{ motorSpeed = MIN_SPEED; }

Serial.println(motorSpeed); command = state; break; } }

 

 

 

El código de Arduino completo utilizado en documentos aquí relacionados se puede encontrar en GITHUB en https://github.com/Mjrovai/Roomba_BT_Ctrl

Varias de las funciones que   el autor  ha creado en su  programa se basaron en la biblioteca de crear 2 desarrollada por Dom Amato. Puede descargar la librería completa en‎: https://github.com/brinnLabs/Create2.

Software para CNC


Aunque  vivimos sin duda  una gran revolución  con la impresión 3d, de forma  silenciosa ,pero firme ,  también estamos viviendo  un considerable avance en el mundo de las maquinas tradicionales de todo tipo (fresadoras, piro-grabadoras, dibujo, corte, láser, etc. )  , eso si  ,controladas no por maquinas especificas diseñadas para su control como antaño , sino  simplemente por cualquier  ordenador y  por potentes  software de control que sin duda permite  obtener resultados completamente profesionales.

Estas maquinas conocidas como router CNC  o simplemente  CNC  en efecto son adecuadas para tallar madera, acrílico o metal blando, madera nativa, PCB CCL, PVC y un largo etcétera  lo cual permite infinidad   de aplicaciones para los profesionales  y también para los aficionados  al bricolaje  y  a la electrónica  dado que su precio  así como también  su tamaño  han hecho que estén accesibles a  casi todos los bolsillos .

Un  router CNC  se puede simplemente comprar  ya montado , en kit  con  todos los componetes ya preparados para montarlos por uno mismo  o fabricarlo  por uno mismo (en la web de OpenBuilds han publicado unos interesantes vídeos sobre una maquina llamada OX  y todo el proceso ), pero en todo caso   su coste suele ser una fracción de lo que cuesta una impresora 3d   en parte porque   normalmente se va a mover sobre solo dos ejes y no requiere  otras partes   que añaden coste y complejidad al  equipo ( un eje z largo , el extrusor o la cama caliente)

 

Una de las utilidades que ya comentamos en un post anterior es la  posibilidad de realizar placas de circuito impreso (PCB),  pero hay muchísimas opciones  como cortar madera, realizar grabados , escultura   y un largo etcétera

 

 

Para  fabricar  placas de circuito   impreso  con  una maquina  CNC   comentamos en  este post  , el   potente  programa    OPenCNCPilot que  nos permite obtener resultado muy profesionales  precisos y limpios  sin usar peligrosos líquidos  peligrosos, pero para otros  usos , sin  duda   bCNC   es  otro programa muy versátil   que  permite controlar  CNC que funcionen a través de arduino y que usen el firmware grbl.

bCNC

Este programa en un gestor GRBL es un    CNC command sender, autoleveler y editor de g-code

Cuenta con un  emisor avanzado de códigos g para GRBL . Este programa es  multiplataforma (Windows, Linux, Mac) escrito en python. El remitente es robusto y rápido capaz de trabajar muy bien con hardware antiguo o lento como Rasperry PI (como fue validado por el mainter de GRBL en pruebas pesadas)  y como vamos  a ver tiene infinidad de opciones.

Como no podía  ser  de otra manera  también permite realizar placas de circuito impreso:

 

bCNC screenshot

Instalación

 

El sw  se puede descargar directamente  desde https://github.com/vlachoudis/bCNC

Necesitará los siguientes paquetes para ejecutar bCNC

  • tkinter el conjunto de herramientas gráficas para python Dependiendo de su python / OS ya puede estar instalado o bajo los nombres tkinter, python-tkinter, python-tk
  • pyserial o bajo el nombre python-serial, python-pyserial
  • python-image-tk: las bibliotecas PIL para el mapa de altura de autolevel  (opcional)
  • python-opencv: para la transmisión por webcam en el colgante web(opcional)

Expanda el directorio o descárguelo desde github y ejecute el comando bCNC

Puede modificar la mayoría de los parámetros desde la página “Herramientas -> Máquina”. Solo los cambios / diferencias del archivo de configuración predeterminado se guardarán en su directorio de inicio $ {HOME} /. BCNC o ~ / .bCNC

La configuración predeterminada se almacena en bCNC.ini en el directorio de instalación. (POR FAVOR NO CAMBIE ESTE)

 

Menú editor Gcode

Entre sus características principales esta el editor de gcode, que nos permite hacer modificaciones sin tener que volver al software CAM.

Entre las opciones del menú de edición podemos nombrar las funciones de copiar y pegar lo que nos permite duplicar una porción del código, opciones de selección de bloques de código lo que nos facilita la edición.

El botón insertar nos permite, agregar lineas de código dentro de un bloque, clonar nos permite duplicar bloques, ademas tenemos botones para eliminar bloques, habilitar o deshabilitar bloques para que estos no se ejecuten pero sin borrarlos.

Los botones de Subir y Bajar , cambian el orden en el que se ejecuta un bloque de código,esto nos permite ordenar el gcode a nuestro gusto, y también tenemos una herramienta para invertir el orden de los bloques seleccionados.La herramienta mover nos permite cambiar la posición de los bloques simplemente seleccionando un bloque y arrastrarlo a la posición deseada. Necesaria para mover bloques que fueron clonados o copiados.El botón de establecer origen nos permite mover todo el trabajo, a la posición donde hagamos clic con el ratón.

Adicionalmente tenemos herramientas de rotar y reflejar y botones que nos permiten invertir el la dirección del corte.

Menú Herramientas

En el menú herramientas o tools tenemos la posibilidad de configurar los materiales o sustratos que usamos y guardarlos en una base de materiales y lo mismo podemos hacer con las herramientas de corte. Esto nos sirve en caso de que generemos las trayectorias directamente desde bCNC.

Ya que en bCNC es posible importar directamente vectores DXF o SVG y hasta tiene soporte para STL.

Dentro de las opciones cam, tenemos herramientas para hacer cortes, perfilados y taladrados.También podemos ahuecar una superficie, generar pestañas y aplanar superficies.

Y   aqui   vienen realmente  las posibilidades de este programa :

E

  • BOWL   Bowl, sirve para generar una concavidad o como su propio nombre loo describe un bowl.
  • BOX :Box es una herramienta para generar cajas con encastres como las que se encuentran en la web pero esta integrada con el programa , ademas las trayectorias generadas con para corte con fresa o con router cnc ya que compensa la circunferencia de la herramienta.Para poder generar una caja lo único que tenemos que hacer es darle los valores de altura, ancho, y profundidad ( X, Y, Z), ademas de la cantidad de encastres que queremos en cada cara y seleccionar el tipo de corte perfilado (Por fuera) , o corte (por sobre).Y por ultimo presionamos el botón ejecutar y se nos genera el g-code de nuestra caja con encastres.
  • Driller:El Driller nos permite generar trayectorias de taladrado, a lo largo de un vector, como se puede ver en la imagen hemos creado una seria de taladrados a lo largo de un vector con forma de circulo.
  • Aplanado (Flatten):Esta herramienta es muy simple nos permite generar una trayectoria de aplanado, con nuestro router cnc, solo tenemos que darle las coordenadas de los ejes X e Y para el inicio, y luego el alto, el ancho y la profundidad final del aplanado.Luego damos en el botón ejecutar y se nos genera el código G correspondiente.
  • Gear – Generador de Engranajes:Esta opción nos permite generar engranajes, los parámetros que debemos pasarle con el numero de dientes el angulo del diente y el diámetro.
  • Heightmap – Mapas de altura:Los mapas de altura son imágenes en escala de grises, que el programa interpreta como ALTOS los colores obscuros y como bajos los colores claros.Bcnc tiene la función heightmap que lo que hace es generar una trayectoria de corte a distintas profundidades generando así un relieve o corte en 3d.Pero en vez de usar un modelo 3d se pueden usar imágenes o fotografías pero para obtener buenos resultados se requiere que la imagen tenga las condiciones adecuadas de luz y sombras.
  • Pyrograph – Pirograbado con router cnc: El pirograbado es similar al grabado con láser, pero en vez de utilizar un haz de luz láser para el grabado, (lo cual es bastante peligroso si no se toman las medidas  de protección correspondientes  ) , utilizando en su lugar  una punta caliente o pirograbador. Bcnc cuenta con una herramienta para generar gcode para pirograbado, este gcode lo que hace es recorrer la imagen variando la velocidad de avance o feed rate para así lograr mayor o menor grado de quemado sobre la madera o material a grabar, sin cambiar la altura del eje Z.Para hacer una trayectoria de pirograbado necesitamos una imagen de preferencia en escala de grises, y luego pasar los parámetros.Diámetro de la punta, altura de trabajo en Z, tamaño máximo, velocidad mínima, velocidad máxima, dirección del recorrido, y la imagen a grabar.Luego damos click en execute y se nos genera el gcode correspondiente, si ven la imagen anterior parece que el gcode solo fuera un recorrido recto, pero eso es por que solo varia la velocidad de avance de la herramienta no la altura en Z.
  • Spirografo – Generador de patrones espirografico.:Interesante si le gustan los espirografos….
  • Text Generator – Generador de Texto para CNC o Imagen Texto:Interesante herramienta para generar texto para cortar letras con tu cnc o Láser.Solo tendremos que introducir el texto deseado elegir el archivo del tipo de fuente que queramos, establecer parámetros como anchura de los caracteres y listo.Pero esta herramienta tiene una función extra que es la capacidad de generar un texto a partir de una imagen.

 Menu maquina o (machine)

En este menú tendremos la posibilidad de configurar las características de nuestro router cnc o Láser. Primero configuramos las unidades, por defecto vienen configurado para milímetros así que a menos que queramos trabajar en pulgadas no deberemos tildar la opción UNITS (INCHES).

La siguiente opción es LaserCutter esta opción solo se deberá activar si en vez de un router cnc tenemos un cortador o grabador Láser. Lo que hace esta opción es activar el uso del los comandos gcode para control de un modulo láser por ttl. Esta opción esta disponible para la versión del firmware GRBL V1.1

En los siguientes nueve parámetros podremos configurar las aceleraciones, velocidades, y recorrido máximo para cada eje de nuestro router o maquina cnc.La opción decimal digits nos permite configurar cuentos decimales le enviara el programa al firmware en los movimientos de los ejes.Luego tenemos resolución de arcos, por defecto en 0,1.

Startup es el gcode de inicio que se envía a la maquina por defecto G90 ( distancias absolutas) si queremos movimientos incrementales tenemos que poner ( G91).Spindle RPM maximas y minimas.

Y por ultimo el header gcode y footer gcode, estos son los gcodes de inicio y fin nos sirve para por ejemplo hacer que se encienda nuestro husillo y que se ajuste a las rpm deseadas antes de empezar y el de fin nos sirve para mover los ejes a una posición deseada luego de finalizado el corte o trabajo.

Control

En esta pestaña es donde vamos a pasar ms tiempo ya que aquí están todas las herramientas de control mas comunes de cualquier software para cnc.

Primero tenemos los botones para crear, abrir y guardar gcode o cualquier archivo con el que vallamos a trabajar. Ademas tenemos el botón de HOME, que lo que hace es enviar el comando G28.

Lo que hace es mover los ejes en busca de los finales de carrera, luego el botón de unlock que nos permite desbloquear nuestra maquina ( recordar que GRBL firmware tiene una opción para bloquear los movimientos de los ejes. ), y por ultimo el reset que reinicia el firmware.

Ahora le toca el turno a una de las funciones que yo mas valoro de este software, y aunque es muy simple también resulta muy util.

Scan

SCAN este botón nos permite hacer un recorrido por los margenes de nuestro vector, gcode o diseño. De modo que al presionarlo los ejes X e Y se moverán recorriendo los limites del espacio que ocupa el modelo.   Esta función es muy útil cuando deseamos saber si lo que vamos a cortar, entra dentro del sustrato o de la pieza a cortar. También podremos determinar si la posición a cortar sera la que necesitamos. Hay que tener la precaución de levantar el eje Z a una posición en la que no tenga riesgos de colisionar con la pieza o algún otro obstáculo.

Debajo de scan tenemos otros botones que son 2, 3, 4, 5 y 6, estos botones son programables o personalizables aquí podemos escribir comandos.

Por ultimo los botones de control de gcode:  Start inicia el corte o trabajo, pause nos permite pausar el trabajo y stop detienen el proceso que se este ejecutando. Luego tenemos el visualizador del estado de la maquina, donde veremos el estado de la conexión con el cnc, las posiciones de trabajo y las posiciones de la maquina.

Debajo de la posición de caga eje tenemos 3 botones con la inscripción X=0, Y=0 y Z=0. Estos nos permiten establecer el cero de cada eje para la posición de trabajo.

Ahora vemos la sección workspaces, donde tenemos 6 espacios de trabajo (G54, G55, G56, G57, G58 y G59)  donde podremos personalizar distintas configuraciones para aplicarlas al trabajo que estemos por realizar. Aquí podremos definir valores como el el modo de desplazamiento (absoluto o incremental), las unidades de trabajo (mm o Pulgadas) plano de trabajo (XY, YZ o ZX),

 

Control de los ejes

Aquí tendremos acceso a los botones correspondientes al control manual de los ejes de nuestro cnc donde ademas podremos seleccionar la cantidad de unidades de desplazamiento.También vemos que podremos controlar el feed rate, al vuelo mientras estamos realizando un corte o trabajo con nuestro cnc.

Y de el mismo modo podremos acceder al control de rpm de nuestro husillo.

Visor de trabajo

A la derecha tenemos el visor del gcode o archivo que estemos por ejecutar, aquí podremos seleccionar entre distintos planos de vista, ( XY, XZ, YZ, ISO1, 2, 3).Ademas tenemos los controles de zoom in y zoom out y mostrar todo.Ahora en la sección tool tenemos la herramienta de selección que lo que nos permite es seleccionar partes de nuestro gcode para realizar acciones como eliminar o desactivarlas entre otras.b También tenemos la herramienta mover visor que lo que hace es mover la posición del modelo en el visor.

Y ahora vemos las funciones MoveGantry y Set Work Position,

  • Move gantry nos permite mover con 2 click el cabezal a la posiciones de nuestro gcode que le indiquemos en el visor.Asi por ejemplo si yo hago click en move Gantry y luego hago click en el centro de mi gcode formado por 2 círculos concéntricos, los ejes X e Y se moverán hasta alcanzar la posición señalada con el puntero.Esto es muy útil por ejemplo para saber donde estará el centro de mi gcode en el material o pieza a cortar, de modo que con esta herramienta podremos movernos con 2 clics a cualquier posición de nuestro plano de visión. Tener en cuenta que los ejes se moverán de a cuerdo al plano de visión, de modo que si estamos en el plano X-Z los ejes que se moverán serán X y Z.
  •  SetWorkPosition;Esta botón también es uno de los mas usados en Bcnc ya que nos permite establecer la posición de trabajo de nuestros ejes con solo hacer 2 clicks.Como en el ejemplo anterior, con set work position podremos con solo 2 clicks decirle al programa que en la posición donde hicimos click es donde están posicionados nuestros ejes X e Y en este momento. Otro ejemplo de uso seria, mover nuestros ejes a una posición determinada donde queremos que quede el centro de nuestro trabajo, y luego damos click en SetWorkPosition y luego hacemos click en el centro de nuestro gcode en el visor.

Ademas en la sección Draw tenemos botones para activar o desactivar la visualización de las diferentes partes de nuestro trabajo. Primero tenemos el botón Display Axis, que lo que hace es activar o desactivar la visualización de los ejes del visor.Después tenemos Grid Lines que activa o desactiva la visualización de la cuadricula.

Display Margins lo que hace es activar o desactivar la visualización de los margenes.

Por ultimo activar o desactivar la visualización de los movimientos G1, G2 y G3 o los movimientos de corte y también tenemos un botón para desactivar los movimientos G0 o los movimientos Rápidos.

 

 

Terminal

Ademas bcnc nos provee de un terminal desde el que podremos enviar comando manuales a nuestro cnc, en grbl es muy útil por ejemplo para hacer la configuración de los valores de la eeprom. Y para dar por finalizado este recorrido por las características y herramientas de bcnc, nos vamos a la pestaña files: Aquí vamos a encontrar la configuración de la conexión con nuestra maquina, donde podremos seleccionar el puerto serie donde tenemos conectado nuestro arduino, y la velocidad de comunicación o baudrate.

 

 

Hemos recorrido la mayoría de las funciones disponibles en este estupendo  software Libre para control de una  CNC llamado Bcnc.

Una nueva de crear placas de circuito impreso


Un circuito impreso no es mas que una placa aislante sobre la cual se dibujan “pistas” e “islas” de cobre las cuales formaran el trazado de dicho circuito, partiendo de un plano  creado normalmente desde un esquema eléctrico que se pasa a pcb con un programa de enrutamiento ,aunque obviamente ese se puede hacer de forma manual.

Para empezar tenemos que decidir que material vamos a precisar  pues si se trata de un circuito donde vayan  a estar señales de radio o de muy alta frecuencia tendremos que usar  placas de  fibra de  vidrio o de pertinax, que es un material poco alterable por la humedad o de lo contrario, para la mayoría de las aplicaciones, con placa de fenólico , baquelita , etc pueden  ser  mas que suficiente.

pcb2.PNG

Tradicionalmente los PCB  se realizaban a partir de un método foto-químico : se exponía con luz una placa de cobre cubierta de emulsión fotosensible  con un acetato  transparente que contenida el diseño de las pistas   , luego se revelaba y finalmente se atacaba con  un ácido , el cual  normalmente era cloruro ferrico(FeCI3)   o una disolución de agua oxigenada de 100 volúmenes y   agua fuerte(H2SO4)

Mas modernamente   con las fotocopiadoras o las impresoras láser  , se ha sustituido la placa fotosensible por simplemente una  fotocopia con el diseño del pcb  que se pone cara abajo con la placa virgen y  se plancha el conjunto

plancha.PNG

Después del planchado  se humedece en agua caliente , se retira el papel (con cuidado  de romper la tiras de tinta ) y luego se ataca  finalmente con  un ácido  que también puede ser una disolución de agua oxigenada de 100 volúmenes y   agua fuerte(H2SO4) o  cloruro ferrico(FeCI3).

Este proceso ultimo por cierto requiere que  pulamos con lana de acero o el estropajo de aluminio hasta que quede brillante pues dependiendo de como quede de limpia se pegará mas o menos el toner (de nuestra fotocopia)  en la placa.

pcb1

Hasta ahora hemos descrito como se hacían ( y/o  se siguen haciendo) muchas placas de circuito impreso para uso personal pero ¿y si existiera algún otro método menos engorroso,limpio, eficiente,profesional   y menos peligroso para hacer una placa de circuito impreso?

Pues en efecto se puede hacer   y gracias a una máquina CNC, que no solo  sirve para  crear piezas de todo tipo, sino que también puede servir para hacer placas PCB caseras en muy poco tiempo (por ejemplo diseñadas com EAGLE y  PCB-gcode)

Un programa  muy famoso es bCNC que nos permite controlar un  CNC que funcione a través de arduino y que usen el firmware grbl.  Este programa es el mas completo en cuanto a funciones,  pero quizás  tenga demasiadas opciones que dificultan  que nos centremos en el proceso que vamos buscando , que es el de creación de pcb mediante el pulido de las zonas que no deben conducir con una herramienta  controlada por control numérico

Precisamente  para superar las dificultades  de  bcnc  surge OpenCNCPilot , que es un sencillo programa creado específicamente para crear placas PCB con una maquina  CNC  .

Este programa es gratuito y esta disponible únicamente para windows desde la pagina de github en https://github.com/martin2250/OpenCNCPilot

Podemos ver una descripción general rápida en YouTube:

 

OpenCNCPilot es un emisor de código G compatible con GRBL.

Su característica principal es su capacidad de explorar áreas definidas por el usuario para alabeo y envolver la trayectoria alrededor de la superficie curva . Esto es especialmente útil para grabar superficies metálicas con cortadores en forma de V donde cualquier desviación en la dirección Z resultará en trazas más anchas o más angostas, por ejemplo, para el aislamiento de PCBs donde el alabeo daría lugar a rastros rotos o en corto.

Está escrito en C # y usa WPF para su interfaz de usuario. Lamentablemente, esto significa que no se ejecutará en Linux, ya que Mono no es compatible con WPF. La ventana gráfica 3D se gestiona con HelixToolkit.

 

Instalación y primeros pasos

Para instalar este programa se requiere   .NET 4.6 ,Vaya a la sección de Versiones y descargue los últimos binarios (o compílelo desde la fuente). Descomprima todos los archivos en su disco duro y ejecute “OpenCNCPilot.exe

Asegúrese de utilizar la versión 1.1f de GRBL (las versiones posteriores pueden funcionar pero aún no han sido probadas)

Antes de la primera ejecución, debe seleccionar un puerto serie, el selector está oculto en el menú de configuración al que puede acceder en la pestaña “Máquina”. Aparte de eso, no es necesario modificar ninguna configuración de modo que seleccionado  podra  conectarte a su máquina.

Abra archivos gcode o height map arrastrándolos a la ventana, o usando los botones correspondientes.

Para crear un nuevo mapa de altura, abra la pestaña “Sonda” y haga clic en “Crear nuevo”. Se le pedirá que ingrese las dimensiones.
Asegúrese de ingresar las coordenadas reales, por ejemplo, cuando su trayectoria esté en la dirección X negativa, ingrese “-50” a “0” en lugar de “0” a “50”. Verá una vista previa del área y los puntos individuales en la ventana principal

Para explorar el área, configure su sistema de coordenadas de trabajo ingresando “G92 X0 Y0 Z0” en su origen seleccionado, asegúrese de conectar el A5 de su Arduino a la herramienta y GND a su superficie , y presione “Ejecutar”.

Una vez que haya terminado de explorar la superficie, cargue el archivo gcode que desea ejecutar y presione el botón “Aplicar mapa de altura” en la pestaña “Editar”. Ahora puede ejecutar el código con el botón “Inicio” en la pestaña “Archivo”.

En la ultima version   hay  una opción muy interesante, casi diría que imprescindible, como el autonivelado por malla. Eso permite que la profundidad de corte siempre sea la misma y el resultado quede perfecto.

 

 

 

 

 

 

 

Programar Arduino con Eclipse


Arduino es una plataforma de prototipado electrónica de código abierto basada en software y hardware flexible y fáciles de usar. Está destinado a artistas, diseñadores, aficionados y cualquiera interesado en la creación de objetos interactivos o entornos.
En realidad el Arduino es un montón de cosas. Dado un determinado contexto, puede significar cualquiera de las siguientes…

  • Arduino , la plataforma de hardware (el «Consejo»)
  • Arduino – la biblioteca de abstracción sobre el WinAVR. WinAVR es la cadena de herramientas GNU (compilador + C Runtime library etc.) para el Microcontrolador AVR utilizado en las placas de Arduino (el “software”)
  • Arduino – “El IDE” (estamos utilizando Arduino 19)

Para empezar con Arduino antes de nada se  necesita familiarizarse con la plataforma Arduino y jugar con el IDE de Arduino que es libremente descargable desde la Web de Arduino.

Si es un  programador experto , pronto se dará cuenta   que necesita  un más potente conjunto de herramientas como puede ser  la combinación de WinAVR , biblioteca Arduino + Eclipse y esto es lo que vamos a ver en este post.

 

leds arduino

Instalación  IDE

Sucintamente  los pasos para  programar Arduino con el Eclipse son los siguientes:.

  1. Descargar Eclipse (sobre 90 MBs). Descomprimir en C:\Misc\Eclipse
  2. Descargar el IDE de Arduino. Descomprimir en C:\Misc\arduino-0019
  3. Descargar la última versión de WinAVR. Descomprimir en C:\Misc\WinAVR
  4. Descargar el Plug-in de Eclipse de AVR e instalarlo (siga las instrucciones en su página web)

Primeros pasos con Eclipse

  1. Iniciar Eclipse
  2. Cerrar la página de bienvenida haga clic en la Cruz en la ficha para revelar el ambiente de trabajo real…
  3. Comenzar un nuevo proyecto haciendo clic en “archivo -> Nuevo -> proyecto de C++“. Elegir el tipo de proyecto “AVR Cross Target biblioteca estática” y establezca el nombre del proyecto Arduino. Ahora vamos a compilar los archivos fuente de Arduino en una biblioteca estática para su uso posterior. Finalmente haga clic en finalizar.
  4. Utilice el explorador de Windows para ir a C:\Misc\arduino-0019\hardware\arduino\cores\arduino, seleccionar todos los archivos de código y arrastrar sobre el proyecto de Arduino ya abierto en Eclipse( Nota :sólo incluyen archivos con extensiones .c, .cpp y .h …)
  5. A continuación, haga clic en aceptar en el siguiente cuadro de diálogo (aceptar la opción de copia por defecto)…
  6. Ahora construya el proyecto haciendo clic derecho sobre él y eligiendo “Crear” en el menú contextual. !puede  que tengamos mas de 10 errores! Pero no se preocupe, a arreglarlos en el momento. Haga clic derecho sobre el proyecto y elija “Propiedades” e ir a la opcion “c/c ++ Build -> Configuración -> AVR compilador” . Haga clic en el icono “+” (después de seleccionar la opción “Directorios”).
  7. Haga clic en el botón “Área de trabajo...” y añadir el directorio del proyecto ${workspace_loc :/ ${Nombre_proyecto}} como un directorio de inclusión una vez para el “compilador AVR” y el “AVR C++ Compiler”
  8. Haga clic derecho sobre el proyecto y elija “Propiedades“, luego ir a “AVR -> Target Hardware” y luego establecer la opción de tipo de MCU en el microprocesador en la placa Arduino junto con la frecuencia del cristal suministrado con él. Por  ejemplo para un arduino antiguo  que lleve el ATmega328P  el valor es de  16000000 respectivamente. A continuación, haga clic en ok.
  9. Ahora construya su proyecto de nuevo  de modo qeu  la construcción debería tener éxito esta vez.(Aunque es posible que vea un montón de advertencias que, simplemente puede ignorarlos por ahora).

Ejemplo

  1. Es hora de que el equivalente a “Hola mundo” el mundo de sistemas embebidos. Ir a “archivo -> Nuevo -> proyecto de C++” como antes pero ahora seleccione “AVR Cross Target solicitud” como el tipo de proyecto y establezca el nombre del proyecto a “social
  2. Haga clic derecho sobre el proyecto social y elegir “New -> File”, el nombre del archivo a Main.cpp y haga clic en finalizar.
  3. Ahora, agregue el código siguiente de C++ a Main.cpp:
    #include "WProgram.h" //Include arduino headers
    
    ///CONSTANTS///
    //The onboard test LED is connected to pin number 13
    const int ledPin = 13;
    const int interval = 1000; //Milliseconds
    
    ///MAIN///
    int main()
    {
        //Initialize the Arduino library.
        //Not doing so will prevent the delay function
        //from working. Calling this functions is a must
        //for all arduino projects.
        init();
    
        //Initialize the serial port. This will be used
        //to send diagnostic information in this project.
        Serial.begin(9600);
    
        //Configure ledPin as an output
        pinMode(ledPin, OUTPUT);
    
        //Announce the start of program. Usually a
        //hyper-terminal is connected to the serial
        //port on the PC so this message can be seen
        //there
        Serial.println("Ready.");
    
        //Enter the infinite loop responsible for making
        //the microcontroller do the same thing over and
        //over again. (Almost every microcontroller has
        //such a loop)
        while(true)
        {
            //Turn on the LED
            digitalWrite(ledPin, HIGH);
            //Wait for half of "interval".
            //The LED remains ON during this time.
            delay(interval/2);
            //Turn off the LED
            digitalWrite(ledPin, LOW);
            //Wait for half of "interval".
            //The LED remains OFF during this time.
            delay(interval/2);
        }
    
        //Unreachable code but it's required by
        //the compiler
        return 0;
    }
  4. Ahora compile el proyecto. !es posible que tenga  un montón  de errores!
  5. OK vamos a arreglarlos. Haga clic derecho sobre el proyecto de “Social” y elija “Propiedades” e ir a la “construcción de C/C++-> Configuración -> Avr Compiler -> directorios” opción y haga clic en el icono “+”.
  6. Haga clic en el botón “área de trabajo…” en el cuadro de diálogo subsecuente y elija Arduino -> Debug en el cuadro de diálogo el posterior.
  7. Finalmente se debe ver la siguiente. Haga clic en Aceptar después de haber verificado la ruta.
  8. Hacer lo mismo para la “construcción de C/C++-> Configuración -> Avr C++ Compiler -> directorios”
  9. Ir a “construir de C/C++-> Configuración -> Avr C++ linker -> bibliotecas” y defina las siguientes opciones.
  10. Ahora compilar el proyecto social otra vez. Compruebe que es mucho mejor ahora, pero todavía tenemos un error . Esto es un error de vinculador. El vinculador se queja aquí que no podría encontrar una aplicación para la función de llamada en cualquier lugar aunque se refiere a / usado en otras partes del código. Baste decir la función es necesaria por el runtime de C++ para decidir lo que hay que hacer cuando alguien llama a una función virtual pura directamente. Como recordará de sus tratos con C++, una función virtual pura no se puede llamar directamente sin proporcionar una implementación en alguna clase derivada. Para ello, una clase con una función virtual pura no puede ser instanciada en todos pero el runtime de C++ le gusta estar preparado para cualquier eventualidad.Compiladores avanzados habrían lanzado una excepción de esta función para indicar una operación ilegal, pero como no tenemos los de la plataforma de WinAVR, todo lo que podemos hacer es evitar  más daño que está haciendo entrar en un bucle sin fin (suponiendo que el programa es corriendo frenéticamente en primer lugar ya que ha hecho lo imposible por llamar a una función virtual pura directamente!)
    Nota: esto debe hacerse sólo para la versión de depuración. Al parecer esta función no se utiliza en la versión de lanzamiento de Arduino. Las compilaciones de depuración están amañadas para fallar rápidamente para que el punto de falla es lo más cercano posible al lugar donde está el verdadero problema.
  11. Agregar un nuevo archivo .c al proyecto Arduino (Nota debería ser .c y no CPP). Llame al missing.c y pegue el código siguiente en él y construir de nuevo ambos proyectos. El error debería desaparecer. Tenga en cuenta que lo necesario para construir Arduino antes de poder construir social.
    void __cxa_pure_virtual()
    {
        while(1);
    }
  12. Conmutando el panel de “Consola”, puede ver el resultado de ejecutar el comando tamaño de avr en el archivo .elf de generado…Pero no es un bonito espectáculo para la vista. Un pobre programa intermitente led ocupa aproximadamente 62% del total de memoria de programa disponible. Pero no se asuste, estamos en la versión de depuración  de modo que obtendrá mejores resultados al cambiar a liberar estructuras.

Cambiar a la versión de lanzamiento

  1. Haga clic derecho en un proyecto y seleccione “configuraciones de generación -> Set activo -> Release 2”. Hacer esto para todos los proyectos.
    Nota: usted necesita volver a especificar todos los ajustes para la versión de lanzamiento como hiciste para hacerlo compilar la versión de depuración.

Optimización prematura

  1. Aquí es cómo vamos de mejor a impresionantes. A continuación se asegurará de que usted sólo paga por las funciones y secciones de datos que realmente se utilizan en el programa. Agregue los siguientes indicadores adicionales para el C y C++ compiladores en todos los proyectos
    -ffunction-sections -fdata-sections

    Añadir la siguiente bandera a las opciones del vinculador en todos los proyectos.

    -Wl,-gc-sections

     

  2. Reconstruir (en el correcto orden Arduino en primer lugar, social segundo.)

Cargar el programa en el Arduino

Ahora ha llegado el momento cuando usted puede cargar su primer programa de Arduino construido dentro de los confines cómodos de Eclipse.

  1. Haga clic derecho sobre el proyecto social y selecciona “Propiedades“. Ir a la página de AVRDude y haga clic en nuevo.
  2. Rellene el formulario siguiente:
    • Nombre de configuración: Arduino
    • Hardware del programador: Arduino
    • Reemplazar el puerto por defecto: \\.\COM3. Reemplazar el COM3 a cualquier puerto del hardware de Arduino está conectado a.
    • Override en baudios por defecto: 19200. Reemplazar 19200 a cualquier velocidad en baudios fue especificado por el fabricante del tablero / la persona que subido el Arduino boot loader en tu tarjeta.

     

  3. Seleccionar Arduino como programador en AVRDude configuración y haga clic en Aceptar.
  4. Haga clic en el botón de la barra de herramientas AVR para subir su programa a la placa.

    Debería ver algo como lo siguiente en la ventana de la consola…

    Launching C:\misc\WinAVR\bin\avrdude -pm328p 
        carduino "-P\\.\COM3" -b19200 -Uflash:w:BlinkenLights.hex:a 
    Output:
    
    avrdude: AVR device initialized and ready to accept instructions
    
    Reading | ################################################## | 100% 0.02s
    
    avrdude: Device signature = 0x1e950f
    avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
             To disable this feature, specify the -D option.
    avrdude: erasing chip
    avrdude: reading input file "BlinkenLights.hex"
    avrdude: input file BlinkenLights.hex auto detected as Intel Hex
    avrdude: writing flash (2828 bytes):
    
    Writing | ################################################## | 100% 2.16s
    
    avrdude: 2828 bytes of flash written
    avrdude: verifying flash memory against BlinkenLights.hex:
    avrdude: load data flash data from input file BlinkenLights.hex:
    avrdude: input file BlinkenLights.hex auto detected as Intel Hex
    avrdude: input file BlinkenLights.hex contains 2828 bytes
    avrdude: reading on-chip flash data:
    
    Reading | ################################################## | 100% 2.14s
    
    avrdude: verifying ...
    avrdude: 2828 bytes of flash verified
    
    avrdude done.  Thank you.
  5. Si todo salió bien, la prueba a bordo del LED (generalmente color rojo) ahora si empieza a parpadear en cerca de 1 parpadeo/seg Felicitaciones!

Finalmente hemos visto cómo utilizar Eclipse para el desarrollo de AVR. Pero esto es sólo el principio pues hay mucho explorar pero hemos visto  los fundamentos y ahora debería ser fina por su cuenta. Los ejemplos y bibliotecas suministradas con Arduino deben ser un buen punto de partida para la exploración de más.

 

 

Fuente https://www.codeproject.com/Articles/110859/Arduino-Unleashed