Manual Pinguino v 1.1.pdf

Taller Práctico de Robótica Educativa con Hardware y Software Libre Multiplataforma Conocimiento al alcance de todos

Pensado para su aplicación en el aula

Responsables:  Miguel Papadópulos  Sergio Arciénaga

Robótica Educativa con “Pingüino”

A modo de Prólogo Estimados estudiantes y docentes: En esta cartilla hemos tratado de recopilar parte de la información que se encuentra fundamentalmente en la web, a los efectos de poner a disposición del sistema educativo salteño, los conocimientos necesarios para iniciarse en el fascinante mundo de la robótica. El taller está pensado para desarrollar las capacidades de creatividad y pensamiento lógico de nuestros estudiantes y docentes, para mejorar las competencias comunicativas y de resolución de problemas, en forma colaborativa. Toda la información ha sido extractada de sitios de personas que comulgan con la filosofía del hardware y el software libre, es decir de la libre circulación del conocimiento y su intercambio. Es por ello que les decimos a todos los que tengan acceso a este material y lo consideren de utilidad, siéntanse libres de modificarlo y distribuirlo. Por último agradecemos a todas las instituciones educativas que, a partir de su participación en el taller, nos hicieron llegar sus sugerencias y correcciones. Miguel y Sergio

2 Salta Argentina 2013


ÍNDICE

::: Introducción a la Plataforma "Pingüino" .................................................................................................4 Plataformas de Hardware Libre: ..............................................................................................................4 ::: Hardware Mínimo Inicial .........................................................................................................................5 Resultado Final del armado Físico ...........................................................................................................5 Esquema lógico de la plataforma ............................................................................................................6 ::: Software inicial ........................................................................................................................................6 Instalación del Software Pingüino en Windows 7 ...................................................................................7 ::: Creación y ejecución de mi primer programa (“Hola Mundo”). .......................................................... 13 ::: Inicio de tu primer proyecto ................................................................................................................. 18 1° Opción de Solución: “Fuerza Bruta” ................................................................................................. 19 2 ° Opción de Solución: Utilización de ciclos for (“Fuerza no tan Bruta”) ............................................ 20 3° Opción de Solución: Utilización de un vector................................................................................... 22 :::: Encender y Apagar un led utilizando un pulsador............................................................................... 23 :::: Armemos un semáforo ........................................................................................................................ 24 :::: Combinando los ejemplos anteriores.................................................................................................. 25 :::: Aprendamos a usar nuevas instrucciones: analogRead y analogWrite............................................... 26 ::: ¡Calentando Motores! .......................................................................................................................... 29 :::: Pongamos Blanco sobre Negro o Negro sobre Blanco ........................................................................ 34 :::: Fuentes de información consultada .................................................................................................... 36 :::: Anexo I: Sintaxis y Estructuras del Lenguaje de Programación Pingüino IDE ..................................... 37 :::: Anexo II: Instalación de los Drivers de Pingüino en Windows 8.......................................................... 39



::: Introducción a la Plataforma "Pingüino" Pingüino es una plataforma de hardware y software "open source" para la experimentación con microcontroladores, similar a Arduino pero basada en un microcontrolador PIC18F2550/4550 y cuenta con su propio Entorno de Desarrollo Integrado (IDE) de uso y apariencia similar al de Arduino. A diferencia de la placa Arduino, el Pingüino no necesita una Interfaz UART a USB adicional para comunicarse con la PC, debido a que el microcontrolador PIC18F2550/4550 tiene un módulo USB integrado, lo cual le permite comunicarse directamente con la PC y reduce el costo del hardware, dejando además libre el puerto UART del microcontrolador para las aplicaciones.

Plataformas de Hardware Libre:

Arduino1

Pingüino2

El circuito básico del Pingüino es muy simple y sólo se precisan unos pocos componentes; todo el software necesario está disponible para bajarse de internet gratuitamente.

En este manual vamos a ver los siguientes aspectos: 

Hardware mínimo inicial



Instalación de los programas necesarios



Compilación



Ejecución de un primer programa.

1 2

http://www.arduino.cc/es/ http://www.pinguino.cc/ 4 Salta Argentina 2013


::: Hardware Mínimo Inicial 

Un Microcontrolador Pic 18F2550/4550



1 Pulsador



1 Cuarzo 20 MHz



5 Capacitores



o o o o 2 Leds



o 1 rojo o 1 verde 3 Resistencias



o 1 de 10 K Ohm o 2 de 470 Ohm Una Protoboard/Placa de prueba



Cables para conectar en la protoboard

1 capacitor cerámico de 0.1 uf (N° 104) 2 capacitores cerámicos de 22 pf (N° 22) 1 capacitor cerámico de 220 nf (N° 224) 1 capacitor electrolítico de 10 uf

Resultado Final del armado Físico

Pata larga

Resultado Final de la plataforma Pingüino.

Pata corta

Imagen desarrollada con un soft ware de licencia libre llamado Fritzing. Lo podés bajar desde su página oficial: http://fritzing.org/



Esquema lógico de la plataforma

Resultado Final de la plataforma Lógico y Físico pingüino.

Muy importante

Tener en cuenta que los Pines Lógicos están numerados por fuera del PIC y son utilizados por el lenguaje de programación a la hora de programar al PIC18F2550 y las patitas físicas están numeradas en forma de “U” por dentro del PIC y se utilizan para el armado del circuito. Por ej. la patita 2 del micro corresponde al PIN 13/ANALÓGICO Además !!! Para que el circuito funcione, el PIC18F2550/4550 debe tener grabado el cargador de arranque (bootloader) de Pingüino, el cual puede ser descargado de: http://sites.google.com/site/pinguinotutorial/bootloader. Se necesita un programador de microcontroladores Microchip como el Pickit 2, Pickit 3 u otro compatible para grabar el bootloader en el PIC18F2550/4550.

::: Software inicial Actualmente el software para Pingüino está soportado oficialmente para los sistemas operativos: 

Linux



Windows XP 6 Salta Argentina 2013




Windows 7



MACOSX

Debido a que el entorno de desarrollo integrado de Pingüino, el cual permite escribir, compilar y grabar los programas, está escrito en Python, es necesario instalar componentes Python para su funcionamiento. En el caso de Windows, la lista de componentes varía ligeramente según sea el sistema operativo (Windows XP o 7) en el cual querremos instalar, sin embargo todo esto está detallado en los tutoriales oficiales del proyecto Pinguino.

Instalación del Software Pingüino en Windows 73 En el sitio: https://sites.google.com/site/pinguinotutorial/installation/windows-7, se encuentra el procedimiento para la instalación del software en Windows 7. Como se encuentra en inglés, simplemente lo tradujimos y desarrollamos a continuación. Primero es necesario instalar el driver libusb. El instalador lo puedes bajar de aquí (http://www.hackinglab.org/pinguino/download/driver%20pinguino%20windows%207/setup.exe). Este driver es compatible con 32 y 64 bits con múltiples arquitecturas ( X86,AMD64,IA64 ). La instalación de los drivers debe seguir este orden!!! 1. Setup

3

Actualmente tenemos desarrollado un sistema de instalación desatendida de todo el software de Pingüino. 7 Salta Argentina 2013


2. Una vez finalizada la instalación del Pingüino Driver conectamos la Placa Pingüino en el puerto USB de la PC. Es probable que el sistema al detectar un nuevo hardware nos muestre el Asistente para instalarlo. Si esto sucede se debe

cancelar o cerrar dicha pantalla. A continuación

verificamos a través del administrador de dispositivos si Windows reconoció nuestra placa Pingüino haciendo: a) Clic en el botón Iniciar

(Windows 7) o en el botón Inicio

(Windows XP),

luego clic con el botón derecho sobre Equipo (Windows 7) o en Mi PC (Windows XP) En la opción Propiedades del menú Luego hacer clic en Administrador de dispositivos ubicado en el panel de la izquierda (Windows 7) contextual hacer clic

Las pantallas corresponden a Windows 7

Debe aparecer la siguiente pantalla:



Vemos que el reconocimiento de la Placa Pingüino debe ser “curado” para que Windows la detecte adecuadamente. 3. Para ello ir a la carpeta libusb-win32-bin-1.2.6.0, luego abrir la carpeta bin y ejecutar el inf-wizard,

El asistente te guía en la instalación haciendo clic en los botones

.Cuando llegues a la

siguiente pantalla selecciona la opción Pingüino Project y continúa con el botón

Cuando llegues a la pantalla con el botón

hacer clic y esperar la finalización de la

instalación



Cuando este driver esté instalado verifica en el Administrador de dispositivos (panel de control/sistema/administrador de dispositivos). Se debe ver algo parecido a esto:

Ya instalamos los driver!!! Luego debes instalar los siguientes programas: •

Python 2.6.6 (http://www.python.org/ftp/python/2.6.6/python-2.6.6.msi)



•

wxpython

2.8

(http://downloads.sourceforge.net/wxpython/wxPython2.8-win32-unicode-

2.8.11.0-py26.exe)

•

pyusb for python 2.6

(http://sourceforge.net/projects/pyusb/files/PyUSB%200.x/0.4.3/pyusb-0.4.3.win32py2.6.exe/download)

Muy Bien!!! ya instalamos todos los paquetes de Python. 11 Salta Argentina 2013


Descarga la última versión de Pingüino: (http://www.hackinglab.org/pinguino/download/latestpinguino/) Por último necesitamos instalar el software pingüino, la versión X.2 o la X.34 haciendo clic en Siguiente > y Finalizar

El último programa que nos falta instalar es el Pingüino Kit, para ello simplemente hacemos doble clic sobre el ícono del instalador y vamos aceptando los valores que por defecto nos propone el proceso de instalación, haciendo clic en Aceptar o en Siguiente-Next, según sea el caso.

Ya instalamos todos los programas, es el momento de5:

4 5

En este Taller se trabaja con la versión X.2 por ser la más estable en estos momentos. Aquí tendríamos que poner sonido de redoblantes!!! 12 Salta Argentina 2013


::: Creación y ejecución de mi primer programa (“Hola Mundo”). En el primer ejemplo de programación del microprocesador simplemente vamos a prender y apagar un LED de manera intermitentemente. Presentamos una guía paso a paso para “no morir en el intento” y asegurar el éxito de la tarea:

1.- Tenemos que tener en claro el objetivo: Hacer que parpadee un LED de manera intermitente conectado a una de las patitas del micro.

2.- Los componentes necesarios son: 1 led

Tener en cuenta que la pata larga del LED –también llamada Ánodo- va hacia el microprocesador (en este caso al Pin 13 Analógico correspondiente a la patita 2 del PIC). Pata larga

3.- Montar el led en la protoboard:

Mueca del PIC

Pata larga



4.- Arrancar Pingüino Kit y arrastrar los bloques hasta que quede como la imagen de la columna de la izquierda: Desde Pingüino Kit

Diagrama de Flujo Inicio del Programa

Código: presionando F4 aparece el siguiente código (sin los comentarios en verde) void setup() //Aquí se establece el comportamiento de los pines { pinMode(13,OUTPUT); // Establecemos el

Pin Mode 13 Analogico - Output

Pin 13 como salida para el led } void loop() // Aquí se inicia un ciclo que

Enciende LED por 4 seg

repite

indefinidamente

lo

que

está

encerrado entre las dos llaves. { //llave de apertura digitalWrite(13,HIGH); // El led se prende Apaga LED por 1 seg

delay(4000); //durante 4 segundo. digitalWrite(13,LOW); // El led se apaga delay(1000); // durante 1 segundo.

Fin del Programa

} //llave de cierre

Al código que aparece en una ventanita luego de presionar F4, lo seleccionamos y lo copiamos presionando Ctrl – C o haciendo clic con el botón derecho del mouse y eligiendo la opción Copy del menú contextual.



5.- Minimizar el Pingüino Kit y arrancar el Pingüino IDE X.2

Hacer clic en Archivo, luego clic en Nuevo. Presionar Ctrl – V para pegar el código.



Ahora hay que Compilar el código con el botón "Compile" en la barra de herramientas (si apuntas los íconos con el mouse, se pueden ver las funciones de cada botón):



1.- Botón para compilar

Eurekas!! ! Si todo ha ido bien debe aparecer en la ventana inferior Output (la que tiene fondo negro) “compilation done”. Esto significa que el Pingüino IDE ha podido compilar (traducir el código a un lenguaje que pueda ser entendido por el micro) con éxito.

6.- Grabar el compilado en el Microprocesador

2.- Botón Upload to Pingüino para grabar el programa compilado en el micro.



Hacer clic en el botón "Upload to Pingüino". 16 Salta Argentina 2013




Aparece la ventana "Vascobootloader". En este momento debes presionar el pulsador de la placa Pingüino montada en la protoboard, esperar tres segundos aproximadamente (cuenta hasta 3) y luego haz clic en el botón "Write" para cargar el programa en la placa Pingüino. 1.- Presionar el pulsador de Reset

2.- Esperar 3 segundos y hacer clic en el botón Write

En la ventana de VascoBootloader aparece la leyenda6: PIC found NoName0.hex uploaded Esto quiere decir que el PIC ha sido encontrado o reconocido y el programa previamente compilado llamado NoName0.hex ha sido cargado con éxito. Una vez cargado, el programa empieza a ejecutarse en la placa Pingüino y en este caso el LED empieza a parpadear7. Probando, probando!!: el número "4000" en la instrucción "delay(4000);" representa el tiempo en milisegundos que el LED permanece prendido (o sea 4 seg.). Cambia la cantidad a 200 u 800 para ver qué sucede. Lo mismo con el “delay(1000);” que es el que define el tiempo que el LED está apagado. No te olvides del

; al final de c/línea.

Nota: No te olvides que para grabar otro nuevo programa en la placa, debes apretar el botón reset, contar hasta 3 y recién pulsar el botón "Write" en la ventana "Vascobootloader", de otro modo el Pingüino no es reconocido por el software.

6

Si en vez de PIC found aparece la leyenda PIC not found!! no te asustes, es probable que te hayas apresurado o demorado en presionar Write. Simplemente vuelve a presionar reset, cuenta hasta tres y haz clic en Write nuevamente. 7 Este es el momento de los fuegos artificiales !!! 17 Salta Argentina 2013


::: Inicio de tu primer proyecto En esta primera actividad vamos a realizar una secuencia de leds que se enciendan y se apaguen simulando un desplazamiento de luces rojas. Para ello contaremos con la conexión de 5 leds agregados al circuito de Pingüino. La secuencia sería la siguiente: Tiempo 1: Led encendido conectado a la salida 3 (En el Grafico Led N° 1) Tiempo 2: Led encendido conectado a la salida 4 (En el Grafico Led N° 2) Tiempo 3: Led encendido conectado a la salida 5 (En el Grafico Led N° 3) Tiempo 4: Led encendido conectado a la salida 6 (En el Grafico Led N° 4) Tiempo 5: Led encendido conectado a la salida 7 (En el Grafico Led N° 5) Manos a la obra!!! El esquema de conexión será el siguiente:

Esta actividad puede ser resuelta de diferentes maneras:



1° Opción de Solución: “Fuerza Bruta” Desde Pingüino Kit

Diagrama de Flujo Inicio del Programa

Código void setup() { pinMode(3,OUTPUT);

Pin Mode 3 Analógico - Output


pinMode(4,OUTPUT); pinMode(5,OUTPUT); pinMode(6,OUTPUT);




pinMode(7,OUTPUT); }

void loop() { digitalWrite(3,HIGH);

Enciende Led 3 por 1 Seg Apaga Led 3 por 1 Seg

delay(1000); digitalWrite(3,LOW); delay(1000);


digitalWrite(4,HIGH); delay(1000); digitalWrite(4,LOW);


delay(1000); digitalWrite(5,HIGH); delay(1000);


digitalWrite(5,LOW); delay(1000); digitalWrite(6,HIGH);


delay(1000); digitalWrite(6,LOW); delay(1000);

Fin del Programa

digitalWrite(7,HIGH); delay(1000); digitalWrite(7,LOW); delay(1000); }



2 ° Opción de Solución: Utilización de ciclos for (“Fuerza no tan Bruta”) ¿Qué es un ciclo for? Este tipo de ciclos es uno de los más usados para repetir una secuencia de instrucciones, sobre todo cuando se conoce la cantidad exactas de veces que se requiere ejecutar un tipo de instrucciones. Su formato es:

for (valores de entrada ; condición de terminación ; iteración por ciclo) 

Las tres partes del ciclo se encuentran separadas por ; (punto y coma)



La primer parte del ciclo especifica valores previos a su inicio.



La segunda parte indica la condición de terminación para el ciclo, la cual está directamente relacionada con los valores iniciales.



Finalmente, la última parte especifica cómo serán incrementados los valores iniciales en cada iteración o repetición del ciclo: de uno en uno, de dos en dos, etc. Desde Pingüino Kit

Diagrama de Flujo

Código int tiempo=2000; // Inicializamos

Inicio del Programa

la variables tiempo en 2 seg.

Inicializamos variables I = 0 utilizado en ciclo For

int i=0; // y la variable i que será

Tiempo = 2000, 2 Seg

utilizada en el ciclo for. void setup() {

iß3

i<8

//Inicializamos

iß i + 1 Si

las

salidas

analógicas utilizando un ciclo for

No

for(i=3;i<8;i++){ pinMode(i,OUTPUT);

Pin (i, Output)

} iß3

} i<8

void loop() {

iß i + 1

for(i=3;i<8;i++){ Si No

Enciende Led (i) por (Tiempo) Seg

Apaga Led (i) por (Tiempo) Seg

digitalWrite(i,HIGH); delay(tiempo); digitalWrite(i,LOW); delay(tiempo);

Fin del Programa

} } 20

Salta Argentina 2013


Analicemos con detenimiento lo que hace el ciclo for y el comando digitalWrite que está en su interior: for (i=3;i<8;i++){ digitalWrite(i,HIGH); }

1.- La primera vez que se ejecute esta instrucción la variable i es igual a 3 por lo tanto digitalWrite será: digitalWrite(3,HIGH) se prende el led conectado al Pin 3 (correspondiente a la patita 24) 2.- La segunda vez que se ejecute esta instrucción i=4 por lo tanto digitalWrite será: digitalWrite(4,HIGH) se prende el led conectado al Pin 4 (correspondiente a la patita 25) 3.- La tercera vez que se ejecute esta instrucción i=5 por lo tanto digitalWrite será: digitalWrite(5,HIGH) se prende el led conectado al Pin 5 (correspondiente a la patita 26) 4.- La cuarta vez que se ejecute esta instrucción i=6 por lo tanto digitalWrite será: digitalWrite(6,HIGH) se prende el led conectado al Pin 6 (correspondiente a la patita 27) 5.- La quinta vez que se ejecute esta instrucción i=7 por lo tanto digitalWrite será: digitalWrite(7,HIGH) se prende el led conectado al Pin 7 (correspondiente a la patita 28) La sexta vez que se ejecute el ciclo for la variable i será igual a 8 por lo tanto la condición i<8 no se cumplirá. Esto hace que se termine el ciclo for y por consiguiente la secuencia de encendido y apagado de los leds. ¿Y si quisiera que la secuencia de encendido y apagado continuara indefinidamente (para que finalice debería desenchufar la placa Pingüino del puerto USB de la PC), qué debería hacer? Simplemente agregar “i=3;” (sin las comillas) después de la llave de cierre del ciclo for. ¿Te animas a comprobarlo? Muy bien!! completamos nuestra actividad utilizando ciclos FOR, ahora te proponemos la siguiente actividad:

1 - Encontrar una alternativa para modificar la secuencia de encendido y apagado de los leds. Que en vez de iniciar la secuencia desde el led 1 se inicie desde el led 5, de la siguiente manera:

Secuencia Anterior

Nueva Secuencia propuesta

Tiempo 1

Prendía el LED 1

Prender el LED 5

Tiempo 2

Prendía el LED 2

Prender el LED 4

Tiempo 3

Prendía el LED 3

Prender el LED 3

Tiempo 4

Prendía el LED 4

Prender el LED 2

Tiempo 5

Prendía el LED 5

Prender el LED 1 21 Salta Argentina 2013


3° Opción de Solución: Utilización de un vector. ¿Qué es un vector en informática? Un array o vector es una colección ordenada de elementos de un mismo tipo de datos, agrupados de forma consecutiva en memoria. Cada elemento del array o vector tiene asociado un índice o dirección, que no es más que un número natural que lo identifica inequívocamente y nos permite acceder a él. Por ej. el vector a puede ser representado como una cajonera cuyo contenido son valores numéricos (3,4,5,6,7):

3 Este cajón contiene el valor numérico 3. El índice del 1° cajón es cero. Se representa: a[0]=3 4 Este cajón contiene un 4 y su índice es 1. Se representa como: a[1]=4 5 Este cajón contiene un 5 y su índice es 2. Se representa como: a[2]=5 6 Este cajón contiene un 6 y su índice es 3. Se representa como: a[3]=6 7

El último cajón

contiene el valor numérico 7 y su índice es 4: a[4]=7

Es decir que se identifica el vector con un nombre (puede ser una letra o una palabra) luego se encierra entre corchetes el índice -que es la posición que ocupa el dato dentro del vector- teniendo en cuenta que la primera posición es el índice cero- luego se coloca el signo igual y a continuación su valor: nombre vector[índice]=valor

Código a ser escrito en el Pingüino IDE X.2 En primer lugar definimos el vector llamado leds con 5 cajoncitos ({3,4,5,6,7}) cuyos contenido serán números enteros (int). La 1° posición o índice [0] tendrá el valor 3 y la última posición o índice [4] tendrá el valor 7: int leds[]={3,4,5,6,7}; // Se define un vector llamado leds que contiene los valores enteros (int) 3,4,5,6 y 7 int tiempo=200; int n=0; int contador=0; void setup() { for (n=0;n<5;n++){ pinMode(leds[n],OUTPUT); //Inicializamos las salidas analógicas utilizando un ciclo for } }



void loop() { for(n=0;n<5;n++){ digitalWrite(leds[n],HIGH); delay(tiempo); digitalWrite(leds[n],LOW); delay(tiempo); } } Muy bien!! Completamos nuestra actividad utilizando un vector, ahora te proponemos la siguiente actividad:

Cambiar el código del programa para obtener la siguiente secuencia de encendido y apagado de los leds: led 7 – led 3 – led 6 – led 2 – led 4. Una vez resuelta la anterior secuencia puedes realizar otras secuencias utilizando otro patrón de encendido y apagado de los leds. Juega un poco con distintas alternativas y saca tus propias conclusiones.

:::: Encender y Apagar un led utilizando un pulsador

Materiales 1 resistencia de 10 k 1 Pulsador 1 led Pulsador

Cuando el pulsador no está pulsado el pin 13 está en estado alto/HIGH Cuando el pulsador está pulsado el pin 13 está en estado bajo/LOW 23 Salta Argentina 2013


En el esquemático se observa las conexiones necesarias para poner en práctica el siguiente ejemplo de código: void setup() { pinMode(7,OUTPUT); pinMode(13,INPUT); } void loop() { if(digitalRead(13)== LOW) //Si el Pin 13 es LOW, el pulsador está presionado. { toggle(7); //El Pin 7 cambia de estado: si está LOW pasa a HIGH y viceversa while(digitalRead(13)==LOW); //Para superar rebotes aleatorios del pulsador. delay(250); } }

En esta secuencia de código definimos por primera vez una patita del micro como entrada (INPUT), también vemos como se “lee” dicha entrada o sea, cuando se presiona el pulsador (con el comando digitalRead). El comando toggle nos permite prender si está apagado o apagar si está prendido el led conectado al Pin 7 (definido como de salida/OUTPUT). Por último con el comando while (que significa: mientras) evitamos los efectos de rebote que pueda tener el pulsador ya que únicamente deja que el void loop se repita si es que el pulsador efectivamente está presionado.

:::: Armemos un semáforo Materiales: 3 leds de color

Circuito: conectar las patitas largas (ánodo) de

Código: debes completar

rojo, amarillo y verde

los leds en los pines: 7(V), 6(A) y 5 (R) del micro.

el código con los valores correctos

int i=5; int tiempo=?; void setup() { for(i=?;i


:::: Combinando los ejemplos anteriores Te proponemos combinar el ejemplo del uso de un pulsador con el encendido del semáforo en un solo proyecto. Si te animas, puedes armar un semáforo como el de la imagen, dentro de un tubito de estaño vacío. La base está hecha con un pedazo de una disquetera vieja y un poco de poxilina. Los agujeros para los leds fueron hechos con el mismo soldador (ojo con quemarse).

Una ayudita con el código (una mezcla de los dos ejemplos anteriores): int i=5; int tiempo=?; void setup() { pinMode(13,INPUT); for(i=?;i

digitalWrite(i,LOW); delay(tiempo); } while(digitalRead(13)==LOW); //Para superar rebotes aleatorios del pulsador. delay(250); } }

:::: Aprendamos a usar nuevas instrucciones: analogRead y analogWrite A continuación vamos a transcribir de la excelente página de Henry Laredo un tutorial referido al uso de estas dos instrucciones: “Este tutorial trata sobre dos instrucciones magníficas del Pingüino que son: analogRead y analogWrite. Mediante el analogRead es posible implementar lecturas de voltajes analógicos, es decir leer niveles de tensión que varíen entre 0V y 5V. Con el analogWrite conseguiremos tener una salida de PWM8 cuyo duty cycle es variable pero de frecuencia fija”. Vamos a explicar un poco cómo trabaja analogWrite. En el siguiente gráfico vemos que el ancho del pulso o Duty Cycle (la meseta) puede variar de tamaño. A medida que es más ancho vemos que la tensión media Vm (representada por línea de puntos) aumenta y se acerca al valor máximo de tensión Vp de 5 voltios en nuestro caso. Esto hace que la señal que sale por la patita del PIC varíe según se aumente o disminuya dicho ancho (Duty Cycle).

Nótese que el tiempo entre el inicio de una señal y otra es constante y se llamada PERÍODO (la distancia en tiempo entre una “meseta” y otra). 8

La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de pulse-width modulation) de una señal o fuente de energía es una técnica en la que se modifica el ciclo útil de una señal (el que tiene forma de meseta), ya sea modificando el ancho del pulso o duty cycle (modulación de ancho de pulso) o el tiempo entre pulso y pulso (modulación por frecuencia de pulso). 26 Salta Argentina 2013


Esto significa que la frecuencia (número de ciclos útiles por unidad de tiempo) siempre es la misma. Por ejemplo, si tenemos durante un segundo la señal a 5 voltios y durante otro segundo a 0 voltios, el nivel medio en 2 segundos habrá sido de 2.5 V exactos. Si utilizamos una señal, por ejemplo, que esté al 40% del nivel alto (5 vol), tendremos un nivel medio de 2.0V (0.40V*5). En definitiva esto hará que –si tenemos un led conectado al pin de salida del PIC- la intensidad de su luz aumente o disminuya. La instrucción anlogWrite hace esto a través de los dos valores que deben definirse separados por una coma y encerrados entre paréntesis: analogWrite(pin PWM, DutyCycle) Recordar que el PIC tiene las patitas 12 y 13 como pines PWM (las patitas 12 y 13 corresponden a los pines 11 y 12 respectivamente, ver esquemático de la página 6) y los valores de Duty Cycle pueden variar entre 0 y 1023 (0= sin señal y 1023=máximo valor de la señal). En la siguiente tabla se ejemplifican algunos valores: Instrucción

Duty Cycle

Pin de salida PWM

% de la señal

Valor de la señal de salida

analogWrite(11, 64)

256

11

25% de 5 vol.

1.25 vol.

analogWrite(11, 127)

512

11

50% de 5 vol.

2.5 vol.

analogWrite(11, 191)

768

11

75% de 5 vol.

3.75 vol.

Los efectos de ambas instrucciones las veremos en el siguiente circuito de aplicación: Materiales:  Un potenciómetro de más de 47 k Ohm.  Un led Conexión: Del potenciómetro: ubicado con el cabo regulador hacia arriba  El conector de la izquierda se conecta a 5 vol.  El conector del medio al pin 13 de Pingüino  El conector derecho a tierra o negativo Del Led:  La patita larga al pin 11 del PIC  La patita corta a tierra o negativo 27 Salta Argentina 2013


El siguiente código lee el valor que el potenciómetro introduce por el pin 13 del PIC, para utilizar dicho valor en el tiempo de encendido y apagado de un led conectado al pin 11. Nótese que si el pin 13 es usado como de ingreso de datos analógicos no necesita ser definido en el void setup. El resultado es un led que modifica su velocidad de parpadeo según se modifiquen los valores introducidos a través del giro del cabo del potenciómetro. #define LED 11 #define POT 13 int val = 0;

// Al pin 11 lo llamamos LED // Al pin 13 lo llamamos POT

void setup() { pinMode(LED, OUTPUT); } void loop() { val = analogRead(POT); digitalWrite(LED, HIGH); delay(val); digitalWrite(LED, LOW); delay(val); }

El siguiente código permite cambiar la intensidad de la luz emitida por un diodo Led conectado al pin 11 (recordemos que es un pin de salida PWM) según se varíe la señal de entrada por el pin 13 a través del giro del cabo del potenciómetro. Nótese que en el void setup no se define nada ya que las entradas (INPUT) como las salidas (OUTPUT) analógicas no necesitan definirse. #define LED 11 #define LDR 13 int valu = 0; void setup() { } void loop() { valu = analogRead(LDR); valu = valu/4;//Se divide por 4 el valor entregado por el potenciómetro para que no sea tan alto analogWrite(LED, valu); delay(10); }



::: ¡Calentando Motores! En esta sección vamos a incursionar en el mundo de los motorcitos de corriente continua de 5 vol. Te vamos a mostrar dónde los puedes conseguir y la forma de conectarlo a la placa Pingüino. En Busca De Los Motores: Los motorcitos de cc o dc (corriente continua - los que andan si los conectamos con una pila) se los pueden extraer de una lectora de CD/DVD en desuso. Como una imagen vale más que mil palabras, veamos la secuencia de imágenes para poder extraerlos:

1

2

3

4

5

6

7

8



9

10

11

12

13

14

15

16

17



Conectando el motor a Pingüino: no se puede conectar los dos cables del motorcito directamente a la placa Pingüino ya que es necesario proteger la placa contra posibles picos de corriente inversa cuando se activa o desactiva el motor9. Para poder proteger la placa vamos a conectar el motor a un chip llamado L293D

El L293D no solo nos permite proteger el circuito sino también controlar el sentido del giro del motor y también –combinado con las salidas PWM del Pingüino- la variación de su velocidad. El circuito de conexión es el siguiente:

Pin PWM de Pingüino Pin digital de Pingüino (13)

Pin digital de Pingüino (14)

Como se ve en el esquemático anterior se pueden conectar dos motorcitos, copiando en el lado derecho las conexiones detalladas en el lado izquierdo. Para que te resulte más fácil su conexión presentamos las imágenes -desarrolladas en Fritzing- del cableado desde Pingüino al L293D y al motor:

9

Cuando un motor continúa girando (debido a la inercia) después de ser apagado se convierte en un generador de corriente. Esta corriente generada por el motor puede dañar la placa electrónica, al retornar a la placa Pingüino. 31 Salta Argentina 2013


Referencia: Cable marrón => del pin 11 del Pingüino al pin 1 del L293D Cable gris

=> del pin 13 del Pingüino al pin 2 del L293D

Cable naranja => del pin 14 del Pingüino al pin 7 del L293D Cable verde => del pin 3 del L293D al motorcito Cable amarillo => del pin 6 del L293D al motorcito

L293D

Código para Pingüino: void setup(){ pinMode(13,OUTPUT); pinMode(14,OUTPUT); digitalWrite(13,LOW); digitalWrite(14,LOW); } void loop(){ //giro en un sentido digitalWrite(13,HIGH); digitalWrite(14,LOW); delay(2000); //giro en el otro sentido digitalWrite(13,LOW); digitalWrite(14,HIGH); delay(2000); //para parar el giro motor digitalWrite(13,LOW); digitalWrite(14,LOW); delay(2000); } 32 Salta Argentina 2013


Explicación del código: En primer lugar definimos a los pines 13 y 14 como pines de salida y lo ponemos en cero. Para manejar el sentido de giro y la parada del motor debemos tener en cuenta la siguiente tabla:

Pin 13

Pin 14

Motor

LOW

LOW

PARADA

HIGH

LOW

GIRO EN UN SENTIDO

LOW

HIGH

GIRO EN OTRO SENTIDO

Para manejar además la velocidad de giro debemos manejar los valores del pin PWM; a tal efecto presentamos un ejemplo de código: #define motor 11 // Recordar que los únicos pines PWM son el 11 y el 12 void setup() { //Recordar que los pines analógicos no necesitan ser definidos } void loop(){ unsigned int a; for (a=0;a<1023;a++) { analogWrite(motor,a); delay(1); } for (a=1023;a>0;a--) { analogWrite(motor,a); delay(100); } }

Explicación del Código: Definimos al pin 11 con el nombre motor, y luego variamos de 0 a 1023 los parámetros de la instrucción analogWrite a través de un ciclo for. El motor debe empezar a aumentar su velocidad de giro hasta alcanzar el valor máximo. Allí se espera 1 milisegundos (casi nada) y se comienza a decrementar la velocidad de giro (de 1023 a 0). Este ciclo se repite indefinidamente hasta que desconectemos Pingüino del puerto USB. Vamos por más!!! Te proponemos combinar los dos códigos a los efectos de poder hacer que el motor varíe la velocidad y el sentido de giro. Esto puede complementarse con el uso de pulsadores que según se presionen tengamos distintas velocidades y distinto sentido de giro.



:::: Pongamos Blanco sobre Negro o Negro sobre Blanco Es posible hacer que Pingüino “distinga” entre una superficie clara/blanca (capaz de refractar la luz) y una superficie obscura/negra (incapaz de refractar la luz). Para ello tenemos que echar mano a un componente llamado foto diodo emisor/receptor; el sensor CNY70 que es uno de los sensores más empleados dada su economía y sus variadas aplicaciones prácticas. Habitualmente se lo usa si se desea que un robot móvil siga un camino marcado por una raya en el suelo; el CNY70 enviará al microcontrolador la información necesaria para que sepa si está desplazandose sobre la raya o no. El tratamiento de dicha información por Pingüino originará los comandos adecuados hacia las ruedas motrices para continuar sobre la raya que hace de guía. A continuación se presenta cómo funciona el CNY7010 y el circuito para conectarlo a Pingüino:

Diodo IR Fototransistor A: Ánodo E: Emisor K: Cátodo C: Colector

10

Cuando la luz del emisor infrarrojo impacta sobre la base del fototransistor se conduce una corriente entre el Colector y el Emisor que produce la señal de salida. La salida de este circuito es analógica y viene determinada por la cantidad de luz reflejada.



Conectamos un led al pin 7 de Pingüino y el cable blanco que sale del circuito del CNY70 lo conectamos al pin 13 de Pingüino, tal como lo muestra el esquema:

Una vez que se tiene todo conectado procedemos a grabar en el Pingüino el código para probar la detección de superficies claras y obscuras. Para ello cargamos el IDE de Pingüino X2 y copiamos el siguiente código: #define ledR 7 #define CNY70 13 int rojo=0; void setup(){ pinMode(ledR,OUTPUT); digitalWrite(ledR,LOW); } void loop() { rojo = (5.0 * analogRead(CNY70) ) / 1024; if (rojo < 1) { digitalWrite(ledR,LOW); } if (rojo > 2.0) { digitalWrite(ledR,HIGH); } delay(1000); }

Como vemos el código es muy sencillo y lo que hace es: 1. “Bautizar” (definir) al pin 7 con el nombre ledR, ya que en dicho pin vamos a conectar la patita larga del led rojo. Al pin 13 con el nombre de CNY70 ya que en ese pin vamos a leer la información que mande el circuito del CNY70 (por el cablecito blanco). Inicializar una variable llamada rojo con el valor cero. 2. En el void setup definimos al pin 7 (ledR) como salida y lo pone en estado bajo (el led apagado). Recordar que los pines analógicos no hace falta definirlos como entrada o salida. 3. En el void loop tenemos una fórmula que dice lo siguiente: al valor leído del CNY70 transformarlo en un valor que represente un porcentaje en relación a los 5 vol (que es el 100%) y 1024 (que representa el máximo valor de la señal que se lee en el pin analógico). Este valor se almacena en la variable rojo. 35 Salta Argentina 2013


4. 5.

Luego se pregunta si rojo es menor que 1, esto quiere decir si sobre el CNY70 hay una superficie blanca, el led rojo permanece apagado o se apaga si estaba encendido. Si rojo es mayor a 2 quiere decir que sobre el CNY70 hay una superficie rojo y el led rojo será encendido si estaba apagado o continuará prendido si ya lo estaba.

De esta manera le hemos enseñado a Pingüino a distinguir entre superficies blancas y superficies negras.

:::: Fuentes de información consultada       

Henry Laredo, http://microembebidos.wordpress.com Raúl Alvarez Torrico, http://www.tecbolivia.com Sitio oficial, http://www.pinguino.cc/ Yeison Cardona, http://yeisoneng2.blogspot.com.ar http://www.crya.com.mx/manuales/atcryabot1.pdf Ingenio Sólido S.A.S., http://www.ingeniosolido.com/blog/ De la Cruz, Julio, http://micropinguino.blogspot.com.ar/



:::: Anexo I: Sintaxis y Estructuras del Lenguaje de Programación Pingüino IDE





:::: Anexo II: Instalación de los Drivers de Pingüino en Windows 811 Pasos 1. Descargar el controlador de Pingüino de este enlace: https://sites.google.com/site/camachomedia/home/archivos/controlador%20pinguino.zip?attredirects=0&d=1

2. Presionar la tecla que tiene el símbolo de windows y 'R' de forma simultánea. 3. Copiar en en el cuadro de texto de la ventana de ejecutar el comando entre comillas "shutdown.exe /r /o /f /t 00" y a continuación pulsa"Aceptar".

4.

Selecciona la opción "Solucionar Problemas"

5.

Selecciona "Opciones Avanzadas"

6.

Selecciona "Configuración de Inicio" y pulsa "Reiniciar".

11

Tutorial extraído de la página http://micropinguino.blogspot.com.ar/ 39 Salta Argentina 2013


7. Una vez se reinicie el sistema aparecerá un menú donde se pueden elegir diferentes opciones como: Habilitar Depuración, Habilitar el registro de arranque, Habilitar modo seguro, etc. Hay que elegir la opción 7 "Deshabilitar el uso obligatorio de controladores firmados".

8. 9.

Conectar la tarjeta pingüino y ejecutar el asistente de instalación del controlador de pingüino. Verificar que está instalando en dispositivos e impresoras.


Manual Pinguino v 1.1.pdf

Recommend Documents