Archivos para febrero, 2017

Este destellador de potencia puede controlar lámparas hasta de 100W en la red de 110V y hasta 200W en la red de 220V, en función del puente de diodos, que en este caso es de 1A, para una lámpara de hasta 200W. Para lámparas de mayor potencia se debe reemplazar los diodos del puente rectificador teniendo en cuenta la siguiente ecuación:

P = V * I     (Potencia = Voltaje * Intensidad)

Donde P es la potencia de la lámpara a controlar, V es el voltaje de la red domiciliaria e I es la corriente que deben soportar los diodos del puente rectificador.

Por ejemplo, para una lámpara de 200W de potencia:
200W = 220V * I
Despejando I de la ecuación, tenemos:
I = (200W / 220V)
I = 0,90A

Para no llevar los componentes al límite de su capacidad (principalmente el puente rectificador), dejamos un margen de 20W.

Ahora analicemos el caso para una lámpara de 600W, el triple de potencia del ejemplo anterior:
600W = 220V * I
Despejando I de la ecuación, tenemos:
I = (600W / 220V)
I = 2,72A

Un total de casi 3A de corriente y una tensión de 220V. En este caso debemos reemplazar los diodos del puente rectificador 1N4007 (1000V – 1A) por otros diodos que toleren los valores calculados anteriormente, como por ejemplo: 1N5408 (1000V – 3A).

El tiristor SCR TIC106D soporta una tensión de trabajo de 400V y corriente de hasta 5A. Debe armarse con disipador de calor.
El control es de onda completa y el ajuste de frecuencia se hace con P1. C1 debe tener valores entre 470nF y 1uF y es de poliéster con una tensión de trabajo por lo menos de 400V.

Datasheet TIC106D

Lista de Componentes
1 Resistencia 47KΩ 0.25W
1 Resistencia 100KΩ 0.25W
1 Resistencia 1KΩ 0.25W
1 Potenciómetro Lineal para PCB 1MΩ
1 Tiristor SCR TIC106D
1 Disipador de Calor Aleta para encapsulado TO-220
1 Diodo de Conmutación Rápida 1N4148
1 Capacitor Poliéster 1uF 400V
1 Lámpara de Neón 90V (NO LED, sino el famoso “foquito naranja” que tenía la plancha de la abuela)
4 Diodos Rectificadores 1N4007, o un puente rectificador 1000V – 1A (tiene la apariencia de una pastilla negra)
2 Borneras de 2 Pines
1 Placa Para Prototipado de 5cm x 5cm

(click para ampliar)

Como primer paso, montaremos sin soldar los componentes, a modo de ubicarlos estratégicamente y nos resulte sencillo soldar formando las pistas de nuestro Destellador de Potencia. Tampoco debemos olvidar los correspondientes jumpers de interconexión entre componentes. Este primer paso también es fundamental para reducir el tamaño de nuestra placa en caso de no utilizarla totalmente.

(click para ampliar)

Ahora ya conocemos el espacio físico que ocuparán los componentes y las pistas que trazaremos posteriormente en el proceso de soldado, por lo tanto podemos redimensionar nuestra placa cortando con una sierra Junior la/s parte/s que no utilizaremos.

(click para ampliar)

A partir de este paso comenzaremos con el proceso de soldado e interconexión entre los componenetes. Generalmente es recomendable soldar primero los componentes de bajo perfil, así que soldaremos los jumpers.

(click para ampliar)

(click para ampliar)

Continuaremos soldando el diodo de conmutación rápida 1N4148.

(click para ampliar)

A continuación soldaremos las resistencias.

(click para ampliar)

(click para ampliar)

Seguiremos por soldar el puente rectificador.

(click para ampliar)

Ahora soldaremos la lámpara de neón.

(click para ampliar)

Soldaremos las borneras de conexión.

(click para ampliar)

El potenciómetro lineal.

(click para ampliar)

A continuación soldaremos el capacitor de poliéster de alta tensión.

(click para ampliar)

IMPORTANTE: El tiristor TIC106D debe ser dotado de un disipador de calor como se observa en la imagen de abajo. La grasa siliconada debe aplicarse en su justa medida (con una película delgada es suficiente), ya que en exceso produce el efecto contrario

(click para ampliar)

(click para ampliar)

Como paso final, soldaremos el tiristor y terminaremos nuestro montaje.

(click para ampliar)

Las pistas formadas y las interconexiones durante el proceso de soldado de los componentes se observan en la siguiente imagen:

(click para ampliar)

Algunas imágenes adicionales de nuestro montaje terminado.

(click para ampliar)

(click para ampliar)

(click para ampliar)

(click para ampliar)

Para el video he utilizado una lámpara de la línea “Philips Disco E27 60W” Color Verde 80mm de diámetro.

En publicaciones anteriores hemos visto diferentes mecanismos de control para nuestro robot, tanto manuales (Construyendo Nuestro Propio Robot Desde Cero – Parte 3) como autónomos (Arduino Robot Seguidor de Líneas y Laberintos). Ahora veremos una alternativa más, también inalámbrica, al igual que en la publicación anterior (Arduino Robot Controlado por Bluetooth y Android App) y que en estos últimos años ha crecido de manera exponencial en el mercado. El lector perspicaz ya advirtió que se trata de la tecnología Wi-Fi (Wireless Fidelity), omnipresente en el mercado y en nuestros hogares.

En cuanto empieces a buscar algo de Wi-Fi económico, te encontrarás con el módulo Wi-Fi ESP8266, fabricado por ESPRESSIF Systems, el cual es muy parecido a los módulos Bluetooth de la publicación anterior, y que al igual que ellos incluye toda la electrónica necesaria para la comunicación RF en la banda Wi-Fi, así como la pila TCP/IP y se comunica con nosotros a través de un puerto serie.

De hecho, exactamente al igual que los módulos Bluetooth HC-06 y HC-05, se gobierna mediante comandos AT, algo que ya no tiene secretos para los seguidores de este blog, y todo por un precio similar al de los módulos Bluetooth.
Lo primero, es decir que es un módulo muy sencillo y diseñado desde el principio con la “Internet of Things” en mente (IoT), y por eso incluye todo lo necesario para conectarse a un punto de acceso Wi-Fi o actuar por sí mismo como punto de acceso Wi-Fi mediante comandos AT, vía un puerto serie, que puede ser configurado a diferentes velocidades.

Este circuito integrado es una pequeña maravilla tecnológica. Está diseñado y pensado para ser la solución ideal para todo el que necesite un “Todo en uno Wi-Fi” para proyectos de hobby, IoT o producto comercial sin complicaciones. Y lo más importante, lo consigue.

  • Voltaje de alimentación: 3.3V
  • Procesador interno de 32 bits a 80 MHz (se puede incrementar hasta 160MHz).
  • 80KB de DRAM.
  • 35KB de IRAM, memoria rápida para el procesador.
  • 512KB (hasta 1MB, dependiendo de la versión del módulo) de memoria flash para nuestros programas.
  • Pila TCP/IP Wi-Fi a 2.4 GHz (b/g/n).
  • 30 metros de alcance teórico.

Nota del Autor: de hecho, el módulo ESP8266 incluye un pequeño procesador interno que podríamos programar para funcionar de modo autónomo y dispone de un par de puertos GPIO (General Purpose Input Output) para su uso como activadores. Es posible programarlo desde el IDE Arduino, y más interesante aún, con MicroPython.

Lista de Componentes
1 Plataforma Turtle2WD con placa Arduino UNO R3 y Shield de Control de Motores ensamblados anteriormente.
1 Adaptador Sparkfun FTDI USB – UART TTL 3.3V
1 Módulo Wi-Fi ESP8266 (ESP-01)
1 Convertidor Bidireccional de Niveles Lógicos Sparkfun.
1 Capacitor Electrolítico 1000uF 6.3V
2 Baterías AA 1.5V de Alto Rendimiento
1 Portapilas para 2 Baterías AA

Antes de instalar el módulo en nuestro robot, modificaremos algunos parámetros de su configuración mediante comandos AT. Para llevar a cabo esta tarea sólo necesitamos descargar el documento que contiene el set de instrucciones AT ESP8266 y un emulador de terminal RS232.

Set de Instrucciones AT ESP8266

Termite 3.3
Tamaño: 294KB
SHA1 Hash: 5A7DEBD9E1F245EB87FAEF397187752D5CFF1841
Descarga     Mirror

A continuación conectaremos nuestro módulo al Adaptador FTDI USB – UART TTL 3.3V como se muestra en la siguiente imagen:

(click para ampliar)

Ahora, el emulador de terminal (en nuestro caso, Termite) debe estar configurado de la siguiente manera, que son los parámetros por defecto de nuestro módulo Wi-Fi.

Habiendo logrado una conexión exitosa en el paso anterior, ahora debemos enviar los comandos AT necesarios para configurar nuestro módulo. En la siguiente imagen se observa la secuencia de comandos enviados:

AT
AT+CWSAP_DEF="TURTLE2WD","",1,0,4
AT+UART_DEF=19200,8,1,0,0

Nuestros comandos enviados se encuentran en color azul, en color verde se encuentran las respuestas de nuestro módulo y el eco local de la consola. Con la ejecución exitosa de estos comandos modificamos el SSID de nuestro módulo por “TURTLE2WD” para identificarlo fácilmente y redujimos la velocidad del puerto serie a 19200bps lo cual nos permite utilizar cables de mayor longitud para el montaje en caso de ser necesario.

Habiendo finalizado exitosamente los pasos anteriores, compilaremos y cargaremos en nuestro Arduino Uno R3 el sketch correspondiente, cuyo código fuente se encuentra a continuación:

/*
Caracteristicas:
- Control por Wi-Fi utilizando el modulo ESP8266
- Interfaz web con jquey para envio de peticiones GET
- Id de botones para envio de datos
W: Adelante
S: Atras
A: Izquierda
D: Derecha
L: Inicio/Parada Modo Vehiculo

Q: Incrementar Velocidad
T: Disminuir Velocidad
X: Encendido/Apagado Luz Frontal

- Detencion automatica en caso de detectar bordes.
*/

#define     PWM_RIGHT   3     // (Control Velocidad Motor Derecho) Timer2 8 bits D3
#define     PWM_LEFT    11    // (Control Velocidad Motor Izquierdo) Timer2 8 bits D11
#define     DIR_A       12    // (Control de Direccion de Motores) D12
#define     DIR_B       13    // (Control de Direccion de Motores) D13
#define     MAX_SPEED   200   // Velocidad Maxima
#define     MIN_SPEED   100   // Velocidad Minima
// -----

// Iluminacion
#define     LED_LIGHT   7
// -----

// Sensores Reflectivos Detectores de Bordes
#define     BORDER_L    A2    // Sensor Izquierdo Externo
#define     BORDER_R    A5    // Sensor Derecho Externo

// Serial commands
#define     DIR_FORWARD     'W'
#define     DIR_BACKWARD    'S'
#define     DIR_LEFT        'A'
#define     DIR_RIGHT       'D'
#define     START_STOP_V    'L'
#define     INC_SPEED       'Q'
#define     DEC_SPEED       'T'
#define     FRONT_LIGHT     'X'
// -----

#define     DEBUG   false

boolean stopped;

byte speed, connectionid;

char data;

void forward() {
    digitalWrite(DIR_A, LOW);
    digitalWrite(DIR_B, LOW);
}

void backward() {
    digitalWrite(DIR_A, HIGH);
    digitalWrite(DIR_B, HIGH);
}

void rotateleft() {
    digitalWrite(DIR_A, LOW);
    digitalWrite(DIR_B, HIGH);
}

void rotateright() {
    digitalWrite(DIR_A, HIGH);
    digitalWrite(DIR_B, LOW);
}

void stop() {
    analogWrite(PWM_LEFT, 0);
    analogWrite(PWM_RIGHT, 0);
}

void setspeed(boolean sp) {
    if (sp) {
        if (speed < MAX_SPEED) {
            speed += 50;
            analogWrite(PWM_LEFT, speed);
            analogWrite(PWM_RIGHT, speed);
        }
    }
    else
    {
        if (speed > MIN_SPEED) {
            speed -= 50;
            analogWrite(PWM_LEFT, speed);
            analogWrite(PWM_RIGHT, speed);
        }
    }
}

void setlight() {
    digitalWrite(LED_LIGHT, !(digitalRead(LED_LIGHT)));
}

boolean isborder() {
    if ((digitalRead(BORDER_L) == HIGH) || (digitalRead(BORDER_R) == HIGH))
        return true;
    else
        return false;
}

String sendData(String command, const word timeout, boolean debug) {
    String response = "";

    Serial.print(command); // send the read character to the esp8266

    unsigned long time = millis();

    while ((time + timeout) > millis()) {
        while(Serial.available()) {
            // The esp has data so display its output to the serial window
            char c = Serial.read(); // read the next character.
            response += c;
        }
    }

    if (debug)
        Serial.print(response);

    return response;
}

void setup() {
    pinMode(PWM_LEFT, OUTPUT);
    pinMode(PWM_RIGHT, OUTPUT);
    pinMode(DIR_A, OUTPUT);
    pinMode(DIR_B, OUTPUT);
    pinMode(LED_LIGHT, OUTPUT);

    pinMode(BORDER_L, INPUT);
    pinMode(BORDER_R, INPUT);

    digitalWrite(LED_LIGHT, LOW);

    stopped = true;

    speed = MIN_SPEED;

    Serial.begin(19200);

    sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); // configure for multiple connections
    sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); // turn on server on port 80
}

void loop() {
    if (Serial.available()) {
        if (Serial.find("+IPD,")) {
            delay(100);
            connectionid = (Serial.read() - 48);

            Serial.find("cmd=");
            data = Serial.read();

            if (data == START_STOP_V) {
                if (stopped) {
                    forward();

                    analogWrite(PWM_LEFT, speed);
                    analogWrite(PWM_RIGHT, speed);

                    stopped = false;
                }
                else
                {
                    stop();
                    stopped = true;
                }
            }

            switch (data) {
                case DIR_FORWARD:
                    if (!stopped)
                        forward();
                    break;

                case DIR_BACKWARD:
                    if (!stopped)
                        backward();
                    break;

                case DIR_LEFT:
                    if (!stopped)
                        rotateleft();
                    break;

                case DIR_RIGHT:
                    if (!stopped)
                        rotateright();
                    break;

                case INC_SPEED:
                    if (!stopped)
                        setspeed(true);
                    break;

                case DEC_SPEED:
                    if (!stopped)
                        setspeed(false);
                    break;

                case FRONT_LIGHT:
                    setlight();
                    break;

                default:
                    break;
            }

            String closecommand = "AT+CIPCLOSE=" + String(connectionid) + "\r\n";
            sendData(closecommand, 100, DEBUG);
        }
    }

    if (isborder())
        stop();
}

En este punto nos encontramos en la etapa final. A continuación conectaremos nuestro módulo Wi-Fi a la placa Arduino UNO R3, como se observa en la siguiente imagen:

(click para ampliar)

Por último necesitamos la interfaz web desde la cual controlaremos nuestro robot. Consta de un documento HTML y jQuery, una biblioteca multiplataforma de JavaScript, que permite simplificar la manera de interactuar con los documentos HTML, manipular el árbol DOM, manejar eventos, desarrollar animaciones y agregar interacción con la técnica AJAX a páginas web. jQuery es la biblioteca de JavaScript más utilizada.

Interfaz Web
Tamaño: 27.5KB
SHA1 Hash: 0C9AE81B92C8243C362C2DFA94C79065D8D3447E
Descarga