Archivo de categoría Posts

León Ramos PorLeón Ramos

Ajustar el peso de la aguja de un tocadiscos o tornamesa

Hola creadores:

Para los adictos a los viniles hay ciertos momentos de enojo que regresan una y otra vez. Uno de ellos es: haber encontrado una pieza única en una tienda de viniles y, aunque en el tocadiscos del vendedor se escucha bien, en tu tornamesa el disco hace saltar la aguja y no se escucha nada.

Cuando regresas con el vendedor, el te dice sabiamente -No hay problema, sólo auméntale el peso a tu aguja.

¿Qué pasa si no tienes el peso suficiente?

La aguja puede saltar y ser inestable, no lograrás escuchar los discos que están ligeramente ondulados.

¿Qué pasa si tiene un peso mayor?

Si es más pesada de lo que debiera, puedes dañar el vinil que escuchas o, si no regresas al peso anterior, también puedes dañar otros discos.

¿Cuál es el peso ideal?

Es buena pregunta, el peso ideal está dictado por el fabricante de la aguja. Busca en Internet la tabla de valores compatibles con tu aguja. Normalmente oscilan entre 2 y 3g de peso.

¿Cómo lo ajusto?

Lo puedes ajustar usando las perillas de tu tocadiscos, si tu tocadiscos no los tiene, te sugiero que pienses seriamente en adquirir uno con más opciones. Sin embargo, como lo pueden ver en el video, los tocadiscos pueden mentir, por lo que sugiero que se use una pesa o balanza para tocadiscos o tornamesa. Su uso es muy sencillo y te da mucha paz mental.

Espero que el video que anexo les sea de mucha utilidad y que puedan escuchar sus viniles como es debido.

¡Hasta la próxima creadores!

Rafael Sobrevilla PorRafael Sobrevilla

Sistemas Operativo en Tiempo Real, para un Sistema Embebido (ARDUINO)

Introducción

Tradicionalmente los microcontroladores, se programan usando un algoritmo secuencial, en la cual los recursos de hardware, no se comparten entre funciones, es decir el uso de un periférico, como son: la Unidad Aritmetica Lógica, contadores, Convertidores Analogico Digital, etc; no son liberados hasta que termina la función actual de ejecutarse. Esto implica tener varias funciones anidadas, que esperan a que la función en ejecución termina de usar los recursos del microcontrolador.

El nivel de integración actual, ha permitido que los microcontroladores posean, mayor capacidad de memoria, mayor velocidad de transferencia de datos para su procesamiento y un acceso mas rápido a la lectura y escritura de memoria.

Todas las características anteriormente citadas, permiten el poder implementar un RTOS (Sistema Operativo en Tiempo Real) en un microcontrolador de 8 bits. Un RTOS, es un gestor de tiempo de ejecución, que administra diferentes tareas que son parecidas a una función secuencial, pero permiten ser, puestas en espera, imitarles el acceso a la memoria y/o al hardware, guardar el entorno actual de contadores, periféricos, contador del programa, etc. Saltar a otra tarea, compartir los recursos y regresar a la tarea que se quedo en espera. Todo esto gracias a la creación de varios Stacks (pilas de registros guardados) en este caso generalmente en memoría RAM. Finalmente la tarea que estaba esperando o que se quedo a mitad de ejecución, puede continuar su ejecución justo en el punto donde fue interrumpida.

Después de comprender este sencillo ejemplo, imaginémonos que esta “puesta en espera” se realiza con diferentes tareas, compartiendo recursos y saltando simultáneamente entre ellas. La combinación de un gestor de tiempos entre tareas secuenciales que comparten recursos, es el objetivo de los RTOS.

Arduino UNO con un RTOS

Una arquitectura Arduino UNO (Atmega328, 8 Bits uC a 16 mega hertz) gracias a freeRTOS, nos permite implementar un pequeño Sistema en Tiempo Real.

Quiero compartirles, este código que utiliza un RTOS en un arduino UNO, es para un cubo de leds de 3×3. En futuras aportaciones explicare a detalle como funciona este RTOS y como configurar las diferentes tareas creadas. Por el momento a grandes razgos:

  • Una tarea ejecuta las secuencias de patrones de encendido de los leds

  • Una tarea revisa el potenciómetro (genera un voltaje variable) que aumenta la velocidad de las secuencias

  • Una tarea revisa el estado de un botón que cambia la secuencia de encendido de los leds, por si ya te aburriste y quieres que los leds prendan con un patrón diferente.

Este programa también se puede escribir de manera tradicional, con lógica secuencial, pero al usar un RTOS, para actualizar las variables globales, que controlan el sentido y velocidad de los patrones de encendido de los leds, se hace evidente, que al usar un RTOS, el programa final es más sencillo y utiliza más eficientemente los recursos del microcontrolador.

Adjunto también, un enlace a un video, para que vean el funcionamiento de este cubito de 3×3.

Rafael Sobrevilla

Referencias

Programación de Sistemas Embebidos en C, Gustavo Galeano, Primera Edición, 2009, Alfaomega

https://aprendiendoarduino.wordpress.com/tag/rtos/

 

Video

Código

/**************************************************************************************************
* File name: cube3x3.ino
* Date Start: 17-may-17
* Author: Rafael Sobrevilla
* email: rasobrevilla@yahoo.com
* Descrip:
* – Control a 27 leds cube
* – Use digital outputs of arduino UNO
* + D2 – D10 Control of base leds
* + D11 – D13 The three floors
* + A0 – A1 Two Buttons
* + D0 and D1 To keep the serial port available
*
* led1 led2 led3
*
* led4 led5 led6
*
* led7 led8 led9
*
* floor0
* floor1
* floor2
*
**************************************************************************************************/

/**************************************************************************/
/* Include headers */
/**************************************************************************/
#include <Arduino_FreeRTOS.h>

/*************************************************************************/
/* Define two task for Sensors and Clock */
/*************************************************************************/
void TaskPatron( void *pvParameters );
//void TaskPotenciometer ( void *pvParameter );
void TaskButton ( void *pvParameter );

/********************************************************************/
/* Global variables */
/********************************************************************/
int led1 = 2;
int led2 = 3;
int led3 = 4;
int led4 = 5;
int led5 = 6;
int led6 = 7;
int led7 = 8;
int led8 = 9;
int led9 = 10;
int floor0 = 11;
int floor1 = 12;
int floor2 = 13;

int sen_pin0 = A0;
int sen_pin1 = A2;
const int ON = 1;
const int OFF = 0;
int delay_ms_value_1 = 250;
int delay_ms_value_2 = 500;
int button_status = 0;
int potenciometer_status = 0;

/***************************************************************************/
/* Setup function is executed when you press reset or power the board */
/***************************************************************************/
void setup() {

Serial.begin(9600);

while (!Serial) {
; // wait for serial port to connect. Needed for native USB, on LEONARDO, MICRO, YUN, and other 32u4 based boards.
}

pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
pinMode(led6, OUTPUT);
pinMode(led7, OUTPUT);
pinMode(led8, OUTPUT);
pinMode(led9, OUTPUT);
pinMode(floor0, OUTPUT);
pinMode(floor1, OUTPUT);
pinMode(floor2, OUTPUT);

// Now set up two tasks to run independently.
xTaskCreate (
TaskPatron
, (const portCHAR *) «Sensor»
, 128 // Stack size
, NULL
, 3 // Priority
, NULL );

xTaskCreate (
TaskButton
, (const portCHAR *)»Motors» // A name just for humans
, 128 // This stack size can be checked & adjusted by reading the Stack Highwater
, NULL
, 3 // Priority, with 3 (configMAX_PRIORITIES – 1) being the highest, and 0 being the lowest.
, NULL );

xTaskCreate (
TaskPotenciometer
, (const portCHAR *) «Sensor»
, 128 // Stack size
, NULL
, 3 // Priority
, NULL );

// Now the task scheduler, which takes over control of scheduling individual tasks, is automatically started.
}

/***********************************************************************/
/* Function for turn on a Position led */
/***********************************************************************/
int enable(int position_led, int floor_on)
{
digitalWrite(position_led, ON);
digitalWrite(floor_on, ON );

}

/***********************************************************************/
/* Fnction for turn off a Position Led */
/***********************************************************************/
int disable(int position_led, int floor_on)
{
digitalWrite(position_led, OFF);
digitalWrite(floor_on, OFF );
}

/*****************************************************************************/
/* LOOP FUNCTION */
/*****************************************************************************/
void loop()
{
// Empty. Things are done in Tasks.
}

/******************************************************************************/
/* Tasks */
/******************************************************************************/

void TaskPatron(void *pvParameters) // This is a task.
{
(void) pvParameters;
for (;;)
{
Serial.println(«PATRONES»);
do{
patron1();
}while(button_status > 200);

do{
patron2();
}while(button_status > 200);

do{
patron3();
}while(button_status > 200);

do{
patron4();
}while(button_status > 200);
}
}

void TaskPotenciometer (void *pvParameters) // This is a task.
{
(void) pvParameters;
for(;;)
{
potenciometer_status = analogRead (sen_pin0);
Serial.println(potenciometer_status);
//delay(delay_ms_value_2);
}
}

void TaskButton (void *pvParameters) // This is a task.
{
(void) pvParameters;
for(;;)
{
button_status = analogRead (sen_pin1);
Serial.println(button_status);
//delay(delay_ms_value_2);
}
}

/************************************************************************/
/* Patron 1 */
/************************************************************************/
void patron1 (void)
{
//floor 2
enable(led1, floor2);
enable(led2, floor2);
enable(led3, floor2);
enable(led4, floor2);
enable(led5, floor2);
enable(led6, floor2);
enable(led7, floor2);
enable(led8, floor2);
enable(led9, floor2);
delay(potenciometer_status );

disable(led1, floor2);
disable(led2, floor2);
disable(led3, floor2);
disable(led4, floor2);
disable(led5, floor2);
disable(led6, floor2);
disable(led7, floor2);
disable(led8, floor2);
disable(led9, floor2);

//floor 1
enable(led1, floor1);
enable(led2, floor1);
enable(led3, floor1);
enable(led4, floor1);
enable(led5, floor1);
enable(led6, floor1);
enable(led7, floor1);
enable(led8, floor1);
enable(led9, floor1);
delay(potenciometer_status );

disable(led1, floor1);
disable(led2, floor1);
disable(led3, floor1);
disable(led4, floor1);
disable(led5, floor1);
disable(led6, floor1);
disable(led7, floor1);
disable(led8, floor1);
disable(led9, floor1);

//floor 0
enable(led1, floor0);
enable(led2, floor0);
enable(led3, floor0);
enable(led4, floor0);
enable(led5, floor0);
enable(led6, floor0);
enable(led7, floor0);
enable(led8, floor0);
enable(led9, floor0);
delay(potenciometer_status );

disable(led1, floor0);
disable(led2, floor0);
disable(led3, floor0);
disable(led4, floor0);
disable(led5, floor0);
disable(led6, floor0);
disable(led7, floor0);
disable(led8, floor0);
disable(led9, floor0);

//floor 1
enable(led1, floor1);
enable(led2, floor1);
enable(led3, floor1);
enable(led4, floor1);
enable(led5, floor1);
enable(led6, floor1);
enable(led7, floor1);
enable(led8, floor1);
enable(led9, floor1);
delay(potenciometer_status );

disable(led1, floor1);
disable(led2, floor1);
disable(led3, floor1);
disable(led4, floor1);
disable(led5, floor1);
disable(led6, floor1);
disable(led7, floor1);
disable(led8, floor1);
disable(led9, floor1);
}

/*********************************************************************************/
/* Patron 2 */
/*********************************************************************************/
void patron2(void)
{
//wall 2
enable(led1, floor2);
enable(led2, floor2);
enable(led3, floor2);
enable(led1, floor1);
enable(led2, floor1);
enable(led3, floor1);
enable(led1, floor0);
enable(led2, floor0);
enable(led3, floor0);
delay(potenciometer_status );

disable(led1, floor2);
disable(led2, floor2);
disable(led3, floor2);
disable(led1, floor1);
disable(led2, floor1);
disable(led3, floor1);
disable(led1, floor0);
disable(led2, floor0);
disable(led3, floor0);

//floor 1
enable(led4, floor2);
enable(led5, floor2);
enable(led6, floor2);
enable(led4, floor1);
enable(led5, floor1);
enable(led6, floor1);
enable(led4, floor0);
enable(led5, floor0);
enable(led6, floor0);
delay(potenciometer_status );

disable(led4, floor2);
disable(led5, floor2);
disable(led6, floor2);
disable(led4, floor1);
disable(led5, floor1);
disable(led6, floor1);
disable(led4, floor0);
disable(led5, floor0);
disable(led6, floor0);

//floor 0
enable(led7, floor2);
enable(led8, floor2);
enable(led9, floor2);
enable(led7, floor1);
enable(led8, floor1);
enable(led9, floor1);
enable(led7, floor0);
enable(led8, floor0);
enable(led9, floor0);
delay(potenciometer_status );

disable(led7, floor2);
disable(led8, floor2);
disable(led9, floor2);
disable(led7, floor1);
disable(led8, floor1);
disable(led9, floor1);
disable(led7, floor0);
disable(led8, floor0);
disable(led9, floor0);

//floor 1
enable(led4, floor2);
enable(led5, floor2);
enable(led6, floor2);
enable(led4, floor1);
enable(led5, floor1);
enable(led6, floor1);
enable(led4, floor0);
enable(led5, floor0);
enable(led6, floor0);
delay(potenciometer_status );

disable(led4, floor2);
disable(led5, floor2);
disable(led6, floor2);
disable(led4, floor1);
disable(led5, floor1);
disable(led6, floor1);
disable(led4, floor0);
disable(led5, floor0);
disable(led6, floor0);
}

/*********************************************************************************/
/* Patron 3 */
/*********************************************************************************/
void patron3 (void)
{
//wall 2
enable(led1, floor2);
enable(led4, floor2);
enable(led7, floor2);
enable(led1, floor1);
enable(led4, floor1);
enable(led7, floor1);
enable(led1, floor0);
enable(led4, floor0);
enable(led7, floor0);
delay(potenciometer_status );

disable(led1, floor2);
disable(led4, floor2);
disable(led7, floor2);
disable(led1, floor1);
disable(led4, floor1);
disable(led7, floor1);
disable(led1, floor0);
disable(led4, floor0);
disable(led7, floor0);

//wall 1
enable(led2, floor2);
enable(led5, floor2);
enable(led8, floor2);
enable(led2, floor1);
enable(led5, floor1);
enable(led8, floor1);
enable(led2, floor0);
enable(led5, floor0);
enable(led8, floor0);
delay(potenciometer_status );

disable(led2, floor2);
disable(led5, floor2);
disable(led8, floor2);
disable(led2, floor1);
disable(led5, floor1);
disable(led8, floor1);
disable(led2, floor0);
disable(led5, floor0);
disable(led8, floor0);

//wall 0
enable(led3, floor2);
enable(led6, floor2);
enable(led9, floor2);
enable(led3, floor1);
enable(led6, floor1);
enable(led9, floor1);
enable(led3, floor0);
enable(led6, floor0);
enable(led9, floor0);
delay(potenciometer_status );

disable(led3, floor2);
disable(led6, floor2);
disable(led9, floor2);
disable(led3, floor1);
disable(led6, floor1);
disable(led9, floor1);
disable(led3, floor0);
disable(led6, floor0);
disable(led9, floor0);

//floor 1
enable(led2, floor2);
enable(led5, floor2);
enable(led8, floor2);
enable(led2, floor1);
enable(led5, floor1);
enable(led8, floor1);
enable(led2, floor0);
enable(led5, floor0);
enable(led8, floor0);
delay(potenciometer_status );

disable(led2, floor2);
disable(led5, floor2);
disable(led8, floor2);
disable(led2, floor1);
disable(led5, floor1);
disable(led8, floor1);
disable(led2, floor0);
disable(led5, floor0);
disable(led8, floor0);
}

/*********************************************************************************/
/* Patron 4 */
/*********************************************************************************/
void patron4 (void)
{
//wall 2
enable(led1, floor2);
enable(led5, floor1);
enable(led9, floor0);
delay(potenciometer_status );

disable(led1, floor2);
disable(led5, floor1);
disable(led9, floor0);

//wall 1
enable(led2, floor2);
enable(led5, floor1);
enable(led8, floor0);
delay(potenciometer_status );

disable(led2, floor2);
disable(led5, floor1);
disable(led8, floor0);

//wall 0
enable(led3, floor2);
enable(led5, floor1);
enable(led7, floor0);
delay(potenciometer_status );

disable(led3, floor2);
disable(led5, floor1);
disable(led7, floor0);

//floor 1
enable(led4, floor2);
enable(led5, floor1);
enable(led6, floor0);
delay(potenciometer_status );

disable(led4, floor2);
disable(led5, floor1);
disable(led6, floor0);
}

 

León Ramos PorLeón Ramos

Hacer un tapete o slipmat de corcho para tu tocadiscos

Hola Creadores:

En esta ocasión hablaremos de cómo hacer un tapete de corcho para tu tornamesa o tocadiscos. Esta inquietud me surgió porque lograba escuchar cierto ruido inducido por el giro mecánico de mi tornamesa. En mi caso tengo una tornamesa reconstruída de los años ochenta y eso me hace poner más atención a la parte mecánica del equipo. Noté que escuchaba ciertos ruiditos que no venían del disco, dichos ruidos son más perceptibles cuando escuchas música suave o clásica.

Noté que el tapete de fábrica de mi tornamesa estaba fabricado en hule y, por el paso del tiempo, se volvió en una pieza menos elástica. Todavía no llega al punto del desquebrajamiento, sin embargo, quise probar con otras opciones.

Una de las que encontré fue sustituirla por un tapete de corcho, entre otras razones, porque no daña la superficie de los discos de vinil y, al mismo tiempo, absorbe vibraciones. Así que me dí a la tarea de buscar uno para mi equipo.

Lamentablemente los que encontré disponibles estaban en el extranjero y tardarían mucho tiempo en llegar. Así que busqué herramientas para realizar mi tapete yo mismo. En el siguiente video, comparto lo que aprendimos al momento de realizar los cortes apropiados, así como su puesta en funcionamiento.

Materiales necesarios:

  • Tapete de corte o una mesa de trabajo
  • Regla o cinta métrica
  • Herramienta de corte circular con filo grueso para profundidades mayores a 4mm
  • Hoja de corcho de 4mm de espesor
  • Broca para madera del grosor para el corte interior
  • Taladro de banco o manual

León Ramos PorLeón Ramos

¿Cómo cambiar un texto en varios archivos en Linux?

Mini tutorial: ¿Como cambiar texto o cadena en varios archivos en Linux?

¡Hola Creadores!

En éste mini tutorial vamos a ver cómo cambiar un texto o una cadena en varios archivos en un sistema Linux.

En la primera parte nos concentramos en encontrar los archivos que tienen la cadena de texto con la herramienta egrep.

$ egrep 'texto' * -ri

Luego vemos cómo contar los archivos encontrados utilizando la herramienta wc.

$ egrep 'cadena' -ri | wc -l

Finalmente nos concentramos en realizar el cambio que queremos

$ egrep 'cadena' -ril | xargs sed -i 's/cadena/nueva/g'

Espero que les sirva!

León Ramos PorLeón Ramos

¿Cómo puedo salir de vi?

Mini tutoriales: ¿Cómo salir de vi?

Hola creadores:

Si, seguramente les ha pasado, no son muy diestros en vi/vim y ya entraron a cambiar un archivo, pero ¿cómo salimos?

Bueno en este mini tutorial les explicamos cómo salir:

  1. Salir sin guardar
  2. :q

  3. Salir sin guardar forzando
  4. :q!

  5. Guardar el contenido del archivo
  6. :w

  7. Guardar y salir
  8. :wq

  9. Guardar y salir abreviado
  10. :x

  11. Guardar y salir más abreviado
  12. SHIFT+z+z

León Ramos PorLeón Ramos

Mini tutorial de comandos Linux: SSH

Mini Tutoriales: SSH

¡Hola Creadores!

Con este post comenzamos la sección de minitutoriales de comandos GNU/Linux. El objetivo de dicha sección es tener un compendio de videos en español que expliquen tips y trucos que frecuentemente se necesitan al operar éstos sistemas.

Se cubren los siguientes puntos de forma breve:

  1. Formas de usar el comando
  2. Switches simples
  3. Usar otro puerto para SSH
  4. Formas de salir de una conexión SSH
  5. SSH sin password
  6. Crear un proxy SOCKS para navegar
  7. Reenviar un puerto remoto a la máquina local (ideal para realizar comunicaciones encriptadas rápidas)

Si tienes dudas, no vaciles en escribirnos, o bien, sugiere qué otros comandos quieres que expliquemos.

¡Hasta luego Creadores!

León Ramos PorLeón Ramos

Espionaje mexicano con spyware pegasus

Entrevista con dos expertos en seguridad:

Ing. Hiram Camarillo y el Ing. Alberto Rivera

Hablamos de cómo funciona el espionaje que supuestamente realizó el gobierno mexicano sobre comunicadores y personajes de la vida civil nacional.

¿Cómo funciona? ¿Qué hace? y ¿Cómo podemos evitarlo? son algunas de las preguntas que intentaremos responder.

Algunos consejos útiles para los usuarios

Herramientas para proteger tu navegación

VPN sin costo
Protonmail

10 Consejos para navegar seguro por Internet

Control Parental

Kaspersky SafeKids – Kids mode
Norton Family parental control

León Ramos PorLeón Ramos

Script para hacer respaldos automáticos de mongodb

A principios de este año 2017 se presentó un tipo de «Ransomeware» que atacaba bases de datos no relaciones MongoDB, <<Ransomeware es un tipo de software malicioso que codifica tu información sensible y cobra un rescate para devolverte el acceso a la misma, proviene del inglés «Ransome» que significa secuestro y «Software»>>  y digo un tipo de Ransomeware porque en realidad no codificaba tu información, simplemente ejecutaba una sentencia de borrado y aún así te pedía rescate. Para los que alguna vez jugamos con bases de datos relacionales, su equivalente sería un «delete database» ejecutado de forma remota sobre servidores mal asegurados.

Dicho lo anterior, ese hecho dejó bien claro que era momento de tener respaldos frecuentes y bien almacenados. Si, como yo, tienes una aproximación muy práctica a las cosas, aquí te dejo un script que puede ayudarte con ese cometido.

Realizar un respaldo de bases de datos mongodb programado y, después borrar los respaldos mayores a un número de días para evitar saturación de disco duro.

No está demás mencionar que el script puede modificarse para respaldar casi cualquier cosa y, como lo estoy liberando bajo la licencia GPLv3, te invito a que lo modifiques a tu antojo. Sólo recuerda compartirlo una vez que lo cambies. Puedes realizar una derivación de mi repositorio.

El archivo readme.md tiene las instrucciones básicas de su uso, pero si tienes alguna duda posterior, no vaciles en contactarme.

Aquí la liga de acceso al repositorio: https://goo.gl/wKfiVK

¡Que la paz mental te acompañe con respaldos completos!

Hasta la próxima,

Rafael Sobrevilla PorRafael Sobrevilla

Robot, Actualmente, ¿Qué es un Robot y qué no es?

Robot es un término que apareció por primera vez en la novela R.U.R. (Robots Universales Rossum) del dramaturgo checo Karel Čapek, que se estrenó en 1920.1 La palabra se escribía como «robotnik»[1].

 

La palabra Robot, hace referencia a sirviente o trabajador. La autoría del término Robótica, fue desarrollado en varias novelas de Isaac Asimov donde se plantea el estudio, el diseño y la generación de inteligencia artificial, necesarios para estos tipos de dispositivos y el problema de su interacción con los seres humanos.

Este término ha tenido una evolución, en los años 60’s en la industria, se planteó a las universidades el desarrollo de manipuladores que permitieran realizar tareas complicadas y/o peligrosas para los seres humanos. Por lo que la creación de manipuladores  caracterizó a la década de los sesentas. Utilizando principios de mecánica, permitían levantar cargas más pesadas, mantenerse a una distancia segura en caso de manipulación de químicos u objetos calientes. Esto nos lleva una de las tres partes principales de un robot.

– Estructura Mecánica [3]

En la década de los 70’s, la industria solicitó a las universidades/fabricantes, que el desarrollo se orientara a la implementación de motores eléctricos e interruptores para poder controlar las estructuras de los robots industriales. El potencial de la producción en cadena, planteado por Henry Ford, al emplear manipuladores mecánicos eléctricos controlados por interruptores y por operadores dentro de las fábricas, fue alto y sigue vigente hasta en la actualidad. Los motores eléctricos, requieren mucho menos mantenimiento que los motores a combustibles fósiles, son más silencios, eficientes, fáciles de reparar y al ser controlados con interruptores versátiles, nos introduce a la segunda parte fundamental de un robot: Su sistema eléctrico de control.

– Sistema Eléctrico de Control

En los años 80’s del siglo pasado, en los manipuladores industriales, tomó importancia el uso de sensores. Con la incorporación de las mini-computadoras programables,  en las cuales se podían generar rutinas con los movimientos repetitivos que caracterizan a la producción en serie. Los problemas de desgaste en las juntas de este tipo de maquinaria, no permitían automatizar por medio de un programa de secuencias repetitivas a los manipuladores, pues las posiciones a las que tenían que llegar los elementos del manipulador, cambiaban con el tiempo, por el efecto de fricción y desgate mencionado. Por lo que los avances en el ramo de la robótica, se centran en la automatización, basada con la retroalimentación de los sensores de posición, velocidad, distancia y presencia. Estos aportes permitieron que los Manipuladores Industriales pudieran tener programaciones que con retroalimentación del mundo exterior, que asegura si las tareas se realizaban dentro de los rangos esperados, o bien, avisar que requerían un ajuste los movimientos, incluso ser ajustados automáticamente por los programas contenidos en su microcomputadora.

Actualmente la definición de robot actual es:

Dispositivo con un sistema de computo, que contiene un programa para controlar los movimientos de los actuadores mecánicos y eléctricos, utilizando la información recopilada de su medio ambiente, por medio de sus sensores, para tomar decisiones.

Partes de un robot

a) Actuadores mecánicos

b) Sistema eléctrico y Sistema electrónico

b) Con un sistema de computo, con un programa

c) Sensores, para tener una retroalimentación de su medio ambiente

Referencias

[1] https://es.wikipedia.org/wiki/Robot

[2] http://www.jotdown.es/2013/02/detroit-asi-se-hundio-el-titanic-del-capitalismo-estadounidense/

[3] http://davidentrablog.blogspot.mx/2012/12/transformaciones-del-sxix-y-su.html

León Ramos PorLeón Ramos

¿Cansado de hacer tuit? ¡Prueba hacer un toot!

Para como están las cosas hoy, muchos sabemos cómo usar las redes sociales, pero hay preguntas importantes que preferimos no contestarnos.

  • ¿Quién es el dueño de mis fotos cuando las publico en redes sociales?

¿Son mías? No para nada, los términos de licenciamiento pueden cambiar y lo harán con el tiempo, pero básicamente dicen que al subir tus fotografías a dichas redes, aunque conservas la propiedad de las mismas, estás otorgando una licencia de uso sin costo a twitter, facebook y a todas sus redes emparentadas. Básicamente, pueden usar tus fotos para lo que quieran, venderlas si les da la gana, y tú no recibirás una retribución por ello.

  • ¿En dónde vive mi información?

Bien, pues en los servidores del dueño de la aplicación, si es facebook, en la granja de servidores de facebook, que bien pueden estar en suelo americano y ser susceptibles a la ley patriota (que el gobierno americano pueda pedir sin restricción ver todo tu perfil si así lo desea), o bien, repartidos por el globo terráqueo.

  • Si  borro todo mi contenido, ¿qué pasará con mis datos?

Si el contenido fue compartido con otros usuarios, las redes sociales ya no pueden asegurarte su eliminación. Básicamente tu información ya fue redistribuída y no podrás detenerla (excepto con algún fallo de la corte americana de derecho al olvido). Por otro lado, aunque tu información no haya sido compartida por otros usuarios, twitter y facebook se reservan el derecho de tener respaldos completos y almacenarlos durante el tiempo que ellos consideren necesario.

  • ¿Puedo ver lo que hace su código?

Pero por su puesto que no, su código es lo más secreto que tienen y su único valor, por ende, los usuarios de éste tipo de servicios no tenemos la facultad de saber qué hacen o cómo lo hacen. ¿Te habrás preguntado por qué la publicidad que te aparece está tan bien estudiada para ti? Bien, sus algoritmos de inteligencia artificial hacen la chamba de perfilar tu segmento y, más interesante, tus gustos.

¿Qué opciones tenemos?

Bien, pues como lo anunciamos con bombo y platillo, este artículo tratará sobre Mastodont, una red social federada de código abierto y que se plantea como una opción viable para reemplazar a twitter.

Pero, ¿qué ventajas reales tiene?

  1. Según la página de términos del sitio, Mastodont, únicamente utilizará tu información para mejorar la experiencia de uso del sistema. Además, se comprometen a no lucrar con su información y a no compartirla con terceras empresas.
  2. El servicio es federado, es decir, no existe una única entidad que se encarga de administrar todos los equipos. Tu mismo puedes montar tu servidor de Mastodont y convertirte en un nodo más de la federación.
  3. Es código abierto, podemos revisar lo que hace y cómo lo hace. Eso nos asegura que no estás corriendo scripts que te rastrean o que intentan algo malicioso contigo.
  4. No más publicidad molesta en el servicio. Su página es limpia y, aunque admito ser neófito en la red, sus funciones parecen ser muy sencillas.

Son cuatro razones importantes de peso ¿no creen? Bienvenidos a Mastodont.

Nuestra cuenta es: @creadoresdigitales y estamos en mastodont.social