POLOLU Manual-Programing

1.
Introduccin
El orangutn de LV-168 conectado a un

soporte de la batera de 3 AA.
Orangutn del beb B con

pines de cabecera
incluidos soldado en la
instalacin de tablero.
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.
Pololu programador AVR USB con cable

incluido ISP seis pines.
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:
2.a. Orangutn SV-xx8 y BT-168 Pin Asignaciones
Orangutn SV-168 vista desde abajo

con dimensiones (cartografa pin de
Arduino).
Orangutn LV-168 vista desde abajo

con dimensiones (cartografa pin de
Arduino).
Tabla Asignacin Pin Ordenado por funcin

Funcin
Arduino Pin
mega168 Pin
digital de E / S (x8)
pines digitales 0 y 1
entradas analgicas 0-5
PD0, PD1,
PC0 - PC5
entradas analgicas (x8)
PC0 - PC5, ADC6, ADC7
1 de control del motor (A y B)
PD5 y PD6
PD3 y PB3
LED rojo de usuario
pin digital 1
PD1
LED verde usuario
pin digital 7
PD7
pulsadores de usuario (x3)
entradas digitales 9, 12 y 13
PB1, PB4 y PB5
zumbador
pin digital 10
PB2
Control LCD (RS, R / W, E)
pines digitales 2, 8 y 4
PD2, PB0, y PD4
Datos LCD (4 bits: DB4 - DB7)
pines digitales 9, 12, 13 y 7
PB1, PB4, PB5, y PD7
trimmer de usuario potencimetro
entrada analgica 7
(a travs de puente)
ADC7
sensor de temperatura (slo LV-168)

de la batera del monitor de tensin (SV-168 solamente)
entrada analgica 6
(a travs de puente SMT)
ADC6
Lneas de programacin ICSP (x3)
PB3, PB4, PB5
pulsador de rearme
reajustar
PC6
UART (RX y TX)
PD0 y PD1
I2C / TWI (SDA y SCL)
entradas analgicas 4 y 5
PC4 y PC5
SPI
inaccesible para el usuario
Tabla Asignacin Pin Ordenado por Pin

Arduino Pin
Funcin orangutn
Notas / Funciones Alternos
pin digital 0
E / S digital
USART pin de entrada (RXD)
pin digital 1
E / S digital
conectado al LED rojo de usuario (altas vueltas LED encendido)

pin de salida USART (TXD)
pin digital 2
De control LCD de
interrupcin externa 0 (INT0)
lnea RS
pin digital 3
Lnea de control M2 Timer2 salida PWM B (OC2B)
pin digital 4
Lnea de control
LCD E
pin digital 5
Lnea de control M1 Timer0 salida PWM B (OC0B)
pin digital 6
Lnea de control M1 Timer0 PWM de salida A (OC0A)
pin digital 7
Lnea de datos LCD

conectado al LED verde usuario (altas vueltas LED encendido)
DB7
pin digital 8
LCD lnea de
control R / W
pin digital 9
Lnea de datos LCD pulsador de usuario (pulsando tira pin baja)

DB4
Timer1 salida PWM A (OC1A)
pin digital 10
zumbador
Timer1 salida PWM B (OC1B)
pin digital 11
Lnea de control M2
Salida Timer2 PWM A (OC2A)

lnea de programacin ISP
pin digital 12
Lnea de datos LCD

pulsador de usuario (pulsando tira pin baja) Precaucin: tambin una lnea de programacin ISP
DB5
pin digital 13
Lnea de datos LCD

pulsador de usuario (pulsando tira pin baja) Precaucin: tambin una lnea de programacin ISP
DB6
entrada
analgica 0
entrada analgica y
E / S digital
ADC canal de entrada 0 (ADC0)
entrada
analgica 1
entrada analgica y
E / S digital
Canal de entrada ADC 1 (ADC1)
entrada
analgica 2
entrada analgica y
E / S digital
USART entrada de reloj externa / salida (XCK)

contador externo Timer0 (T0)
Timer1 captura de entrada (ICP1)

salida de reloj del sistema dividido (CLK0)
entrada
analgica 3
entrada analgica y
E / S digital
entrada
analgica 4
entrada analgica y
E / S digital

I2C / TWI lnea de datos de entrada / salida (SDA)
entrada
analgica 5
entrada analgica y
E / S digital

I2C / TWI lnea de reloj (SCL)
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
de entrada analgica puenteado a recortador usuario potencimetro

dedicada
del canal de entrada ADC 7 (ADC7)
reajustar
pulsador de rearme
tirado internamente alta; activo bajo

E / S digital desactivado por defecto
2.b. beb orangutn B Pin Asignaciones

Funcin
Arduino Pin
mega168 Pin
digital de E / S (x16)
pines digitales 0-2, 4, 7-10, 12, 13

PD0 - PD2, PD4, PD7,

PB0 - PB2, PB4, PB5,
PC0 - PC5
entradas analgicas (x8)
PC0 - PC5, ADC6, ADC7
PD5 y PD6
PD3 y PB3
LED rojo de usuario
pin digital 1
PD1
entrada analgica 7
ADC7
PB3, PB4, PB5
REINICIO
reajustar
PC6
UART (RX y TX)
PD0 y PD1
I2C / TWI (SDA y SCL)
entradas analgicas 4 y 5
PC4 y PC5
SPI
Timer1 salidas PWM (A y B)
PB1 y PB2

Arduino Pin
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
Timer0 PWM de salida A (OC0A)
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
Precaucin: tambin una lnea de programacin ISP
pin digital 13
E / S digital
Precaucin: tambin una lnea de programacin ISP
entrada analgica 0
entrada analgica y E / S digital
ADC canal de entrada 0 (ADC0)
entrada analgica 1
entrada analgica 2
entrada analgica 3
entrada analgica 4

I2C / TWI lnea de datos de entrada / salida (SDA)
entrada analgica 5

I2C / TWI lnea de reloj (SCL)
entrada analgica 6
de entrada analgica dedicada
entrada analgica 7
conectado al recortador de usuario potencimetro

canal de entrada ADC 7 (ADC7)
reajustar
REINICIO pin

2.c 3pi Robot Pin Asignaciones
Caractersticas generales del robot 3pi Pololu, vista desde arriba.
Etiquetada vista inferior del robot 3pi Pololu.
Caractersticas especficas del robot 3pi Pololu, vista desde arriba.

Funcin
Arduino Pin
mega168 Pin
Me digital gratuito / Os (x3)

(Quite el puente PC5 al pin digital gratuito 19)
pines digitales 0, 1, 19
PD0, PD1, PC5
entradas analgicas libres (si se quita los puentes, x3)
PC5, ADC6, ADC7
motor 1 (motor izquierdo) de control (A y B)
PD5 y PD6
motor 2 (motor derecho) de control (A y B)
PD3 y PB3
Sensores de reflectancia de QTR-RC (de izquierda a derecha, x5)
pines digitales 14-18
PC0 - PC4
rojo (izquierda) LED usuario
pin digital 1
PD1
verde (derecha) LED usuario
pin digital 7
PD7
pulsadores de usuario (de izquierda a derecha, x3)
entradas digitales 9, 12 y 13
PB1, PB4 y PB5
zumbador
pin digital 10
PB2
Control LCD (RS, R / W, E)
PD2, PB0, y PD4
Datos LCD (4 bits: DB4 - DB7)
pines digitales 9, 12, 13 y 7
PB1, PB4, PB5, y PD7
sensor de reflectancia IR LED de control

(conducir bajo para encender LEDs IR apagado)
pin digital 19
(a travs del puente)
PC5
entrada analgica 7
(a travs de puente)
ADC7
2 / 3rds de voltaje de la batera
entrada analgica 6
(a travs de puente)
ADC6
PB3, PB4, PB5
pulsador de rearme
reajustar
PC6
UART (RX y TX)
PD0 y PD1
I2C / TWI
SPI

Arduino Pin
Funcin orangutn
pin digital 0
Me digital gratuito / S
pin digital 1
Me digital gratuito / S

pin digital 2
De control LCD de lnea RS
pin digital 3
Lnea de control M2
pin digital 4
Lnea de control LCD E

pin digital 5
Lnea de control M1
pin digital 6
Lnea de control M1
Timer0 PWM de salida A (OC0A)
pin digital 7
Lnea de datos LCD DB7
conectado al LED verde usuario (altas vueltas LED encendido)
pin digital 8
LCD lnea de control R / W

pin digital 9
pulsador de usuario (pulsando tira pin baja)

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
RC
sensor marcado PC1
pin digital 16
RC
sensor marcado PC2 (sensor central)
pin digital 17
RC
sensor marcado PC3
pin digital 18
RC
sensor marcado PC4 (sensor ms a la derecha)
pin digital 19
puenteado con LEDs IR sensores ' (conducir bajo apaga emisores)

canal de entrada ADC 5 (ADC5)
entrada analgica
6
puenteado a 2 / 3rds de voltaje de la batera

entrada analgica
7
puenteado a recortador usuario potencimetro

reajustar

pulsador de rearme
3. Configuracin del Arduino Medio Ambiente
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.maximum_size = 16384
orangutan168pgm.build.mcu = atmega168
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
################################################## ############
orangutan328pgm.name = Pololu Orangutn o robot 3pi w / ATmega328P travs Programador
orangutan328pgm.upload.maximum_size = 32768
orangutan328pgm.build.mcu = ATmega328P
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.
avrispv2.name = AVR ISP v2
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;
// LED conectado al pin digital 1 (PD1) en orangutanes
void setup ()
{
pinMode (ledPin, OUTPUT);
}
// ejecutar una vez, cuando se inicia el croquis
void loop ()
{
// ejecutar una y otra vez
// establece el pin digital como salida
18
19
20
21
22
23
24
25
digitalWrite (ledPin, HIGH);

retardo (1000);
digitalWrite (ledPin, LOW);
retardo (1000);
// establece el LED el
// espera un segundo
// establece el LED apagado
O copie el texto anterior en un nuevo boceto en blanco, o descargar este

como OrangutanBlinkExample.pde (pde 1k) y abrirlo en el IDE de Arduino.
Selecciona una de nuestras tablas especialmente creados utilizando el men Herramientas> Junta:
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.
5. Arduino Bibliotecas para el orangutn y el robot 3pi
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
// C ++ a travs de la funcin objeto instanciado

OrangutanAnalog analgica; // esta lnea se coloca generalmente por encima de setup ()
x = analog.readTrimpot ();
// C ++ funcin a travs mbito de clase
x = OrangutanAnalog :: readTrimpot ();
/ / funcin C
x = read_trimpot ();
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:
PololuArduinoLibraries-111221 (107k zip), probados con Arduino 1.0
PololuArduinoLibraries-101215 (107k zip), probados con Arduino 0021

Instalacin
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;
// Se ejecuta una vez, cuando se inicia el croquis

// 8 bits analgica-digital conversiones
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);
// inicia conversin inicial
}
void loop ()
{
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;
}
}
// cuando avg == 0, el LED rojo est casi totalmente fuera

// cuando avg == 255, el LED rojo est casi totalmente de
brillo // debe escalar de forma lineal entre
leds.red (LOW);
// LED apagado rojos
delayMicroseconds (256 - avg);
leds.red (HIGH);
// LED rojo en
delayMicroseconds (avg + 1);
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>
/ *
* 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);
}
// ejecuta una vez, cuando se inicia el croquis

// 10 bits analgica-digital conversiones
void loop ()
{
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);
// LCD cursor al inicio de la segunda lnea
// obtener la temperatura en dcimas de grado F

unsigned int temp = analog.readTemperatureF ();
lcd.print (temp / 10);
// obtener el nmero total de grados
lcd.print ( '.' );
// imprime el punto decimal
lcd.print (temp - (temp / 10) * 10); // impresin el dcimas dgitos
lcd.print (( Char ) 223);
// imprime un smbolo de grado
lcd.print ( "F" );
// espacios aadidos son sobrescribir la izquierda sobre caracteres
de retardo (100);
}
// Espera a 100 ms ( reduce el parpadeo LCD)
49
5.b OrangutanBuzzer - de Alto Nivel Buzzer Control Library

Visin de conjunto
Esta biblioteca le permite controlar fcilmente el zumbador piezo en el robot 3pi , Orangutn SV-xx8 y orangutn
LV-168 . Te da la opcin de jugar ya sea una nota o una frecuencia para una duracin especificada en un volumen
determinado, o puede utilizar el juego () mtodo para reproducir una meloda entera en el fondo. Control Zumbador
se logra utilizando una de las salidas PWM Timer1, y la duracin de tiempo se realiza mediante una alarma de
desbordamiento Timer1, por lo que esta biblioteca estar en conflicto con otras bibliotecas que dependen de o
reconfiguran Timer1 . Por ejemplo, la funcin de Arduino analogWrite () no funcionar en los pines de salida PWM
Timer1 una vez que han comenzado a utilizar esta biblioteca en su dibujo.
La ventaja de este enfoque es que se puede jugar notas sobre la bocina, dejando la CPU sobre todo libre para
ejecutar el resto de tu cdigo. Esto significa que puede tener un juego meloda de fondo mientras su 3pi orangutn o
hace su tarea principal. Usted puede sondear el isPlaying () mtodo para determinar cuando el timbre se termin de
tocar.
No es necesario para inicializar el objeto OrangutanBuzzer antes de su uso. Toda la inicializacin se realiza
OrangutanBuzzer en su dibujo.
Mtodos OrangutanBuzzer
Ejemplos de uso
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 <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),
NOTE_D_SHARP (5), NOTE_E (5), SILENT_NOTE,
NOTE_C (6), SILENT_NOTE, NOTE_C (6), SILENT_NOTE, NOTE_C (6),
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
};
OrangutanLCD del LCD;

OrangutanPushbuttons botones;
zumbador OrangutanBuzzer ;
sin firmar carbn currentIdx;
void setup ()
{
currentIdx = 0;
lcd.print ( "Msica!" );
}
void
{
//
//
si
{
loop ()
si no han terminado de jugar la cancin y

el zumbador est listo para la siguiente nota, reproducir la siguiente nota
(currentIdx <MELODY_LENGTH &&! buzzer.isPlaying ())
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
// juego nota al volumen mximo

buzzer.playNote (nota [ currentIdx], duracin [currentIdx], 15);
// opcional retroalimentacin LCD (por diversin)
lcd.gotoXY (0, 1);
// Ir al inicio de la segunda lnea del LCD
lcd.print ((unsigned int ) nota [currentIdx ]); // valor entero de impresin de la nota actual
lcd.print ( "" );
// sobrescribir cualquier sobrante caracteres
currentIdx ++;
}
//
//
//
//
Introducir algn otro cdigo til aqu ...

la meloda jugar normalmente mientras que el resto de su cdigo se ejecuta
siempre que se ejecuta con la suficiente rapidez para evitar la insercin de retrasos
entre las notas.
// 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
/ *
* OrangutanBuzzerExample2: para el Orangutn SV-xx8, orangutn LV-168,
* y el robot 3pi
*
* 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
*
*
*
*
Este ejemplo demuestra el uso de la OrangutanBuzzer :: mtodo play (),

que toca la meloda especificado en su totalidad en el fondo, lo que requiere
ninguna otra accin de la usuario una vez que se llama al mtodo. La CPU
es libre de ejecutar otro cdigo mientras que la meloda
lcd;
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 ()
{
// 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
/ *
* 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
*
* 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
* Si slo ALWAYS_CHECK es comentada, el programa estar en play-cheque

* Modo tanto durante la fase de LED parpadeante y la fase de distribucin. Aqu
* ver el efecto de que los retrasos LED-parpadear tienen en play-cheque
* Modo (la secuencia ser muy agitado mientras el LED parpadea, pero
* sonar normal durante la fase de sincronizacin). La lectura mxima sincronizacin debe
ser * 20, como se esperaba.
* /
// *** descomentar UNA DE LAS DIRECTIVAS precompilador ***
// (los dos restantes deben ser comentada)
#define WORKING_CORRECTLY // este es el camino correcto utilizar PLAYMODE ()
// # define ALWAYS_AUTOMATIC // PLAYMODE () es siempre PLAY_AUTOMATIC (el tiempo es inexacta)
// # define ALWAYS_CHECK // PLAYMODE () siempre PLAY_CHECK (retrasos interrumpen la secuencia)
OrangutanLEDs leds;
OrangutanBuzzer zumbador;
OrangutanLCD lcd ;
#include <avr / pgmspace.h>
const char rapsodia [] PROGMEM = "O6 T40 L16 d # <b <f # <d # <f # <bd # f #"
"T80 c # <b- <f # <c # <f # <bc # 8 "
"T180 D # b <f # d # f #> bd # f # c # b- <f # c # f #> bc # 8
ejecutar una vez, cuando se inicia el croquis

{
TCCR2A = 0;
// configure Timer2 para funcionar a 78 kHz
TCCR2B = 0x06;
// y el desbordamiento cuando TCNT2 = 256 (~ 3 ms)
buzzer.playFromProgramSpace (rapsodia);
}
void loop ()
{
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
5.c. OrangutanLCD - Biblioteca de controles de LCD

Visin de conjunto
Esta biblioteca le da la capacidad de controlar el carcter LCD de 8 2 en el robot 3pi , Orangutn SVxx8 y orangutn LV-168 . Implementa el protocolo estndar HD44780 de 4 bits, y utiliza la funcin de ocupado:
espere de bandera para evitar las innecesariamente largos retrasos presentes en otras bibliotecas Arduino LCD de 4
bits. Esta amplia biblioteca est destinado a ofrecer el mximo control LCD como sea posible, por lo que lo ms
probable es que te da ms mtodos de las que necesita. Usted puede comentar mtodos que no sean necesarios
(por ejemplo ShowCursor ()) en OrangutanLCD.cpp hacer esta biblioteca ms pequea. Si usted hace esto,
recuerde que debe eliminar OrangutanLCD.o as y reiniciar el IDE de Arduino para que se volver a compilar la
biblioteca.
Esta biblioteca est diseado para manejar con gracia uso alternativo de las cuatro lneas de datos LCD. Se va a
cambiar sus registros de direccin de datos y estados de salida slo cuando sea necesario para un comando de
LCD, despus de lo cual restaurar inmediatamente los registros a sus estados anteriores. Esto permite que las
lneas de datos LCD para funcionar como entradas de pulsador y un controlador LED en el orangutn y 3pi.
No es necesario para inicializar el objeto OrangutanLCD antes de su uso. Toda la inicializacin se realiza
OrangutanLCD en su dibujo.
Mtodos OrangutanLCD
Ejemplos de uso
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
/ *
* 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);

// pantalla "Hola" en (0, 0), tambin conocido como superior izquierda
// Desplaza la pantalla derecha cada 200ms tres veces

lcd.scroll (LCD_RIGHT, 3, 200);
lcd.clear ();
// borrar la pantalla
lcd. gotoxy (3, 1);
// ir al cuarto personaje de la segunda lnea del LCD
22
23
24
25
26
27
28
29
30
31
32
lcd.print ( "Hola" );
de retardo (200);
// pantalla "Hola" en (3, 1), tambin conocido como inferior derecha
// Desplaza la pantalla dej cada 200ms tres veces

lcd.scroll (LCD_LEFT, 3, 200);
lcd.clear ();
// borrar el LCD
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:
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
#include <stdlib.h> // utilizado por sus funciones y "al azar" "srandom"

/ *
* OrangutanLCDExample2: para el Orangutn SV-xx8, orangutn LV-168 o robot 3pi
*
* En este ejemplo se utiliza la biblioteca OrangutanLCD para mostrar caracteres personalizados en
la pantalla LCD *. Slo tiene que pulsar un botn cualquier usuario para mostrar una nueva, al azar
carcter humor * elegido.
* /
OrangutanLCD lcd;
// definir algunos personajes personalizados "estado de nimo"
#include <avr / pgmspace.h> // Esto nos permite referirnos a los datos en el programa espacio (es decir, flash)
const char feliz [] = {PROGMEM
0b00000, // los 5 bits que componen la fila superior del carcter 5x8
0b01010,
0b01010,
0b01010,
0b00000,
0b10001,
0b01110,
0b00000
};
const char triste [] PROGMEM = {
0b00000,
0b01010,
0b01010,
0b01010,
0b00000,
0b01110,
0b10001,
0b00000
};
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
const char indiferente [] = {PROGMEM

0b00000,
0b01010,
0b01010,
0b01010,
0b00000,
0b00000,
0b01110,
0b00000
};
const char sorprendi [] PROGMEM = {
0b00000,
0b01010,
0b01010,
0b00000,
0b01110,
0b10001,
0b10001,
0b01110
};
const char burlndose [] = {PROGMEM
0b00000,
0b01010,
0b01010,
0b01010,
0b00000,
0b11111,
0b00101,
0b00010
};
Char prevMood = 5;
void setup ()
// ejecuta una vez, cuando se inicia el croquis
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);

// mover el cursor a la posicin correcta
// asegurar que conseguimos un nuevo estado de nimo que se diferencia de la anterior

Char estado de nimo;
do
{
estado de nimo = random ()% 5;
// lo mismo que: humor = random (5);
} mientras que (humor == prevMood);
prevMood = estado de nimo;
lcd.print (estado de nimo);
// imprime un carcter humor aleatorio
// esperar para cualquier botn para presionar

OrangutanPushbuttons :: waitForButton (ALL_BUTTONS);
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
5.D. OrangutanLEDs - Biblioteca de control LED

Visin de conjunto
Esta biblioteca le permite controlar fcilmente el LED (s) en el robot 3pi , Orangutn SV-xx8 , orangutn LV-168 ,
y beb orangutn B . En el Orangutn SV-xx8 y LV-168, hay dos LEDs de usuario estn en la parte superior de la
placa con el LED en la parte inferior de color rojo a la izquierda y el LED verde en la parte superior derecha. En el
3pi, hay dos LEDs de usuario en el lado inferior de la PCB con el LED rojo a la derecha (al mirar en la parte inferior)
y el LED verde de la izquierda. LEDs adicionales incluidas con el 3pi se pueden soldar en en la parte superior (en
paralelo con los LED de montaje en superficie en la parte inferior) para facilitar la visualizacin. El beb orangutn
tiene un solo LED rojo y el LED no verde.
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
OrangutanLEDs en su dibujo.
Mtodos OrangutanLEDs
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
/ *
* 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);
}
/ / ejecutar una y otra vez

// LED rojo en
// roja LED apagado
// espera por un segundo
// LED verde en (no funcionar en el Orangutn del beb)
// espera durante 0,5 segundos
// LED verde apagado (no lo har trabajar en el beb del orangutn)
// espera 0,5 segundos
5.E. OrangutanMotors - Biblioteca de Control de Motores

Visin de conjunto
Esta biblioteca le da la capacidad de controlar los controladores de motor en el robot 3pi , Orangutn SVxx8 , orangutn LV-168 , y el beb orangutn B . Esto se logra mediante el uso de las salidas PWM cuatro
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
OrangutanMotors en su dibujo.
Mtodos OrangutanMotors
Ejemplos de uso
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 <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 ()
{
// 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);
// enciende LED en rojo
// enciende el LED rojo apagado
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
* motores en respuesta a la posicin del potencimetro de ajuste de usuario

* y para mostrar la posicin del potencimetro y la velocidad del motor deseada
* en la pantalla LCD. Utiliza la biblioteca OrangutanAnalog para medir la
posicin * trimpot, y utiliza la biblioteca OrangutanLEDs proporcionar
retroalimentacin * limitada con los LEDs de usuario rojos y verdes.
* /
OrangutanLCD lcd;
motores OrangutanMotors;
analgica OrangutanAnalog;
leds OrangutanLEDs;
void setup ()
{
/ / ejecutar una vez, cuando se inicia el croquis
}
void loop ()
{
// 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 LED apagados

leds.red (LOW);
leds.green (LOW);
// enciende LED verde cuando los motores estn girando hacia adelante
si (MotorSpeed> 0)
leds.green (HIGH);
// enciende el LED rojo cuando los motores son girando en sentido inverso
si (MotorSpeed <0)
leds.red (HIGH);
retardo (100);
}
5.F. OrangutanPushbuttons - Pulsador Interface Library

Visin de conjunto
Esta biblioteca le permite interactuar fcilmente con los tres pulsadores de usuario en el robot 3pi , Orangutn SVxx8 y orangutn LV-168 por cualquiera de votacin para el estado de botones especficos o esperando a eventos
de pulsacin / soltura en los botones que se pueden especificar. Los waitFor ____ () mtodos en esta biblioteca
resolver automticamente el botn de eliminacin de rebotes.
No es necesario para inicializar sus OrangutanPushbuttons objeto antes de su uso. Toda la inicializacin se realiza
OrangutanPushbuttons en su dibujo.
Mtodos OrangutanPushbuttons
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
/ *
* 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.
* /
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" );
// esperar a que cualquiera de los botones superiores o inferiores al ser presionadas

// almacenar el valor del botn se pulsa en el botn '' variables
sin signo carbn botn = botones. waitForPress (TOP_BUTTON | BOTTOM_BUTTON);
lcd.clear ();
si (botn == TOP_BUTTON)
// muestra el botn que se presion
lcd.print ( "de arriba abajo" );
lo dems
lcd.print ( "bot abajo" );
botones .waitForRelease (botn); // esperar a que el botn sea liberado
lcd.clear ();
lcd.print ( "liberado" );
// pantalla que el botn se libera
de retardo (1000);
}
5.g. Pololu3pi - Biblioteca del sensor para el robot 3pi

Visin de conjunto
Esta biblioteca le permite interactuar fcilmente con los cinco sensores de reflectancia en el infrarrojo en el robot
3pi . Tenga en cuenta que para utilizar esta biblioteca, tambin debe incluir PololuQTRSensors.h en su
dibujo . Usted debe tener algo como lo siguiente en la parte superior de su dibujo:
1
2
3
4
#include
#include
#include
#include
<Pololu3pi.h> // da acceso al sensor funciones de interfaz

<PololuQTRSensors.h> // utilizado por Pololu3pi.h
<OrangutanMotors.h> // da acceso a las funciones de control de motor
<OrangutanBuzzer.h > // da acceso a las funciones de control del zumbador
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 .

POLOLU Manual-Programing

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

POLOLU Manual-Programing

Uploaded by

Copyright:

Available Formats

1.

El orangutn de LV-168 conectado a un

Orangutn del beb B con

Pololu programador AVR USB con cable

2.a. Orangutn SV-xx8 y BT-168 Pin Asignaciones

Orangutn SV-168 vista desde abajo

Orangutn LV-168 vista desde abajo

Tabla Asignacin Pin Ordenado por funcin

entradas analgicas (x8)

entradas analgicas 0-7

PC0 - PC5, ADC6, ADC7

1 de control del motor (A y B)

2 de control del motor (A y B)

LED rojo de usuario

LED verde usuario

pulsadores de usuario (x3)

PB1, PB4 y PB5

Control LCD (RS, R / W, E)

PD2, PB0, y PD4

Datos LCD (4 bits: DB4 - DB7)

pines digitales 9, 12, 13 y 7

PB1, PB4, PB5, y PD7

trimmer de usuario potencimetro

sensor de temperatura (slo LV-168)

Lneas de programacin ICSP (x3)

pines digitales 11, 12 y 13

PB3, PB4, PB5

UART (RX y TX)

I2C / TWI (SDA y SCL)

inaccesible para el usuario

Tabla Asignacin Pin Ordenado por Pin

Notas / Funciones Alternos

USART pin de entrada (RXD)

conectado al LED rojo de usuario (altas vueltas LED encendido)

interrupcin externa 0 (INT0)

Lnea de control M2 Timer2 salida PWM B (OC2B)

Lnea de control M1 Timer0 salida PWM B (OC0B)

Lnea de control M1 Timer0 PWM de salida A (OC0A)

Lnea de datos LCD

Lnea de datos LCD pulsador de usuario (pulsando tira pin baja)

Timer1 salida PWM B (OC1B)

Salida Timer2 PWM A (OC2A)

Lnea de datos LCD

Lnea de datos LCD

ADC canal de entrada 0 (ADC0)

Canal de entrada ADC 1 (ADC1)

Canal de entrada ADC 2 (ADC2)

USART entrada de reloj externa / salida (XCK)

Timer1 captura de entrada (ICP1)

Canal de entrada ADC 3 (ADC3)

Canal de entrada ADC 4 (ADC4)

Canal de entrada ADC 5 (ADC5)

de entrada analgica puenteado a recortador usuario potencimetro

tirado internamente alta; activo bajo

2.b. beb orangutn B Pin Asignaciones

Tabla Asignacin Pin Ordenado por funcin

pines digitales 0-2, 4, 7-10, 12, 13

PD0 - PD2, PD4, PD7,

entradas analgicas (x8)

entradas analgicas 0-7

PC0 - PC5, ADC6, ADC7

1 de control del motor (A y B)

2 de control del motor (A y B)