Академический Документы
Профессиональный Документы
Культура Документы
Introduccin
Arduino es una plataforma de prototipado popular, de cdigo abierto que hace que sea fcil para las personas con
poca experiencia en la electrnica para entrar en el mundo de los microcontroladores y programacin embebida. El
entorno Arduino consiste en un entorno de cdigo abierto de desarrollo integrado (IDE) y el compilador, libreras de
software, y placas de hardware programable basado en el ATmega168 potente y microcontroladores
Atmega328. Debido a que nuestro Orangutn SV-xx8 , orangutn LV-168 , y de beb orangutn B controladores de
robots usan estos mismos microcontroladores, tienen un alto grado de solapamiento con Arduino. Por tanto,
nuestros controladores de robots orangutn pueden ser una alternativa atractiva a hardware oficial de Arduino para
aquellos que ya estn familiarizados con el entorno Arduino, y el medio ambiente pueden ser una alternativa
amigable para los principiantes a AVR Studio para aquellos que buscan para empezar con los orangutanes.
Nota: El robot 3pi Pololu tiene efectivamente un orangutn SV-xx8 como su ncleo, por lo que esta gua y las
bibliotecas orangutn Arduino aplica al 3pi tambin. Para obtener ms informacin sobre el 3pi, consulte la gua
del usuario 3pi .
La oferta orangutanes y robot 3pi hardware que Arduinos no lo hacen, como controladores de motor doble de a
bordo integrado. Esto los hace muy adecuados para aplicaciones que implican el control de pequeas y medianas
robots. El orangutn SV-xx8, orangutn LV-168, y el robot 3pi tambin han integrado pulsadores, un zumbador
piezo, y un LCD extrable, todas las cuales son caractersticas adicionales que no se encuentran en Arduinos
oficiales.
Con algunos cambios menores en los archivos de configuracin de software de Arduino, se hace posible programar
nuestros orangutanes y robot 3pi usando el Arduino IDE y bibliotecas. Esta gua le guiar a travs del proceso de
reconfiguracin de la Arduino IDE, y ofrecer una serie de bibliotecas personalizadas que harn ms fcil para hacer
interfaz con todo el hardware a bordo del orangutn / de 3pi.
Una diferencia clave entre las tablas estndar de Arduino y los controladores de robots orangutn es que la mayora
vienen con Arduino USB a serial adaptadores integrados, que permiten conectar a su computadora y el programa a
travs de gestores de arranque pre-cargado, mientras que los orangutanes carecen integrado USB- a serie
adaptadores. Como tal, para el Orangutn SV-xx8, LV-168 y el robot 3pi, le recomendamos que programe los
orangutanes o robot 3pi usando un ISP AVR (denominado ICSP en el mundo Arduino) programador como
nuestro USB AVR Programmer . Al adoptar este enfoque y dejando fuera el gestor de arranque, se obtiene un 2 KB
extra de espacio del programa. Tambin evitar el retraso del gestor de arranque al encender o reiniciar el tablero.
Nota: Este documento se aplica slo al robot 3pi y Orangutn SV-xx8 , orangutn LV-168 , y el beb orangutn
B controladores de robots. Para simplificar, los tres ltimos dispositivos se denominarn a partir de ahora
como "orangutanes" , a menos que una distincin debe hacerse entre los modelos Orangutn especficos. Este
documento hacenosolicitar a la originalorangutn , orangutn del beb , orangutn X2 , o SVP Orangutn de
control del robot.
2. ATmega168 Mapping / 328-Pin Arduino
En nuestra documentacin estndar orangutn y 3pi, utilizamos la misma convencin que Atmel utiliza en su
ATmega168 / 328 hoja de datos, en referencia a las patillas de sus puertos asociados. Por ejemplo, el pin PD7 es el
pin 7 del puerto D. Se utiliza esta convencin, ya que cada puerto es controlado por sus propios registros AVR, y los
bits de estos registros corresponden a los pines individuales.
El Arduino asla al usuario de este nivel de detalle, en referencia a los pines de E / S como pines digitales 0-13 y
entradas analgicas 0 - 7. Tenga en cuenta que esta terminologa puede ser un poco engaoso ya que las entradas
analgicas 0-5 tambin se puede utilizar como yo digital de propsito general pines E / S (referido como pines
digitales 14-19).
Usted puede visitar http://www.arduino.cc/en/Hacking/PinMapping168 para ver exactamente cmo los mega168 /
328 pines se asignan a los pines de Arduino. Tenga en cuenta que esta pgina muestra un chip encapsulado DIP de
28 pines, mientras que los orangutanes llevan pequeos paquetes de 32 pines del FML que contienen dos entradas
analgicas dedicadas adicionales: ADC6 y ADC7. En el entorno de Arduino, estas patillas se convierten en entradas
analgicas Arduino 6 y 7, respectivamente. El diagrama siguiente proviene de la pgina vinculada anteriormente:
Arduino Pin
mega168 Pin
digital de E / S (x8)
pines digitales 0 y 1
entradas analgicas 0-5
PD0, PD1,
PC0 - PC5
pines digitales 5 y 6
PD5 y PD6
pines digitales 3 y 11
PD3 y PB3
pin digital 1
PD1
pin digital 7
PD7
entradas digitales 9, 12 y 13
zumbador
pin digital 10
PB2
pines digitales 2, 8 y 4
entrada analgica 7
(a travs de puente)
ADC7
entrada analgica 6
(a travs de puente SMT)
ADC6
pulsador de rearme
reajustar
PC6
pines digitales 0 y 1
PD0 y PD1
entradas analgicas 4 y 5
PC4 y PC5
SPI
Funcin orangutn
pin digital 0
E / S digital
pin digital 1
E / S digital
pin digital 2
De control LCD de
lnea RS
pin digital 3
pin digital 4
Lnea de control
LCD E
pin digital 5
pin digital 6
pin digital 7
pin digital 8
LCD lnea de
control R / W
pin digital 9
pin digital 10
zumbador
pin digital 11
Lnea de control M2
pin digital 12
pin digital 13
entrada
analgica 0
entrada analgica y
E / S digital
entrada
analgica 1
entrada analgica y
E / S digital
entrada
analgica 2
entrada analgica y
E / S digital
entrada
analgica 3
entrada analgica y
E / S digital
entrada
analgica 4
entrada analgica y
E / S digital
entrada
analgica 5
entrada analgica y
E / S digital
entrada
analgica 6
SMT puenteado a sensor de temperatura (slo LV-168) SMT puenteado de supervisar voltaje de la
de entrada analgica
batera (SV-168 solamente) canal de entrada ADC 6 (ADC6)
dedicada
entrada
analgica 7
reajustar
pulsador de rearme
Arduino Pin
mega168 Pin
digital de E / S (x16)
pines digitales 5 y 6
PD5 y PD6
pines digitales 3 y 11
PD3 y PB3
pin digital 1
PD1
entrada analgica 7
ADC7
REINICIO
reajustar
PC6
pines digitales 0 y 1
PD0 y PD1
entradas analgicas 4 y 5
PC4 y PC5
SPI
pines digitales 9 y 10
PB1 y PB2
Funcin orangutn
pin digital 0
E / S digital
pin digital 1
E / S digital
pin digital 2
E / S digital
pin digital 3
Lnea de control M2
pin digital 4
E / S digital
pin digital 5
Lnea de control M1
pin digital 6
Lnea de control M1
pin digital 7
E / S digital
pin digital 8
E / S digital
pin digital 9
E / S digital
pin digital 10
E / S digital
pin digital 11
Lnea de control M2
pin digital 12
E / S digital
pin digital 13
E / S digital
entrada analgica 0
entrada analgica 1
entrada analgica 2
entrada analgica 3
entrada analgica 4
entrada analgica 5
entrada analgica 6
entrada analgica 7
reajustar
REINICIO pin
Arduino Pin
mega168 Pin
pines digitales 0, 1, 19
pines digitales 5 y 6
PD5 y PD6
pines digitales 3 y 11
PD3 y PB3
PC0 - PC4
pin digital 1
PD1
pin digital 7
PD7
entradas digitales 9, 12 y 13
zumbador
pin digital 10
PB2
pines digitales 2, 8 y 4
pin digital 19
(a travs del puente)
PC5
entrada analgica 7
(a travs de puente)
ADC7
entrada analgica 6
(a travs de puente)
ADC6
pulsador de rearme
reajustar
PC6
pines digitales 0 y 1
PD0 y PD1
I2C / TWI
SPI
Funcin orangutn
pin digital 0
Me digital gratuito / S
pin digital 1
Me digital gratuito / S
pin digital 2
pin digital 3
Lnea de control M2
pin digital 4
pin digital 5
Lnea de control M1
pin digital 6
Lnea de control M1
pin digital 7
pin digital 8
pin digital 9
pin digital 10
zumbador
pin digital 11
Lnea de control M2
pin digital 12
pulsador de usuario (pulsando tira pin baja) Precaucin: tambin una lnea de
programacin ISP
pulsador de usuario (pulsando tira pin baja) Precaucin: tambin una lnea de
programacin ISP
pin digital 13
pin digital 14
Sensor de reflectancia de QTR- (Unidad de alta para el 10 de nosotros, y luego esperar a la entrada de lnea para ir bajo)
RC
sensor marcado PC0 (sensor ms a la izquierda)
pin digital 15
Sensor de reflectancia de QTR- (Unidad de alta para el 10 de nosotros, y luego esperar a la entrada de lnea para ir bajo)
RC
sensor marcado PC1
pin digital 16
Sensor de reflectancia de QTR- (Unidad de alta para el 10 de nosotros, y luego esperar a la entrada de lnea para ir bajo)
RC
sensor marcado PC2 (sensor central)
pin digital 17
Sensor de reflectancia de QTR- (Unidad de alta para el 10 de nosotros, y luego esperar a la entrada de lnea para ir bajo)
RC
sensor marcado PC3
pin digital 18
Sensor de reflectancia de QTR- (Unidad de alta para el 10 de nosotros, y luego esperar a la entrada de lnea para ir bajo)
RC
sensor marcado PC4 (sensor ms a la derecha)
pin digital 19
entrada analgica
de entrada analgica dedicada
6
entrada analgica
de entrada analgica dedicada
7
reajustar
pulsador de rearme
Las instrucciones de configuracin de esta seccin explican cmo alterar el Arduino IDE para que programe su
orangutn o un robot 3pi usando la configuracin correcta, utilizando un programador AVR ISP que soporte el
protocolo avrispv2 (como el programador AVR Pololu USB ) o un Arduino bootloader.
1.
Ir a http://www.arduino.cc/en/Main/Software y descargar el software ms reciente para su plataforma Arduino
(Arduino 1.0.1 partir de este escrito).
2.
Agregue lo siguiente al final de la boards.txt archivo en el arduino-1.0.1 / hardware / Arduino directorio:
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
################################################## ############
orangutan48pgm.name = Pololu Orangutn del beb B-48 a travs del programador
orangutan48pgm.upload.using = avrispv2
orangutan48pgm.upload.maximum_size = 4,096
orangutan48pgm.build.mcu = ATmega48
orangutan48pgm.build.f_cpu = 20000000L
orangutan48pgm.build.core = arduino
orangutan48pgm.build.variant = estndar
################################################## ############
orangutan168pgm.name = Pololu Orangutn o robot 3pi w / ATmega168 va programador
orangutan168pgm.upload.using = avrispv2
orangutan168pgm.upload.maximum_size = 16384
orangutan168pgm.build.mcu = atmega168
orangutan168pgm.build.f_cpu = 20000000L
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
orangutan168pgm.build.core = arduino
orangutan168pgm.build.variant = estndar
################################################## ############
orangutan328pgm.name = Pololu Orangutn o robot 3pi w / ATmega328P travs Programador
orangutan328pgm.upload.using = avrispv2
orangutan328pgm.upload.maximum_size = 32768
orangutan328pgm.build.mcu = ATmega328P
orangutan328pgm.build.f_cpu = 20000000L
orangutan328pgm.build.core = arduino
orangutan328pgm.build.variant = estndar
Esto agregar tres opciones para la Herramientas> Junta men del IDE de Arduino.
Si prefiere utilizar un programador diferente que no admite el protocolo avrispv2 , a continuacin, cambiar
los upload.using lneas para que coincida con el nombre de su programador / protocolo, y omita el paso 3 (si el
programador ya est definido por el entorno Arduino) o aadir la entrada correspondiente para su programador
en programmers.txt .
Estas dos entradas siguientes son opcionales, pero le permiten usar un gestor de arranque Arduino en lugar de un
programador externo:
################################################## ############
orangutan168.name = Pololu Orangutn o robot 3pi w / ATmega168 a travs del cargador de arranque
orangutan168.upload.protocol = arduino
orangutan168.upload.maximum_size = 15872
orangutan168.upload.speed = 144000
orangutan168.bootloader.low_fuses = 0xF6
orangutan168.bootloader.high_fuses = 0xdd
orangutan168.bootloader.extended_fuses = 0x04
orangutan168.bootloader.path = optiboot
orangutan168.bootloader.file = optiboot_atmega168.hex
orangutan168.bootloader.unlock_bits = 0x3F
orangutan168.bootloader.lock_bits = 0x0F
orangutan168.build.mcu = atmega168
orangutan168.build.f_cpu = 20000000L
orangutan168.build.core = arduino
orangutan168.build.variant = estndar
################################################## ############
orangutan328.name = Pololu Orangutn o robot 3pi w / ATmega328P a travs del cargador de arranque
orangutan328.upload.protocol = arduino
orangutan328.upload.maximum_size = 32256
orangutan328.upload.speed = 144000
orangutan328.bootloader.low_fuses = 0xF6
orangutan328.bootloader.high_fuses = 0xDE
orangutan328.bootloader.extended_fuses = 0x05
orangutan328.bootloader.path = optiboot
orangutan328.bootloader.file = optiboot_atmega328.hex
orangutan328.bootloader.unlock_bits = 0x3F
orangutan328.bootloader.lock_bits = 0x0F
orangutan328.build.mcu = ATmega328P
orangutan328.build.f_cpu = 20000000L
orangutan328.build.core = arduino
orangutan328.build.variant = estndar
Si desea utilizar el gestor de arranque , usted todava tendr que utilizar un programador AVR cargar
inicialmente el gestor de arranque en su orangutn o 3pi, y usted tambin tendr que obtener un adaptador serie
USB-a-o RS-232-a-TTL adaptador de serie a travs del cual el software Arduino puede hablar con el bootloader
de Arduino en su dispositivo. El Pololu USB AVR programador puede servir como su programador AVR ISP y de
USB a serial adaptador.
Tenga en cuenta que tendr que o bien restablecer el orangutn / 3pi manualmente cuando se programa con el
gestor de arranque o modificar el hardware para permitir que la seal de control DTR a auto-reset del
microcontrolador.
Tenga en cuenta que el beb orangutn B- 48 tiene un microcontrolador ATmega48, que carece de una seccin
del gestor de arranque, es decir, la versin B-48 slo se puede programar utilizando un ICSP.
37.
Si est utilizando un programador AVR ISP como nuestro USB AVR programador, aadir lo siguiente al final de
la programmers.txt archivo en el arduino-1.0.1 / hardware / Arduino directorio:
38.
39.
avrispv2.communication = serial
avrispv2.protocol = avrispv2
Esto permitir que el Arduino IDE para programar con el protocolo avrispv2 utilizado por nuestro USB AVR
Programmer.
. 4 Utilizando el Arduino IDE: un LED parpadeante
Ahora es el momento de dar el Arduino IDE para dar una vuelta. Nuestro primer objetivo ser cargar un boceto LED
parpadeante sencillo (programa de Arduino) en nuestra orangutn o 3pi.
Abra el Arduino IDE y crear el siguiente bosquejo:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/ *
* Blink
*
* El ejemplo bsico Arduino, modificado para trabajar para los orangutanes.
* Se enciende un LED durante un segundo, y luego se apaga durante un segundo,
* y as sucesivamente ... Nos usar el pin 1 porque orangutanes tienen un LED
* en PD1, que corresponde a Arduino pin 1.
*
* http://www.arduino.cc/en/Tutorial/Blink
* /
int ledPin = 1;
void setup ()
{
pinMode (ledPin, OUTPUT);
}
void loop ()
{
18
19
20
21
22
23
24
25
// establece el LED el
// espera un segundo
// establece el LED apagado
// espera un segundo
bosquejo
Seleccione el programador:
Si est utilizando un Pololu USB AVR programador, seleccione "AVR ISP v2" en el men Programador. De lo
contrario, consulte la documentacin de su programador para averiguar qu opcin para seleccionar.
Seleccione el puerto serie del programador:
Si est utilizando un Pololu USB AVR programador, asegrese de que ha instalado los controladores adecuados
(vase la gua del usuario del programador ) y conectarlo a su ordenador. Una vez hecho esto, usted debera ser
capaz de ver su puerto COM aparece en las Herramientas> Serial Port men. Si usted no sabe qu puerto COM su
programador est activada, se puede determinar esto crianza de administrador de dispositivos de su equipo y la
ampliacin de los Puertos (COM & LPT) lista. Para abrir el administrador de dispositivos, haga clic en "Mi PC" y
seleccione Administrar , haga clic en elAdministrador de dispositivos de opcin que aparece en el lado
izquierdo, en Herramientas del sistema . Busque el puerto que dice "Pololu USB AVR Programmer Puerto de
programacin".
Si est utilizando un verdadero programador USB (es decir, uno que no emula un puerto serie), que no es necesario
para seleccionar un puerto serie.
Programa tu o 3pi Orangutn con el boceto:
Conecte el programador con el orangutn o 3pi a travs de su jefe de la ISP de seis pines, asegurndose de que el
pin 1 de las lneas programador hasta con el pin 1 del conector de programacin del objetivo. El Orangutn SV-xx8,
orangutn LV-168, y 3pi cada uno tiene una cabecera envuelta que har cumplir la orientacin pin correcto, pero el
beb orangutn B no lo hace. Pin 1 del orangutn del beb est marcado por una flecha de cobre en el PCB y el pin
1 en nuestro USB AVR Programmer est marcada por un tringulo de plstico en relieve en el conector IDC.
Con el programador conectado a su ordenador y su orangutn o 3pi, haga clic en el Subir al Consejo Directivo del
I / O botn (en el crculo en la siguiente captura de pantalla) o pulse Ctrl + T para compilar el boceto y lo cargue en el
dispositivo de destino. La barra de estado en la parte inferior de la ventana dir "Subida a la I / O Board ...", mientras
que la carga est en curso y se leer "uploading Done." Cuando la carga est completa. Si todo ha funcionado
correctamente ahora debera ver usuario roja del blanco LED parpadeante y apaga cada segundo. Tenga en cuenta
que si est utilizando un 3pi y an no ha soldado en los LED opcionales a travs de hoyos, usted tendr que mirar
en la parte inferior del robot para ver el parpadeo del LED.
Nota: Debido a que los orangutanes no fueron diseados como placas Arduino oficiales, no todo el cdigo de la
biblioteca Arduino existente ser directamente compatible con ellos. Por ejemplo, ciertas funciones Arduino
como delayMicroseconds () y pulseIn () estn diseados para funcionar a 16 MHz y por lo tanto su
comportamiento se ve alterada por el reloj del orangutn de 20 MHz. En otros casos, las bibliotecas-orangutn
especfica pueden entrar en conflicto con las libreras de Arduino existentes, si los dos estn compitiendo por los
mismos perifricos de hardware mega168 (por ejemplo, dos bibliotecas que intentan utilizar Timer1 de diferentes
maneras no ser compatible).
Visin de conjunto
En esta seccin se ofrece una serie de bibliotecas-orangutn especfica que le permiten hacer interfaz con facilidad
con el hardware / 3pi orangutn desde el entorno Arduino. Es importante tener en cuenta que el beb orangutn B
es un subconjunto de hardware de la mayor orangutn SV-xx8 y LV-168, y estos orangutanes son (casi) un
subconjunto de hardware del robot 3pi. Lo que esto significa es que cualquier cdigo de la biblioteca que funciona en
el beb orangutn B tambin trabajar en el robot orangutn y 3pi, y (casi) cualquier cdigo de la biblioteca que
funciona en el orangutn tambin trabajar en el 3pi. Las siguientes subsecciones contienen documentacin
detallada de cada biblioteca orangutn Arduino. Todas las bibliotecas que se aplican al orangutn va a trabajar
para el hardware correspondiente en el robot 3pi .
La nica clase biblioteca para lo cual es significativo tener varias instancias es PololuQTRSensors. Todas las otras
clases consisten enteramente en mtodos estticos, por lo que no tiene sentido para crear instancias de ellos varias
veces. Desde la versin 101 215, las versiones C de las funciones de la biblioteca tambin estn disponibles para su
uso en sus programas de Arduino. Esto significa que hay tres formas posibles para que usted pueda llamar a los
mtodos de la biblioteca:
?
1
2
unsigned int x;
3
4
5
6
7
8
9
10
11
Las nicas clases de biblioteca que necesitan ser inicializado explcitamente antes de que se utilizan son
PololuQTRSensors y Pololu3pi, ya que estos objetos se inicializan con los parmetros especificados por el
usuario. Ninguno de los restantes objetos de la biblioteca Orangutn debe inicializar explcitamente en
su configuracin () funcin que la inicializacin se realiza automticamente cuando sea necesario.
Instrucciones de descarga
Los Pololu Arduino Bibliotecas estn dentro de un archivo comprimido, que se puede descargar desde el siguiente
enlace:
Pololu Arduino Bibliotecas versin 120914 (107k postal) , probado con Arduino 1.0.1
Si est utilizando una versin anterior del entorno Arduino, le recomendamos que actualice a Arduino 1.0.1 y utilizar
la ltima versin de los Pololu Arduino Bibliotecas. Sin embargo, las versiones anteriores de las bibliotecas se
proporcionan para garantizar la compatibilidad con los entornos Arduino mayores:
Nota: Si actualmente tiene una versin ms antigua de nuestras Pololu Arduino Bibliotecas, el primer paso debe
ser el de eliminar todos los directorios Orangutan___ y Pololu___ desde el directorio de bibliotecas. Si no realiza
este paso, la versin ms reciente de las bibliotecas no puede ser compilado.
Descomprimir el archivo y mover cada uno de los directorios Orangutan___ y Pololu___ dentro de la carpetalibpololu avr en la bibliotecas subdirectorio dentro de su cuaderno de dibujo Arduino. Usted puede ver su ubicacin
cuaderno de dibujo seleccionando Archivo> Preferencias en el entorno Arduino; si no hay ya una carpeta
"bibliotecas" en ese lugar, usted debe crear usted mismo. La captura de pantalla muestra donde los directorios de
libreras deben aparecer una vez que se extraen:
Despus de instalar la biblioteca, reinicie el entorno de Arduino para que pueda encontrar las libreras y sus
ejemplos. Ahora debera ser capaz de utilizar estas bibliotecas en sus bocetos. Por ejemplo, si desea utilizar la
biblioteca OrangutanBuzzer, puede seleccionar Sketch> Importar biblioteca> OrangutanBuzzer desde tu Arduino
IDE, o simplemente puede escribir #include <OrangutanBuzzer.h> en la parte superior de su dibujo. Tenga en
cuenta que puede que tenga que reiniciar el Arduino IDE antes de ver las nuevas bibliotecas. Si usted no necesita la
funcionalidad de una biblioteca especfica, debe dejarlo fuera de su dibujo (simplemente elimine el # include lnea
asociada a ella desde la parte superior de su esquema si ya has agregado l). Bibliotecas incluidas ocuparn
espacio del programa, incluso si estos no se utilicen en su programa.
Ejemplos de uso
La mayora de las bibliotecas cuentan con al menos un ejemplo boceto que muestra cmo se puede utilizar la
biblioteca. Para cargar un boceto ejemplo, abra el Arduino IDE y vaya a Archivo> Ejemplos> Orangutan____ .
La biblioteca Pololu3pi viene con varios bocetos de seguimiento de lneas y ejemplo laberinto de resolucin
detallados que se pueden cargar mediante Archivo> Ejemplos> Pololu3pi .
5.a OrangutanAnalog - Analog Biblioteca entrada
Visin de conjunto
Esta biblioteca proporciona un conjunto de mtodos que se pueden utilizar para leer las entradas de tensin
analgicas, as como las funciones especficamente diseadas para leer el valor del potencimetro de ajuste (en
el robot 3pi , Orangutn SV-xx8 , orangutn LV-168 , y el beb orangutn B ), el nivel de voltaje de la batera en
milivoltios (robot 3pi, SV-xx8), y el valor del sensor de temperatura en dcimas de grado F o C (en el orangutn slo
LV-168). Esta biblioteca le da ms control de las funciones de entrada analgica Arduino existentes.
No es necesario para inicializar el objeto OrangutanAnalog antes de su uso. Toda la inicializacin se realiza
automticamente cuando sea necesario.
Todos los mtodos de esta clase son estticos; nunca se debe tener ms de una instancia de un objeto
OrangutanAnalog en su dibujo.
Mtodos OrangutanAnalog
La documentacin completa de los mtodos de esta biblioteca se puede encontrar en la seccin 2 de la Pololu AVR
Library Command Reference .
Ejemplos de uso
Esta biblioteca cuenta con dos bocetos de ejemplo que se pueden cargar por ir a Archivo> Ejemplos>
OrangutanAnalog . Los ejemplos de bocetos que vienen con el OrangutanMotors biblioteca tambin hacen uso
limitado de esta biblioteca.
1. OrangutanAnalogExample
Muestra cmo puede utilizar los mtodos en esta biblioteca para leer el voltaje analgico del potencimetro de
ajuste en el fondo, mientras que el resto de su cdigo se ejecuta. Si el ADC es libre, el programa se inicia una
conversin en el potencimetro de entrada analgica (canal 7), y luego se procede a ejecutar el resto del cdigo en
bucle (), mientras que las obras de hardware ADC. Sondeo del mtodo isConverting () permite que el programa para
determinar cundo se completa la conversin y para actualizar su nocin del valor trimpot en consecuencia. Se da
retroalimentacin a travs del LED rojo de usuario, cuyo brillo se hace a escala con la posicin trimpot.
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <OrangutanLEDs.h>
#include <OrangutanAnalog.h>
/ *
* OrangutanAnalogExample para el 3pi, Orangutn SV-xx8,
* orangutn LV-168, o Orangutn del beb B
*
* Este bosquejo utiliza la biblioteca OrangutanAnalog para leer la salida de tensin
* del potencimetro de ajuste en el fondo mientras que el resto del bucle principal ejecuta.
* El LED destella de manera que su brillo aparece proporcional a la
* trimpot
leds;
analgica OrangutanAnalog;
unsigned int suma;
sin firmar int ; avg
sin firmar Char muestras;
void setup ()
{
analog.setMode (MODE_8_BIT);
suma = 0;
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
muestras = 0;
avg = 0;
analog.startConversion (ajuste);
}
void loop ()
// ejecutar una y otra vez
{
si (! analog.isConverting ())
// si la conversin es hecho ...
{
suma + = analog.conversionResult (); // obtener resultar
analog.startConversion (ajuste);
// y comenzar la prxima conversin
si (++ muestras == 20)
{
avg = suma / 20;
// compute promedio de 20 muestras de resultado ADC
muestras = 0;
suma = 0;
}
}
55
2. OrangutanAnalogExample2
Previsto para el uso en el orangutn LV-168. Tenga en cuenta que se ejecutar en el robot 3pi y Orangutn SV-xx8,
pero la temperatura mostrada ser incorrecta como la entrada analgica conectada a la sonda de temperatura en el
orangutn LV-168 est conectado a 2 / 3rds de la tensin de la batera en el 3pi y 1/3 de la tensin de la batera en
el Orangutn SV-xx8. Se muestra en la pantalla LCD de la salida potencimetro de ajuste en milivoltios y la salida
del sensor de temperatura en grados Fahrenheit. Si mantiene el dedo en la parte inferior del PCB del orangutn de
LV-168, cerca del centro de la tabla, debera ver la lectura de temperatura lentamente comenzar a subir. Tenga
cuidado de no zap la tarjeta con descargas electrostticas si intenta esto!
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <OrangutanLCD.h>
#include <OrangutanAnalog.h>
/ *
* OrangutanAnalogExample2: el orangutn de LV-168
*
* Este bosquejo utiliza la biblioteca OrangutanAnalog para leer la salida de voltaje
* del potencimetro (en milivoltios) y leer la Orangutn de LV-168
* Sensor de temperatura en grados Farenheit. Estos valores se imprimen a
* la pantalla LCD 10 veces por segundo. Este ejemplo es para uso con el
* orangutn LV-168, a pesar de todo, pero la porcin de medicin de temperatura
* funcionar en el robot 3pi (en el 3pi, entrada analgica 6 se conecta a 2 / 3rds
* de la tensin de la batera en lugar de una sensor de temperatura) y el
* Orangutn SV-xx8 (en el SV-xx8, entrada analgica 6 se conecta a 1/3 de
* el voltaje de la batera).
*
* Usted debe ver el cambio de voltaje trimpot como usted le da vuelta, y usted puede
* obtener la lectura de temperatura para aumentar poco a poco mediante la celebracin de un dedo en el
* inferior del PCB del orangutn de LV-168, cerca del centro de la tabla.
* Tenga cuidado de no zap la tarjeta con descargas electrostticas si
* Intntelo!
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
* /
OrangutanLCD lcd ;
OrangutanAnalog analgica;
void setup ()
{
analog.setMode (MODE_10_BIT);
}
void loop ()
// ejecutar una y otra vez
{
lcd .gotoXY (0,0);
// cursor del LCD a la posicin inicial (arriba a la izquierda)
lcd.print (analog.toMillivolts (analog.readTrimpot ())); // salida trimpot en mV
lcd.print ( "mV" ) ;
// espacios aadidos son sobrescribir sobra caracteres
lcd.gotoXY (0, 1);
49
Esta biblioteca cuenta con tres bocetos de ejemplo que se pueden cargar por ir a Archivo> Ejemplos>
OrangutanBuzzer .
1. OrangutanBuzzerExample
Demuestra una forma de utilizar de esta biblioteca PlayNote () mtodo para tocar una meloda sencilla almacenada
en la memoria RAM. Se debe comenzar inmediatamente a tocar la meloda, y se puede utilizar el botn de usuario
superior para detener y reproducir la meloda. El ejemplo est estructurado de modo que usted puede aadir su
propio cdigo para loop () y la meloda todava jugar normalmente en el fondo, asumiendo que su cdigo se
ejecuta con la suficiente rapidez para evitar la insercin de los retrasos entre las notas. Puede utilizar esta misma
tcnica para tocar melodas que se han almacenado en la EEPROM (la mega168 tiene suficiente espacio en la
memoria EEPROM para almacenar 170 notas).
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <OrangutanLCD.h>
#include <OrangutanPushbuttons.h>
#include <OrangutanBuzzer.h>
/ *
* OrangutanBuzzerExample: para el Orangutn SV-xx8, orangutn LV-168,
* y 3pi robot
*
* En este ejemplo se utiliza la biblioteca OrangutanBuzzer para jugar una serie de notas sobre
* el timbre. Tambin utiliza la biblioteca OrangutanLCD para mostrar las notas que es
* de juego, y utiliza la biblioteca OrangutanPushbuttons para permitir al usuario
* STOP / RESET la meloda con la parte superior
MELODY_LENGTH 95
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// Estas matrices ocupan un total de 285 bytes de RAM (de un lmite 1k)
sin firmar carbn nota [MELODY_LENGTH] =
{
NOTE_E (5), SILENT_NOTE, NOTE_E (5), SILENT_NOTE,
NOTE_E (5), SILENT_NOTE , NOTE_C (5), NOTE_E (5),
NOTE_G (5), SILENT_NOTE, NOTE_G (4), SILENT_NOTE,
NOTE_C (5), NOTE_G (4), SILENT_NOTE, NOTE_E (4), NOTE_A (4),
NOTE_B (4 ), NOTE_B_FLAT (4), NOTE_A (4), NOTE_G (4),
NOTE_E (5), NOTE_G (5), NOTE_A (5), NOTE_F (5), NOTE_G (5),
SILENT_NOTE, NOTE_E (5), NOTE_C (5), NOTE_D (5), NOTE_B (4),
NOTE_C (5), NOTE_G (4), SILENT_NOTE, NOTE_E (4), NOTE_A (4),
NOTE_B (4), NOTE_B_FLAT (4), NOTE_A (4) , NOTE_G (4),
NOTE_E (5), NOTE_G (5), NOTE_A (5), NOTE_F (5), NOTE_G (5),
SILENT_NOTE, NOTE_E (5), NOTE_C (5), NOTE_D (5), NOTE_B ( 4),
SILENT_NOTE, NOTE_G (5), NOTE_F_SHARP (5), NOTE_F (5),
NOTE_D_SHARP (5), NOTE_E (5), SILENT_NOTE, NOTE_G_SHARP (4),
NOTE_A (4), NOTE_C (5), SILENT_NOTE, NOTE_A (4), NOTE_C (5), NOTE_D (5),
SILENT_NOTE, NOTE_G (5), NOTE_F_SHARP (5), NOTE_F (5),
NOTE_D_SHARP (5), NOTE_E (5), SILENT_NOTE,
NOTE_C (6), SILENT_NOTE, NOTE_C (6), SILENT_NOTE, NOTE_C (6),
SILENT_NOTE, NOTE_G (5), NOTE_F_SHARP (5), NOTE_F (5),
NOTE_D_SHARP (5), NOTE_E (5), SILENT_NOTE,
NOTE_G_SHARP (4), NOTE_A (4) , NOTE_C (5), SILENT_NOTE,
NOTE_A (4), NOTE_C (5), NOTE_D (5),
SILENT_NOTE, NOTE_E_FLAT (5), SILENT_NOTE, NOTE_D (5), NOTE_C (5)
};
unsigned int duracin [MELODY_LENGTH] =
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
{
100, 25, 125, 125, 125, 125, 125, 250, 250, 250, 250, 250,
375, 125, 250, 375, 250, 250, 125, 250, 167, 167, 167, 250, 125 , 125,
125, 250, 125, 125, 375,
375, 125, 250, 375, 250, 250, 125, 250, 167, 167, 167, 250, 125, 125,
125, 250, 125, 125, 375 ,
250, 125, 125, 125, 250, 125, 125, 125, 125, 125, 125, 125, 125, 125,
250, 125, 125, 125, 250, 125, 125, 200, 50, 100, 25 , 500,
250, 125, 125, 125, 250, 125, 125, 125, 125, 125, 125, 125, 125, 125,
250, 250, 125, 375, 500
};
void
{
//
//
si
{
loop ()
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
// Por ejemplo, dejar que la funcin de pulsador de usuario superior como STOP / RESET botn meloda
si (buttons.isPressed (TOP_BUTTON) )
{
buzzer.stopPlaying (); // silenciar el timbre
si (currentIdx <MELODY_LENGTH)
currentIdx = MELODY_LENGTH;
// terminar la meloda
dems
currentIdx = 0;
// reiniciar la meloda
buttons.waitForRelease (TOP_BUTTON); // esperar aqu el botn que se lanzar
}
107
108
109
110
111
112
113
114
115
2. OrangutanBuzzerExample2
Muestra cmo se puede utilizar de esta biblioteca play () mtodo para iniciar un juego meloda. Una vez iniciada, la
meloda se reproducir todo el camino hasta el final con ninguna otra accin requerida de su cdigo, y el resto de su
programa se ejecutar con normalidad mientras se reproduce la meloda en el fondo. El play () mtodo est
impulsado en su totalidad por la interrupcin de desbordamiento Timer1. El pulsador de usuario superior jugar una
fuga de Bach de la memoria del programa, el pulsador usuario medio ser tranquilamente jugar la escala de Do
mayor arriba y hacia abajo de la memoria RAM, y el pulsador de usuario final se detendr cualquier meloda que se
est reproduciendo o jugar una sola nota si el timbre est inactivo.
?
1
2
3
4
5
6
7
8
9
10
#include <OrangutanLCD.h>
#include <OrangutanPushbuttons.h>
#include <OrangutanBuzzer.h>
/ *
* OrangutanBuzzerExample2: para el Orangutn SV-xx8, orangutn LV-168,
* y el robot 3pi
*
* En este ejemplo se utiliza la biblioteca OrangutanBuzzer para jugar una serie de notas sobre
* el timbre. Utiliza la biblioteca OrangutanPushbuttons para permitir al usuario
seleccionar la meloda * obras de teatro.
*
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
*
*
*
*
lcd;
OrangutanPushbuttons botones;
OrangutanBuzzer zumbador;
#include <avr / pgmspace.h> // esto vamos a referirnos a los datos en el espacio del programa (es decir, flash)
// almacenamos esta fuga en el espacio del programa mediante la macro PROGMEM.
// Ms tarde lo haremos jugar directamente desde el espacio del programa, pasando por alto la necesidad de cargarlo
// Todos en la RAM primero.
const char fuga [] PROGMEM =
"! O5 L16 agafaea dac + adaea fa <aa <bac # a # dac adaea f"
"O6 dcd <bd <ad <gd <f + d <gd <ad <b- d <dd <ed <f + d <gd <f + d <gd <ad "
"L8 MS <bd <bd MLe- <ge- < g MSc <ac <a ML d <fd <f O5 MS b-gb-g "
"ML> c # e> c # e MS afaf ML gc gc # # MS fdfd ML e <sea <b-"
"O6 L16ragafaea dac # adaea fa <aa <bac # a # dac adaea faeadaca "
"<b-acadg <bg egdgcg <bg <ag <b-GCF <af dfcf <bf <af"
"<gf <af <ser <ge c # e <ser <ae <ge <fe <ge <ad <fd "
"O5 e> ee> ef> df> d b-> c # b-> c # a> df> de> ee> ef> df> d "
"e> d> c #> db> d> c # b> c # agaegfe f O6 dc # dFdC # <bc # 4" ;
void setup ()
{
lcd.print ( " Pulse " );
lcd.gotoXY (0, 1);
lcd.print ( "botn .." );
}
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
void loop ()
// ejecutar una y otra vez
{
// esperar aqu a uno de los tres botones para ser empujado
sin firmar carbn botn = buttons.waitForButton (ALL_BUTTONS);
lcd.clear ();
si (botn == TOP_BUTTON)
{
buzzer.playFromProgramSpace (fuga);
lcd.print ( "Fuga!" );
lcd.gotoXY (0, 1 );
lcd.print ( "Flash ->" );
}
si (botn == MIDDLE_BUTTON)
{
buzzer.play ( "! V8 CDEFGAB> cbagfedc " );
lcd.print ( "Do Mayor" );
lcd.gotoXY (0, 1);
lcd.print ( "RAM ->" );
}
si (botn ==
}
}
200, 15);
lcd.print ( "nota A5" );
71
72
73
74
75
76
77
78
79
80
81
82
83
84
3. OrangutanBuzzerExample3
Demuestra el uso de PLAYMODE de esta biblioteca () y PlayCheck () mtodos. En este ejemplo, el modo de
reproduccin automtica se utiliza para permitir la meloda para seguir jugando mientras que parpadea el LED rojo
de usuario. Luego se cambia el modo de jugar de comprobacin de modo durante una fase en la que estamos
tratando de medir con precisin el tiempo. Hay tres macros #define que le permiten ejecutar este ejemplo de
diferentes maneras y observar el resultado. Por favor, vea los comentarios en la parte superior del boceto para una
informacin ms detallada.
?
1
2
3
4
5
6
#include <OrangutanLCD.h>
#include <OrangutanLEDs.h>
#include <OrangutanBuzzer.h>
/ *
* OrangutanBuzzerExample3: el orangutn de LV-168, Orangutn SV-xx8,
* o robot 3pi
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
*
* En este ejemplo se utiliza la biblioteca OrangutanBuzzer para jugar una serie de notas sobre
* piezo buzzer del objetivo.
*
* Este ejemplo demuestra el uso de la OrangutanBuzzer :: PLAYMODE ()
* y OrangutanBuzzer :: PlayCheck () mtodos, que permiten seleccionar
* si la secuencia de meloda iniciado por OrangutanBuzzer :: play () es
* reproducir automticamente en segundo plano por el Timer1 interrumpir, o si
* el juego es impulsado por el mtodo en su bucle principal PlayCheck ().
*
* modo de reproduccin automtica debe utilizarse si su cdigo tiene mucho de retrasos
* y no es momento crtico. En este ejemplo, el modo automtico se utiliza
* para permitir la meloda para seguir jugando mientras parpadear los LED rojo de usuario.
*
* El modo de Play-cheque debe utilizarse durante partes del cdigo que son
* momento crtico. En el modo automtico, la interrupcin Timer1 es muy lento
* cuando se carga la siguiente nota, y esto puede retrasar la ejecucin de su.
* Utilizando el modo de reproduccin de comprobacin le permite controlar cuando la nota siguiente se
* cargado por lo que no es as ocurrir en el medio de algn sensible al tiempo
* medicin. En nuestro ejemplo usamos el modo de juego-de verificacin para mantener la meloda
* ir al realizar mediciones de tiempo utilizando Timer2. Despus de los
* mediciones, el tiempo mximo medido se muestra en la pantalla LCD.
*
* Inmediatamente a continuacin son tres declaraciones #define que le permiten modificar
la forma * Este programa se ejecuta. Usted debe tener una de las tres lneas
* sin comentar mientras comentando los otros dos:
*
* Si slo WORKING_CORRECTLY es comentada, el programa debe ejecutarse en su
estado ideal *, utilizando el modo de reproduccin automtica durante la fase de LED parpadeante
* y el uso de la reproduccin modo de comprobar durante la fase de distribucin. El mximo registrado
* El tiempo debe ser de 20, como se esperaba.
*
* Si slo es ALWAYS_AUTOMATIC comentarios, el programa utilizar automtico
* Modo de juego durante tanto el parpadeo del LED de fase y la fase de temporizacin. Aqu
* podrs ver el efecto que esto tiene en las mediciones de tiempo (en lugar de 20,
* usted debe ver una lectura mxima de alrededor de 27 o 28).
*
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
// permite la secuencia a seguir jugando de forma automtica a travs de los siguientes retrasos
#ifndef ALWAYS_CHECK
buzzer.playMode (PLAY_AUTOMATIC);
#else
buzzer.playMode (PLAY_CHECK);
#endif
lcd.gotoXY (0, 0) ;
lcd.print ( "parpadea!" );
int i;
para (i = 0; i <8; i ++)
{
#ifdef
0);
lcd.print ( "timing" );
lcd.gotoXY (0, 1);
lcd.print ( "" );
// clara lnea de LCD inferior
// Desactivar reproduccin automtica para que nuestro cdigo de tiempo-crtico gan ' t ser interrumpido por
// timer1 largo del zumbador de interrupcin. De lo contrario, esta interrupcin podra sacudir nuestras
// mediciones de tiempo. En cambio, ahora vamos a utilizar PlayCheck () para mantener la secuencia
// jugar de una manera que no va a deshacerse de nuestras mediciones.
#ifndef ALWAYS_AUTOMATIC
buzzer.playMode (PLAY_CHECK);
#endif
sin firmar carbn MaxTime = 0;
para (i = 0; i <8,000; i ++)
{
TCNT2 = 0;
mientras (TCNT2 <20)
// tiempo de ~ 250 nosotros
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
;
si (TCNT2> MaxTime)
MaxTime = TCNT2;
// si el tiempo transcurrido es mayor que el mximo anterior, gurdelo
#ifndef ALWAYS_AUTOMATIC
buzzer.playCheck ();
// comprobar si es el momento de ejecutar la nota siguiente y reproducirlo si es as
#endif
}
lcd.gotoXY (0, 1);
lcd.print ( "max =" );
lcd.print ((unsigned int ) MaxTime);
lcd.print ( '' ); // sobrescribir cualquier sobrante caracteres
}
127
128
Esta biblioteca cuenta con dos bocetos de ejemplo que se pueden cargar por ir a Archivo> Ejemplos>
OrangutanLCD . Tenga en cuenta que la mayora de las otras bibliotecas tienen ejemplos de bocetos que utilizan la
pantalla LCD, as que por favor ver estos ejemplos de uso para ms OrangutanLCD.
1. OrangutanLCDExample
Demuestra cambiando el contenido de la pantalla moviendo la palabra "Hola" en torno a las dos lneas de la pantalla
LCD.
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <OrangutanLCD.h>
/ *
* OrangutanLCDExample para el orangutn LV-168, Orangutn SV-xx8,
* o robot 3pi
*
* En este ejemplo se utiliza la biblioteca OrangutanLCD escribir "Hola"
* en la pantalla LCD y luego moverlo alrededor de la rea de visualizacin.
* /
lcd OrangutanLCD;
void setup ()
{
}
void loop ()
{
lcd.print ( "Hola" );
de retardo (200);
22
23
24
25
26
27
28
29
30
31
32
lcd.print ( "Hola" );
de retardo (200);
1. OrangutanLCDExample2
Demuestra crear y mostrar caracteres personalizados en la pantalla LCD. La siguiente imagen muestra un ejemplo
de caracteres personalizados, usndolos para mostrar un grfico de barras de las lecturas del sensor y una cara
sonriente:
#include <OrangutanPushbuttons.h>
#include <OrangutanLCD.h>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
{
lcd.loadCustomCharacter (feliz, 0);
lcd.loadCustomCharacter (triste, 1);
lcd.loadCustomCharacter (indiferente, 2);
lcd.loadCustomCharacter (sorprendido, 3);
lcd.loadCustomCharacter (burlndose, 4);
lcd.clear ();
// debe ser llamada antes de poder usar el caracteres personalizados
lcd.print ( "estado de nimo:?" );
// inicializar el generador de nmeros aleatorios basados en cunto tiempo mantenga pulsado el botn la primera vez
OrangutanPushbuttons :: waitForPress (ALL_BUTTONS);
larga semilla = 0;
mientras (OrangutanPushbuttons :: IsPressed (ALL_BUTTONS))
semilla ++;
srandom (semilla);
// lo mismo que: randomSeed ((unsigned int) de la semilla) ;
void loop ()
{
lcd.gotoXY (6, 0);
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
Tenga en cuenta que el LED rojo est en el mismo pin como el transmisor de serie UART0 (PD1), as que si usted
est utilizando UART0 para la transmisin en serie entonces el LED rojo comandos no funcionan, y ver el LED rojo
parpadea brevemente cuando se transmiten los datos en UART0. Tenga en cuenta que el LED verde est en el
mismo pin como un pin de control LCD; el LED verde parpadear brevemente cuando los datos se envan a la
pantalla LCD, pero las dos funciones de lo contrario no va a interferir unos con otros.
No es necesario para inicializar sus OrangutanLEDs objeto antes de su uso. Toda la inicializacin se realiza
automticamente cuando sea necesario.
Todos los mtodos de esta clase son estticos; nunca se debe tener ms de una instancia de un objeto
OrangutanLEDs en su dibujo.
Mtodos OrangutanLEDs
La documentacin completa de los mtodos de esta biblioteca se puede encontrar en la seccin 6 de la Pololu AVR
Library Command Reference .
Ejemplos de uso
Esta biblioteca cuenta con un boceto de ejemplo, que puede cargar por ir a Archivo> Ejemplos> OrangutanLEDs .
1. OrangutanLEDExample
Parpadea alternativamente los LEDs rojos y verdes en el Orangutn SV-xx8, orangutn LV-168, o un robot 3pi. Si
ejecuta este programa en el beb orangutn B, slo ver el usuario roja comenzar a parpadear, pero se puede
conectar un LED externo al pin PD7 (pin de Arduino 7) si usted quiere ver el segundo parpadeo del LED. Si usted
hace esto, no te olvides de incluir una resistencia limitadora de corriente!
?
1
2
3
4
#include <OrangutanLEDs.h>
/ *
* OrangutanLEDExample: para el robot 3pi, orangutn LV 168, Orangutn SV-xx8,
* o beb orangutn B.
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
*
*
*
*
*
Este programa utiliza las funciones OrangutanLEDs para controlar los rojos y verdes
LED de la robot 3pi o orangutn. Tambin se trabajar para controlar el rojo
LED en el beb orangutn B (que carece de un segundo, el LED verde).
/
leds OrangutanLEDs;
void setup ()
{
}
void loop ()
{
leds.red (HIGH);
retardo (1000);
leds.red (LOW);
retardo (1000);
leds.green (HIGH);
de retardo (500);
leds.green (bajo);
de retardo (500);
}
hardware de temporizadores Timer0 y Timer2, por lo que esta biblioteca entrar en conflicto con cualquier otra
biblioteca que dependen de o reconfiguran Timer0 o Timer2 .
Debido a que el entorno de Arduino se basa en Timer0 para funciones de tiempo como millis () y retraso (), esta
biblioteca no puede volver a configurar los temporizadores; en consecuencia, las salidas PWM se limitan a una
frecuencia de 1,25 kHz en el entorno Arduino . En muchos casos, esto se traducir en un gemido audible del
motor. Para evitar este problema, puede en lugar del programa en C o C ++ con la Biblioteca AVR Pololu , lo que
le permite utilizar los controladores de motor a frecuencias PWM mayores.
No es necesario para inicializar sus OrangutanMotors objeto antes de su uso. Toda la inicializacin se realiza
automticamente cuando sea necesario.
Todos los mtodos de esta clase son estticos; nunca se debe tener ms de una instancia de un objeto
OrangutanMotors en su dibujo.
Mtodos OrangutanMotors
La documentacin completa de los mtodos de esta biblioteca se puede encontrar en la seccin 7 de la Pololu AVR
Library Command Reference .
Ejemplos de uso
Esta biblioteca cuenta con dos bocetos de ejemplo que se pueden cargar por ir a Archivo> Ejemplos>
OrangutanMotors .
1. OrangutanMotorExample
Demuestra controlar los motores utilizando el potencimetro de ajuste y usa el LED rojo para la retroalimentacin.
?
1
2
3
4
#include <OrangutanLEDs.h>
#include <OrangutanAnalog.h>
#include <OrangutanMotors.h>
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/ *
* OrangutanMotorExample para el robot 3pi, orangutn LV-168, Orangutn SV-xx8,
* y beb orangutn B
*
* En este ejemplo se utiliza la biblioteca OrangutanMotors conducir
* motores en respuesta a la posicin de trimmer de usuario potencimetro
* y parpadea el LED a una velocidad determinada por el condensador de ajuste de usuario roja
* posicin del potencimetro. Utiliza la biblioteca OrangutanAnalog para medir
* la posicin trimpot, y utiliza la biblioteca OrangutanLEDs proporcionar
retroalimentacin * limitada con el usuario roja
analgico;
leds OrangutanLEDs;
motores OrangutanMotors;
void setup ()
{
}
void loop ()
// ejecutar una y otra vez
{
// en cuenta que la siguiente lnea tambin podra lograrse con:
// int olla = analog.read (7);
int olla = analog.readTrimpot ();
// determinar la posicin trimpot
int MotorSpeed = olla / 2-256; // enciende olla lectura en nmero entre -256 y 255
si (MotorSpeed = = -256)
MotorSpeed = -255; // 256 est fuera de rango
motors.setSpeeds (MotorSpeed, MotorSpeed);
int ledDelay = MotorSpeed;
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
si (ledDelay <0)
ledDelay = -ledDelay; // hacer la demora un no negativo nmero
ledDelay = 256 ledDelay; // el retraso debe ser corta cuando la velocidad es alta
leds.red (HIGH);
retardo (ledDelay);
leds.red (LOW);
retardo (ledDelay);
2. OrangutanMotorExample2
Demuestra controlar los motores utilizando el potencimetro de ajuste, pero utiliza la pantalla LCD para la mayora
de las votaciones, por lo que no va a funcionar plenamente en el beb del orangutn.
?
1
2
3
4
5
6
7
8
#include
#include
#include
#include
<OrangutanLEDs.h>
<OrangutanAnalog.h>
<OrangutanMotors.h>
<OrangutanLCD.h>
/ *
* OrangutanMotorExample2 para el robot 3pi, orangutn LV-168,
* y Orangutn SV-xx8.
*
* Este ejemplo utiliza los OrangutanMotors y bibliotecas OrangutanLCD conducir
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
}
void loop ()
// ejecutar una y otra vez
{
// en cuenta que la siguiente lnea tambin podra lograrse con:
// int olla = analogRead (7);
int olla = analgica. readTrimpot (); // determinar la posicin trimpot
// evite limpiar la pantalla LCD para reducir el parpadeo
lcd.gotoXY (0, 0);
lcd.print ( "pot =" );
lcd.print (POT);
// imprimir el guarnecido posicin olla (0 - 1023)
lcd.print ( "" );
// sobrescribir cualquier sobrante dgitos
int MotorSpeed = (512 - pot) / 2;
lcd.gotoXY (0, 1);
lcd.print ( "spd =" );
lcd.print (MotorSpeed);
// imprime la velocidad resultante del motor (-255 a 255)
lcd.print ( "" );
motors.setSpeeds (MotorSpeed, MotorSpeed); // establecer las velocidades de los motores 1 y 2
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
Todos los mtodos de esta clase son estticos; nunca se debe tener ms de una instancia de un objeto
OrangutanPushbuttons en su dibujo.
Mtodos OrangutanPushbuttons
La documentacin completa de los mtodos de esta biblioteca se puede encontrar en la seccin 9 de la Pololu AVR
Library Command Reference .
Ejemplos de uso
Esta biblioteca cuenta con un boceto de ejemplo, que puede cargar por ir a Archivo> Ejemplos>
OrangutanPushbuttons .
1. OrangutanPushbuttonExample
Demuestra la interfaz con los pulsadores de usuario. Se esperar que usted empuje el botn superior o el botn
inferior, momento en el que se mostrar en la pantalla LCD que se pulsa el botn. Tambin detectar cuando se
libera posteriormente ese botn y mostrar que para la pantalla LCD.
?
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <OrangutanLCD.h>
#include <OrangutanPushbuttons.h>
/ *
* OrangutanPushbuttonExample: para el robot 3pi, orangutn LV-168,
* y Orangutn SV-xx8
*
* En este ejemplo se utiliza la biblioteca OrangutanPushbuttons para detectar la entrada de usuario
* desde el pulsadores, y utiliza la biblioteca OrangutanLCD para mostrar
* retroalimentacin en la pantalla LCD.
* /
OrangutanPushbuttons botones;
OrangutanLCD lcd;
void setup ()
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
{
}
void loop ()
{
lcd.clear ();
lcd.print ( "Waiting" );
1
2
3
4
#include
#include
#include
#include
A diferencia de las otras bibliotecas orangutn, debe llamar explcitamente al init () mtodo para inicializar el objeto
Pololu3pi antes de usarlo.
Todos los mtodos de esta clase son estticos; nunca se debe tener ms de una instancia de un objeto Pololu3pi en
su dibujo.
Mtodos Pololu3pi
La documentacin completa de los mtodos de esta biblioteca se puede encontrar en la Seccin 19 de la Pololu
AVR Library Command Reference .
Ejemplos de uso
Esta biblioteca cuenta con tres bocetos de ejemplo que se pueden cargar por ir a Archivo> Ejemplos>
Pololu3pi . Hay un ejemplo muy simple, basada siguiente, un ejemplo de lnea de seguimiento ms avanzado
basado en PID, y un ejemplo bsico laberinto de resolucin.
Para obtener ms informacin sobre la creacin de la lnea y del laberinto de golf, as como una explicacin
detallada de las versiones C de los programas de demostracin, consulte las secciones 6 y 7 de laGua del usuario
3pi .