Sessions Robòtica Extraescolar. Curs 2015-2016
Contingut
- 1 Sessió 1. Arduino. Introducció. Encendre i apagar el LED
- 2 Sessió 2. Interactuar amb Python des de l'Arduino. Encendre i apagar el LED. LED RGB
- 3 Sessió 3. Sensors. Fotoresistència (LDR). Tractament de les dades: gràfic
- 4 Sessió x. Actuadors. Solenoide, relé, motor DC, motor pas a pas, servomotor. Sensors i actuadors. Domòtica
- 5 Sessió 4. Robòtica. Introducció. Robot Zowi
- 6 Sessió 5. Programació amb bitbloq I
- 7 Sessió 6. Programació amb bitbloq II
- 8 Sessió 7. Programació amb bitbloq III
- 9 Sessió 7. Programació amb l'Arduino IDE I
- 10 Sessió 8. Programació el Zowi escollint la placa. Accedint als components individuals
- 11 Sessió 9. Aplicació Android: Programació amb Protocoder
- 12 Sessió 10. Impressora 3D
- 13 Sessió 11. Impressora 3D: tunejar el Zowi
Sessió 1. Arduino. Introducció. Encendre i apagar el LED
Objectiu
- Què és Arduino?
- Entorn de desenvolupament (IDE)
- Primer experiment: encendre i apagar un LED
Desenvolupament
Què és Arduino?
Getting Started with Arduino:
Powerpoint:
- IntrotoArduino.ppt
Hola Món de l'Arduino: encendre i apagar un LED
- https://www.arduino.cc/en/Tutorial/Blink
- fitxer hola_mon_arduino_led_v1.ino
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
*/
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin 13 as an output.
pinMode(13, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Ara farem una petita modificació d'aquest exemple. Farem servir un interruptor per encendre i apagar el LED. El pin on connectem el LED s'haurà de definir com a pin de sortida. El pin on tenim l'interruptor s'haurà de definir com a pin d'entrada.
- https://www.arduino.cc/en/Tutorial/Button
- fitxer hola_mon_arduino_led_v1.ino
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
*/
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin
int buttonState = 0; // variable for reading the pushbutton status
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin 13 as an output.
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}
// the loop function runs over and over again forever
void loop() {
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
} else {
// turn LED off:
digitalWrite(ledPin, LOW);
}
}
Sessió 2. Interactuar amb Python des de l'Arduino. Encendre i apagar el LED. LED RGB
Referències
Objectius
Els alumnes, en la primera part del curs, han fet una introducció a la programació amb Python. L'objectiu és que els alumnes, des dels seus ordinadors, puguin interactuar amb l'Arduino utilitzant Python. La solució que es dóna té l'avantatge de què des dels diferents ordinadors podem interactuar amb una sola placa d'Arduino, i això fa possible poder fer la pràctica tenint en compte el temps limitat que tenim. Tanmateix, conceptes com la programació de sockets s'escapen del nivell que han d'assolir els alumnes. La idea és que fem servir la xarxa local de l'institut per comunicar-nos amb l'Arduino (a l'Arduino li afegim un Ethernet Shield que li proporciona una IP).
- objectiu 1: Interruptor. Encendre i apagar un LED (output) amb un interruptor (input).
- objectiu 2: Cada alumne tindrà un LED, i podrà encendre i apagar el LED des del seu script python.
- objectiu 3: Tenim un LED RGB, i podrem canviar el color del LED des d'un script python.
Botó i LED. Encendre i apagar el LED amb un botó (pulsador)
Muntarem la configuració d'aquest exemple:
led_boto_v1.ino:
**************************/
/* Encendre el LED amb un botó pulsador */
/**************************/
int pulsador=0; //emmagatzema l'estat del pulsador
void setup() {
pinMode(2, OUTPUT); //declarem el pin 2 com a sortida
pinMode(4, INPUT); //declarem el pin 4 com a entrada
}
void loop() {
pulsador = digitalRead(4); //llegim l'estat del botó
if(pulsador==HIGH) { //si estem pitjant el botó...
digitalWrite(2, HIGH); //s'encén el led
}
else{ //si no estem pitjant...
digitalWrite(2, LOW); //s'apaga el led
}
}
LED RGB
LED RGB. Configuració bàsica
Per mostrar el funcionament bàsic d'un LED RGB podem fer servir el següent codi: LED_RGB_v1.ino
/*
* | | | |
* | |
* |
* g r t b
* /
*/
/*-----Declaracion de variables para cada color R G B-----*/
int rled = 11; // Pin PWN 11 para led rojo
int bled = 10; // Pin PWM 10 para led azul
int gled = 9; // Pin PWM 9 para led verde
/*----Declaracion de variables auxiliares-----*/
int i; // Variable para ciclos repetitivos
int repeat = 5; // Variables para cantidad limite de repeticiones
void setup() {
/*----- Se inicializan pines PWM como salida*/
pinMode(rled, OUTPUT);
pinMode(bled, OUTPUT);
pinMode(gled, OUTPUT);
}
void loop() {
for(i=0; i<repeat; i++) //Se repite la ejecucion de la funcion rgbon() "repeat" veces
rgbon();
delay(1000); //Se espera 1 segundo
colors('y'); //Se enciende el LED en color amarillo (y de yellow)
delay(1000);
colors('o'); //Se enciende el LED en color naranko (o de orange)
delay(1000);
colors('p'); //Se enciende el LED en color rosado (p de pink)
delay(1000);
}
/*-----Funcion para mostrar colores principales cada 500 ms-----*/
void rgbon(){
analogWrite(rled,255); // Se enciende color rojo
delay(500); // Se esperan 500 ms
analogWrite(rled,0); // Se apaga color rojo
analogWrite(bled,255); // Se enciende color azul
delay(500); // Se esperan 500 ms
analogWrite(bled,0); // Se apaga color azul
analogWrite(gled,255); // Se enciende color verde
delay(500); // Se esperan 500 ms
analogWrite(gled,0); // Se apaga colo verde
}
/*-----Funcion que permite escoger entre color amarillo, naranjo o rosado-----*/
void colors(char color){ //La funcion recibe un parametro que se guarda en variable color
switch(color){ //Se compara variable color con dato guardado
case 'y': analogWrite(rled,255); // Si color == 'y' se enciende color amarillo
analogWrite(gled,255); // Mezclando r = 255 / g = 255 / b = 0
analogWrite(bled,0);
break;
case 'o': analogWrite(rled,255); // Si color == 'o' se enciende color naranjo
analogWrite(gled,180); // Mezclando r = 255 / g = 180 / b = 0
analogWrite(bled,0);
break;
case 'p': analogWrite(rled,255); // Si color == 'p' se enciende color rosado
analogWrite(gled,0); // Mezclando r = 255 / g = 0 / b = 255
analogWrite(bled,255);
break;
}
}
Comunicació amb sockets. Arduino i script Python. Encendre i apagar el LED
El script que necessitem en l'arduino i en l'ordinador estan en el següent enllaç:
Instal.lació Python a Windows
Descarreguem el Python de:
- www.python.org/downloads/release/python-351/
Inici > Programas > Python 3.5 > Python 3.5 (32-bit)
El directori d'instal.lació és:
- C:\Users\super\AppData\Local\Programs\Python\Python35-32\python.exe
Per tant,
cmd.exe cd C:\Users\super\AppData\Local\Programs\Python\Python35-32
i ara ja podem executar el script:
python.exe C:\Users\super\python_client_socket_led.py
Respecte la versió de Linux, la funció print() obligatòriament ha d'anar entre parèntesi.
print (data)
He d'instal.lar a Windows la llibreria socket de Python.
Comunicació amb sockets. Arduino i script Python. LED RGB
Sessió 3. Sensors. Fotoresistència (LDR). Tractament de les dades: gràfic
Input al Playground d'Arduino:
La prova bàsica per comprovar una fotoresistència:
analog_ldr.ino:
/* Simple test of the functionality of the photo resistor
Connect the photoresistor one leg to pin 0, and pin to +5V
Connect a resistor (around 10k is a good value, higher
values gives higher readings) from pin 0 to GND. (see appendix of arduino notebook page 37 for schematics).
----------------------------------------------------
PhotoR 10K
+5 o---/\/\/--.--/\/\/---o GND
|
Pin 0 o-----------
----------------------------------------------------
*/
int lightPin = 0; //define a pin for Photo resistor
int ledPin=11; //define a pin for LED
void setup()
{
Serial.begin(9600); //Begin serial communcation
pinMode( ledPin, OUTPUT );
}
void loop()
{
Serial.println(analogRead(lightPin)); //Write the value of the photoresistor to the serial monitor.
analogWrite(ledPin, analogRead(lightPin)/4); //send the value to the ledPin. Depending on value of resistor
//you have to divide the value. for example,
//with a 10k resistor divide the value by 2, for 100k resistor divide by 4.
delay(10); //short delay for faster response to light.
}
Anem a llegir amb un script de python els valors d'una LDR en l'Arduino. Farem servir sockets com ja havíem fet:
arduino_server_socket_ldr.ino:
/*
PhotoR 10K
+5 o---/\/\/--.--/\/\/---o GND
|
Pin 0 o-----------
----------------------------------------------------
*/
int lightPin = 0; //define a pin for Photo resistor
int valorldr;
#include <Ethernet.h> //Load Ethernet Library
#include <EthernetUdp.h> //Load UDP Library
#include <SPI.h> //Load the SPI Library
byte mac[] = { 0x9A, 0xA2, 0xDA, 0x00, 0x0A, 0xDC };
IPAddress ip(192, 168, 1, 140); //Assign my IP adress
unsigned int localPort = 5000; //Assign a Port to talk over
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
String datReq; //String for our data
int packetSize; //Size of Packet
EthernetUDP Udp; //Define UDP Object
void setup() {
Serial.begin(9600); //Turn on Serial Port
Ethernet.begin(mac, ip); //Initialize Ethernet
Udp.begin(localPort); //Initialize Udp
delay(1500); //delay
}
void loop() {
packetSize = Udp.parsePacket(); //Read theh packetSize
if(packetSize>0){ //Check to see if a request is present
Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE); //Reading the data request on the Udp
String datReq(packetBuffer); //Convert packetBuffer array to string datReq
//Serial.println(datReq);
valorldr = analogRead(lightPin);
Serial.println(valorldr); //Write the value of the photoresistor to the serial monitor.
Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); //Initialize Packet send
Udp.print(valorldr); //Send string back to client
Udp.endPacket(); //Packet has been sent
delay(1000);
}
memset(packetBuffer, 0, UDP_TX_PACKET_MAX_SIZE);
}
lectura_ldr.py:
#aquest codi s'ha de millorar, no té massa sentit obrir i tancar el fitxer cada vegada
from socket import *
import time
address = ( '192.168.1.140', 5000) #Defind who you are talking to (must match arduino IP and port)
client_socket = socket(AF_INET, SOCK_DGRAM) #Set Up the Socket
client_socket.settimeout(1) #only wait 1 second for a response
filename="fitxer.txt"
print "Opening the file..."
print "Anem a llegir els valors del sensor LDR\n"
while(1): #Main Loop
data = "lectura"
client_socket.sendto(data, address) #send command to arduino
try:
rec_data, addr = client_socket.recvfrom(2048) #Read response from arduino
print rec_data #Print the response from Arduino
target = open(filename, 'a')
target.write(rec_data)
target.write('\n')
target.close()
except:
pass
El resultat és que obtenim un fitxer de text, fitxer.txt, amb les dades de la resistència. Aquestes dades les podem dibuixar amb un programa com per exemple Excel o Calc. Podem visualitzar com ha anat variant la lluminositat al llarg del dia, de forma suau (matí, migdia, tarda, capvespre, nit).
Sessió x. Actuadors. Solenoide, relé, motor DC, motor pas a pas, servomotor. Sensors i actuadors. Domòtica
Output al playground d'Arduino:
Sessió 4. Robòtica. Introducció. Robot Zowi
Sessió 5. Estudiem el robot Zowi. Característiques. Recursos
DIWO, escola maker:
- http://diwo.bq.com/
- Aprende
- Construye
- Cursos
- Productos
El Zowi:
Sessió 5. Programació amb bitbloq I
Aprèn robòtica i programació amb bitbloq 2:
És una col.lecció de 23 lliçons:
- Lección 1: Antes de empezar con Bitbloq 2
- Lección 2: Conociendo bitbloq 2
- Lección 3: ¿Qué es un robot? Conociendo los sensores y actuadores
- Lección 4: Y la luz se hizo: programando los LED en bitbloq 2
- Lección 5: Las sentencias condicionales y el pulsador.
- Lección 6: Comunicándose con otros dispositivos. El puerto serie.
- Lección 7: Programando con variables en bitbloq 2
- Lección 8: ¡Aprende a pensar como un robot! Los algoritmos
- Lección 9: Piruru piii… Programando el zumbador
- Lección 10: El sensor infrarrojo.
- Lección 11: Programando el potenciómetro con bitbloq 2
- Lección 12: Programando el sensor de luz
- Lección 13: los bucles de control
- Lección 14: el miniservo
- Lección 15: El servo de rotación continua
- Lección 16: La máquina de estados.
- Lección 17: El sensor de ultrasonidos.
- Lección 18: Las funciones sin retorno
- Lección 19: Las funciones con retorno.
- Lección 20: La lógica booleana
- Lección 21: La pantalla LCD y Bitbloq 2
- Lección 22: El joystick
- Lección 23: Creando melodías con Bitbloq 2
Bitbloq és una aplicació web per programar amb les plaques d'arduino Zum Core, i amb el robot Zowi. Per entrar al bitbloq (ha de ser amb el Chrome):
La instal.lació i configuració del bitbloq s'explica aquí:
En aquesta sessió es farà una introducció a la programació amb Bitbloq. Només disposem d'una placa Zum Core, i anirà bé per fer la demostració. Farem i explicarem l'exemple més senzill (Lección 4)
Aquest exemple és el més senzill de tots. Hem utilitzat blocs gràfics per programar, però també podem veure el codi:
/*** Included libraries ***/
/*** Global variables and function definition ***/
int led_0 = 13;
/*** Setup ***/
void setup() {
pinMode(led_0, OUTPUT);
}
/*** Loop ***/
void loop() {
digitalWrite(led_0, HIGH);
delay(1000);
digitalWrite(led_0, LOW);
delay(1000);
}
Un cop funcionat, ara podem fer un exemple senzill amb el robot Zowi. Per exemple, programar l'array per canviar les cares del Zowi. La idea és la mateixa.
NOTA. En el Zum Core s'utilitza una codificació de colors que fa que sigui difícil equivocar-se.
Programar els robots amb el bitbloq
Com que tenim 4 robots, ara els alumnes sí que podran treballar i fer el seu primer programa amb el robot. Si no dóna temps, la setmana vinent.
Els alumnes no han de tenir por d'equivocar-se amb la programació, doncs sempre podrem restaurar el software original del robot.
El millor per veure exemples és anar a Explorar, i filtrar per Zowi. Per exemple, ens fixem en el projecte Zowi se asusta o se alegra, i veiem com estan programats els blocs.
Amb Zowi i el bitbloq també podem declarar funcions:
El primer objectiu pot ser, per exemple, que:
- quan el Zowi escolti un soroll, mostri una cara de sorpres
- quan detecti una distància menor que 15cm, camini un pas.
Recordatori: protocol per programar amb Bitbloq
A classe tenim instal.lat el SO Ubuntu. Recordem que hem de fer servir el navegador Chrome per programar amb el Bitbloq.
- Entrarem a l'ordinador com a super-usuari (el professor posarà la contrasenya). Això és important perquè per accedir a la placa arduino es necessiten permisos especials.
- Després connectem el Zowi a l'ordinador amb el cable USB. Hem d'arrencar el robot (algun alumne se'n descuidava).
- Moltes vegades el bitbloq no reconeix que està instal.lat el programa web2board. Aquest programa és essencial perquè és el responsable d'enviar el codi de programació des de la pàgina web a la placa Arduino del Zowi. En realitat web2board sí que està instal.lat. El que hem de fer és obrir un terminal (pantalla negra) i cridar executar aquest programa (i no tancar la finestra):
$ web2board
En condicions normals això no s'hauria de fer, i hauríem de veure com s'obre automàticament una finestra de terminal.
- Per veure que tot funciona, compilem i pugem un programa (encara que sigui buit). N'hi ha prou en arrossegar el Zowi al mig de la pantalla. Compilem (un programa que no fa res no ha de donar cap error de compilació). Pugem el programa a la placa. Si puja amb èxit, vol dir que tot ho tenim ben configurat.
És important seguir aquests passos, doncs aleshores ja ens podem concentrar en la programació, que és el que ens interessa.
Sessió 6. Programació amb bitbloq II
La setmana passada vam fer una introducció al bitbloq i la programació amb Zowi. En aquesta sessió els alumnes programaran els 4 Zowi's de què disposem, i hauran d'acomplir els següents objectius:
Per la setaman vinent, prepara una melodia. (TODO).
Sessió 7. Programació amb bitbloq III
Música
El dia anterior alguns alumnes ja van estar provar de fer sonar algunes notes. Avui farem una melodia, però seguint l'esquema descrit a
És a dir, declararem variables i declararem funcions. I en el bucle principal farem crides a les funcions que executen els compassos.
Començarem programant amb blocs, però de seguida anirem a la pestanya codi, i acabarem d'escriure el programa picant el codi.
Proposta de cançons: himne del Barça:
Matriu de LEDs
Amb el Zowi és fàcil programar la matriu de LEDs de la boca. Per exemple, podem posar el bloc Mostra un somriure a la teva boca. I podem mirar el codi corresponent:
/*** Included libraries ***/
#include <BitbloqZowi.h>
#include <BitbloqUS.h>
#include <BitbloqBatteryReader.h>
#include <BitbloqLedMatrix.h>
#include <Servo.h>
#include <BitbloqOscillator.h>
#include <EEPROM.h>
/*** Global variables and function definition ***/
Zowi zowi;
/*** Setup ***/
void setup() {
zowi.init();
zowi.putMouth(smile_code, false);
}
/*** Loop ***/
void loop() {}
On està deifinica la funció putMouth i el paràmetre smile_code. Concretament:
#include <BitbloqLedMatrix.h>
$ locate BitbloqZowi.h /home/joan/Arduino/libraries/BitbloqLedMatrix/BitbloqZowi.h
i dins les llibreries d'Arduino existeix el fitxer Arduino/libraries/BitbloqZowi/Zowi_mouths.h
i aquí trobem la línia:
#define smile_code 0b00000000100001010010001100000000 ... #define zero_code 0b00001100010010010010010010001100
Per exemple, en aquesta llibreria també trobem el moviment:
void moonwalker(float steps=1, int T=900, int h=20, int dir=LEFT);
Els símbols queden definits per 4 bytes (4x8=32 bits). Però la matriu de LEDs és de 6x5=30 bits. N'hi ha prou en descartar els dos primers bits. Descartem els dos primers bits (queden 30 bits), i tenim 5 grups de 6 bits:
El número zero 00001100 01001001 00100100 10001100 001100 010010 010010 010010 001100 El símbol de smile: 00000000 10000101 00100011 00000000 000000 100001 010010 001100 000000
Si volem crear una nova icona, de fet no cal tocar aquests fitxers. Quan estem en els blocs, a código > Escribe tu propio código puc ficar:
zowi.putMouth(smile_code, false);
i també puc ficar directament el codi amb bits:
zowi.putMouth(0b00000100001100000100000100001110, false);
Per definir una nova icona, com per exemple quadrat_negre, he d'anar a Zowi_mouths.h:
#define quadrat_negre_code 0b11111111111111111111111111111111 ... #define quadrat_negre 31
i a BitbloqZowi.cpp, he d'actualitzar la matriu de la línia 670:
unsigned long int Zowi::getMouthShape(int number){
unsigned long int types []={zero_code,one_code,two_code,three_code,four_code,five_code,six_code,seven_code,eight_code,
nine_code,smile_code,happyOpen_code,happyClosed_code,heart_code,bigSurprise_code,smallSurprise_code,tongueOut_code,
vamp1_code,vamp2_code,lineMouth_code,confused_code,diagonal_code,sad_code,sadOpen_code,sadClosed_code,
okMouth_code, xMouth_code,interrogation_code,thunder_code,culito_code,angry_code,quadrat_negre};
i ara ja puc escriure el meu codi amb la nova icona:
zowi.putMouth(quadrat_negre_code, false);
Quan compili no donarà error.
De la mateixa manera que puc definir noves icones, també puc definir noves animacions (com a conjunt de gestos de cara i sons), i definir nous gestos de cara (getAnimShape)
Exemple amb la matriu de LEDs
/*** Included libraries ***/
#include <BitbloqZowi.h>
#include <BitbloqUS.h>
#include <BitbloqBatteryReader.h>
#include <BitbloqLedMatrix.h>
#include <Servo.h>
#include <BitbloqOscillator.h>
#include <EEPROM.h>
/*** Global variables and function definition ***/
Zowi zowi;
/*** Setup ***/
void setup() {
zowi.init();
}
/*** Loop ***/
void loop() {
if (digitalRead(PIN_AButton) == 1) {
zowi.sing(S_sad);
zowi.putMouth(475120656, false); //P
delay(500);
zowi.putMouth(507634718, false); //E
delay(500);
zowi.putMouth(475121172, false); //R
delay(500);
zowi.putMouth(507634718, false); //E
delay(500);
zowi.putMouth(0, false); //pantalla blanca
}
if (digitalRead(PIN_BButton) == 1) {
zowi.sing(S_surprise);
zowi.putMouth(458576977, false); //M
delay(500);
zowi.putMouth(206169234, false); //A
delay(500);
zowi.putMouth(475121172, false); //R
delay(500);
zowi.putMouth(134251016, false); //I
delay(500);
zowi.putMouth(206169234, false); //A
delay(500);
zowi.putMouth(0, false); //pantalla blanca
}
Sessió 7. Programació amb l'Arduino IDE I
Dins del bitbloq el normal és programar amb blocs. Però si vull programar amb codi també ho puc fer, però aleshores ja no puc tornar als blocs.
Si el que volem és programar amb processing, de fet no cal fer servir el Arduino IDE. Amb el bitbloq també podem programar amb processing. Per exemple, explorant projectes dins de l'entorn del bitbloq hem trobat el següent projecte per al Zowi:
The Imperial March Intro (Darth Vader's Theme):
/*** Included libraries ***/
#include <BitbloqZowi.h>
#include <BitbloqUS.h>
#include <BitbloqBatteryReader.h>
#include <BitbloqLedMatrix.h>
#include <Servo.h>
#include <BitbloqOscillator.h>
#include <EEPROM.h>
/*** Global variables and function definition ***/
Zowi zowi;
float tiempo = 0;
float tono = 0;
// frequency definition of musical notes
const int c = 261;
const int d = 294;
const int e = 329;
const int f = 349;
const int g = 391;
const int gS = 415;
const int a = 440;
const int aS = 455;
const int b = 466;
const int cH = 523;
const int cSH = 554;
const int dH = 587;
const int dSH = 622;
const int eH = 659;
const int fH = 698;
const int fSH = 740;
const int gH = 784;
const int gSH = 830;
const int aH = 880;
// play a note
void beep(int note, int duration) {
//Play tone on buzzerPin
tone(10, note, duration);
delay(duration);
delay(20);
}
void firstSection() {
beep(a, 500);
beep(a, 500);
beep(a, 500);
beep(f, 350);
beep(cH, 150);
beep(a, 500);
beep(f, 350);
beep(cH, 150);
beep(a, 650);
delay(500);
beep(eH, 500);
beep(eH, 500);
beep(eH, 500);
beep(fH, 350);
beep(cH, 150);
beep(gS, 500);
beep(f, 350);
beep(cH, 150);
beep(a, 650);
delay(500);
}
void variant1() {
beep(f, 250);
beep(gS, 500);
beep(f, 350);
beep(a, 125);
beep(cH, 500);
beep(a, 375);
beep(cH, 125);
beep(eH, 650);
delay(500);
}
void secondSection() {
beep(aH, 500);
beep(a, 300);
beep(a, 150);
beep(aH, 500);
beep(gSH, 325);
beep(gH, 175);
beep(fSH, 125);
beep(fH, 125);
beep(fSH, 250);
delay(325);
beep(aS, 250);
beep(dSH, 500);
beep(dH, 325);
beep(cSH, 175);
beep(cH, 125);
beep(b, 125);
beep(cH, 250);
delay(350);
}
void variant2() {
beep(f, 250);
beep(gS, 500);
beep(f, 375);
beep(cH, 125);
beep(a, 500);
beep(f, 375);
beep(cH, 125);
beep(a, 650);
delay(500);
}
/*** Setup ***/
void setup() {
zowi.init();
zowi.home();
}
/*** Loop ***/
void loop() {
if (zowi.getDistance() < 10) {
//Play first section
firstSection();
//Play second section
secondSection();
//Variant 1
variant1();
//Repeat second section
secondSection();
//Variant 2
variant2();
}
zowi.putMouth(smile_code, false);
}
Quan acostem la mà sona la marxa del Dart Vader.
Sessió 8. Programació el Zowi escollint la placa. Accedint als components individuals
Anem a programar amb els components del Zowi. Però en comptes d'escollir en el bitbloq el Zowi, anem a escollir directament la placa. La sorpresa és que la placa bq ZUM no la reconeix (és la que ens pensàvem que portava incorporat el Zowi). I en canvi sí que reconeix les altres dues: Freeaduino UNO i Arduino UNO. Escollim Freeaduino UNO.
El Zowi té els següent components, als quals podem accedir: zumbador, botons A i B, sensor d'ultrasons, 4 servos i matriu de LEDs. Anem a accedir individualment a aquests components.
Si obrim el Zowi podem resseguir els cables i veure a quins pins estan connectats. L'altre possibilitat és anar provant els diferents pins.
Després d'investigar una mica ja tenim identificats els pins on estan connectats els components del Zowi. L'objectiu de la pràctica és comprovar el funcionament d'aquests pins individuals, programar-los amb un petit exercici, i també veure el codi associat.
- brunzidor: pin 10 (digital). Exercici: fer l'escala musical.
void loop() {
tone(brunzidor_0, 261, 500);
tone(brunzidor_0, 263, 500);
}
- botó A: pin 6 (digital). Exercici: quan cliquem el botó A, fer sonar una nota (veure gràfic). Hem d'utilitzar un if
void loop() {
if (digitalRead(boto_0) == true) {
tone(brunzidor_0, 261, 200);
delay(200);
}
}
- botó B: pin 7 (digital). Exercici: quan cliquem A+B, fer sonar una nota. Hem d'utilitzar un if on a dins hi ha un and. Com es fa un and amb blocs?
- sensor d'ultrasons. Un sensor d'ultrasons consta d'un emissor i d'un receptor. És una sortida i una entrada digitals que hem de saber en quins pins connectar. Solució: TRI: pin8; ECH: pin9.
Exercici1: el primer que farem és utiltizar un component nou que és el port sèrie. Veiem que el port sèrie es connecta automàticament per USB a la placa. Existeix un bloc que és Port Sèrie Envia (Llegeix sensor_ultrasons) Amb salt de línia. El que pretenem es enviar la lectura del sensor d'ultrasons, a través del port sèrie, a la consola del bitbloq. Aquesta consola la podem accedir mitjançant la pestanya Mostra > Mostra la Consola.
bqSoftwareSerial port_serie_0(0, 1, 9600);
void loop() {
port_serie_0.println(ultrasons_0.read());
}
Exercici2: Si el valor del sensor és més petit que 10, fés sonar el brunzidor. Programa els blocs i després mira el codi:
void loop() {
if (ultrasons_0.read() <= 10) {
tone(brunzidor_0, 261, 50);
delay(50);
}
}
- Programar els servos. El Zowi té 4 servos, que estan associats als següents pins:
- pin2: servo del maluc de la cama esquerra
- pin3: servo del maluc de la cama dreta
- pin4: servo del genoll de la cama esquerra
- pin5: servo del genoll de la cama dreta
Podem programar tant un servo continu com un servo normal.
Exercici: Fés girar el servo (servo_continu_0) en sentit horari, espera 200 ms, Fés girar el servo (servo_continu_0) en sentit anti-horari, espera 200ms. Si fiquem aquesta informació en el loop, el servo no pararà de moure's. És més intel.ligen dir que faci el moviment responent a una determinada acció, com ara acostar la mà al sensor d'ultrasons.
//associa un servo al pin 2 servo_continu_0.attach(2); //Fés girar el servo en sentit horari durant 200ms servo_continu_0.write(180); delay(200); //Fés girar el servo en sentit anti-horari durant servo_continu_0.write(0); delay(200);
També podem utilitzar els servos amb el component servo (servo normal), i aleshores podem especificar el número de graus que volem que es mogui.
Exercici2: fer moure el servo 90 graus, esperar 1 segon, -90 graus, esperar 1 segon. Si fem que l'espera sigui inferior a 1 segon, no té temps de realitzar el moviment de 90 graus.
void loop() {
servo_0.write(90);
delay(1000);
servo_0.write(-90);
delay(1000);
}
Exercici 3. Ara que ja sabem controlar el moviment dels servos, si volem fer caminar el Zowi hem de pensar quina combinació de moviments dels servos és la que fa avançar el Zowi. Ara bé, sàpigues que fer moure un robot de forma natural és molt difícil. ÉS un dels reptes de la robòtica.
Resumint, hem utilitzat aquests pins de la placa Arduino per accedir als components del Zowi:
pin 2: servo del maluc de la cama esquerra pin 3: servo del maluc de la cama dreta pin 4: servo del genoll de la cama esquerra pin 5: servo del genoll de la cama dreta pin 6: botó A pin 7: botó B pin 8: sensor ultrasons (TRI) pin 9: sensor ultrasons (ECH) pin 10: brunzidor
I els altres pins? El pin 0 i pin 1 és on està connectat internament el mòdul de bluetooth. Quan faci proves de connexió amb bluetooth, faré servir aquests pins.
I la matriu de LEDs
Programar directament la matriu de LEDs està fora del nostre abast. La matriu de LEDs està connectada a la placa mitjançant el protocol ICSP. La idea és que el programa envia unes comandes on hi ha codificat els LEDs que s'han d'encendre. Els pins dels connector ICSP els pots veure en aquesta imatge. http://gammon.com.au/images/ArduinoUno_R3_Pinouts.png
Sessió 9. Aplicació Android: Programació amb Protocoder
- http://diwo.bq.com/introduccion-a-protocoder-y-hola-mundo/
- http://diwo.bq.com/domotica-con-protocoder-parte-i/
La idea és que amb la placa Zum Core, o bé directament amb el robot, puguem llegir algun sensor, i poder llegir els valors del sensor directament al dispositiu Android (mòbil o tauleta) a través de Bluetooth.
Sessió 10. Impressora 3D
Sessió 11. Impressora 3D: tunejar el Zowi
creat per Joan Quintana Compte, gener 2016
