Per començar, instal·la Processing 4 seguint aquests passos:
Ara, instal·la Arduino IDE seguint aquests passos:
Ara hauries de tenir Processing 4 i Arduino IDE instal·lats i llestos per utilitzar.
Abans de començar a utilitzar Arduino amb Processing, és important assegurar-se que el port i la placa estiguin configurats correctament:
Aquí tens un codi en Processing que permet encendre i apagar un LED a l'Arduino Uno quan es prem la tecla "H" i "L", respectivament:
import processing.serial.*;
Serial myPort; // Objecte Serial per comunicar-se amb l'Arduino
char state = 'L'; // Inicialitzem l'estat del LED com a apagat (L)
void setup() {
size(200, 200);
// Inicialitzem la connexió sèrie amb l'Arduino
String portName = "COM3"; // Canvia-ho pel teu port Arduino
myPort = new Serial(this, portName, 9600);
}
void draw() {
// Dibuixa alguna cosa a la finestra, si és necessari
}
void keyPressed() {
if (key == 'H') {
// Envia 'H' a l'Arduino quan es prem la tecla "H" per encendre el LED
myPort.write('H');
state = 'H'; // Actualitza l'estat del LED
} else if (key == 'L') {
// Envia 'L' a l'Arduino quan es prem la tecla "L" per apagar el LED
myPort.write('L');
state = 'L'; // Actualitza l'estat del LED
}
}
void serialEvent(Serial myPort) {
// Llegeix les dades enviades des de l'Arduino
String val = myPort.readStringUntil('\n').trim();
println("Dades rebudes de l'Arduino: " + val);
// Aquí pots afegir més lògica si cal processar les dades rebudes de l'Arduino
}
Ara, aquí tens un exemple senzill de codi Arduino que controla un LED mitjançant les dades rebudes de Processing:
int ledPin = 13; // Defineix el pin digital on està connectat el LED
void setup() {
pinMode(ledPin, OUTPUT); // Configura el pin com a sortida
Serial.begin(9600); // Inicia la comunicació sèrie
}
void loop() {
if (Serial.available() > 0) {
char command = Serial.read(); // Llegeix el caràcter rebut
if (command == 'H') {
digitalWrite(ledPin, HIGH); // Encén el LED quan rep 'H'
} else if (command == 'L') {
digitalWrite(ledPin, LOW); // Apaga el LED quan rep 'L'
}
}
int sensorValue = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
sensorValue = analogRead(A0); // Llegir el valor del sensor LDR connectat a l'entrada analògica A0
Serial.println(sensorValue); // Enviar el valor a Processing
delay(100); // Espera una mica per a evitar la sobrecàrrega del port sèrie
}
import processing.serial.*;
Serial port;
int paletaY;
int ampladaPaleta = 10;
int alcadaPaleta = 100;
void setup() {
size(800, 400);
port = new Serial(this, Serial.list()[0], 9600); // Canvia l'índex si és necessari
paletaY = (height - alcadaPaleta) / 2;
}
void draw() {
background(0);
// Llegir el valor del sensor LDR des d'Arduino
if (port.available() > 0) {
String valor = port.readStringUntil('\n');
if (valor != null) {
valor = trim(valor);
int sensorValue = int(valor);
// Mappeja el valor del sensor a la posició de la paleta
paletaY = int(map(sensorValue, 0, 1023, 0, height - alcadaPaleta));
}
}
// Dibuixa la paleta
fill(255);
rect(10, paletaY, ampladaPaleta, alcadaPaleta);
}
Aquesta pàgina proporciona el codi per crear un joc de ping pong amb una sola paleta controlada per un sensor LDR. Aquí tens una descripció dels components clau:
Aquest codi s'executa a l'Arduino i llegeix el valor del sensor LDR connectat a l'entrada analògica A0. Envia aquest valor a la computadora a través del port serial.
Aquest codi s'executa a la computadora i rep les lectures del sensor LDR des de l'Arduino a través del port serial. Utilitza aquestes lectures per controlar la posició de la paleta en una finestra gràfica. La paleta es mou verticalment segons les lectures del sensor LDR.
Amb aquests dos codis i una connexió sèrie entre l'Arduino i la computadora, podràs controlar una paleta de ping pong mitjançant un sensor LDR.
//CODI Arduino
// Definim el pin PWM on connectem el LED
#define LED_PIN 9
// Definim les variables per a guardar el valor del LED i el byte rebut
int ledValue = 0;
byte receivedByte;
void setup() {
// Iniciem la comunicació serial a 9600 bauds
Serial.begin(9600);
// Establim el pin del LED com a sortida
pinMode(LED_PIN, OUTPUT);
}
void loop() {
// Comprovem si hi ha dades disponibles al port serial
if (Serial.available() > 0) {
// Llegim el byte rebut
receivedByte = Serial.read();
// Si el byte és '+' augmentem el valor del LED en 10 unitats
if (receivedByte == '+') {
ledValue = ledValue + 10;
// Si el valor supera el màxim de 255, el fixem a 255
if (ledValue > 255) {
ledValue = 255;
}
}
// Si el byte és '-' disminuïm el valor del LED en 10 unitats
if (receivedByte == '-') {
ledValue = ledValue - 10;
// Si el valor és inferior al mínim de 0, el fixem a 0
if (ledValue < 0) {
ledValue = 0;
}
}
// Enviem el valor del LED al port serial per a mostrar-lo al monitor
Serial.println(ledValue);
// Establim el valor del LED com a senyal PWM al pin corresponent
analogWrite(LED_PIN, ledValue);
}
}
//CODI Processing
// Importem la llibreria de comunicació serial
import processing.serial.*;
// Definim una variable per a guardar l'objecte Serial
Serial myPort;
void setup() {
// Iniciem una finestra de 200x200 píxels
size(200, 200);
// Obtenim la llista de ports disponibles i mostrem el primer
println(Serial.list());
// Creem un nou objecte Serial amb el primer port i la mateixa velocitat que l'Arduino
myPort = new Serial(this, Serial.list()[0], 9600);
}
void draw() {
// No fem res al bucle principal
}
void keyPressed() {
// Quan es prem una tecla, comprovem si és '+' o '-'
if (key == '+' || key == '-') {
// Si és així, enviem el caràcter al port serial per a que l'Arduino el rebi
myPort.write(key);
}
}
Aquí hi ha algunes pràctiques possibles que podeu fer amb un LED, Arduino Uno i Processing 4:
Et dono els dos codis per copiar i pegar. El primer és el codi de Processing, que s’encarrega de capturar la imatge de la webcam, detectar les cares i enviar una senyal a Arduino. El segon és el codi d’Arduino, que s’encarrega de rebre la senyal i encendre o apagar el LED. Aquí els tens:
// Codi de Processing
import processing.serial.*; // Importem la biblioteca Serial per comunicar-nos amb Arduino
import gab.opencv.*; // Importem la biblioteca OpenCV per fer visió per ordinador
OpenCV opencv; // Creem un objecte OpenCV
Serial port; // Creem un objecte Serial
PImage src; // Creem una variable per guardar la imatge de la webcam
boolean faceDetected = false; // Creem una variable per indicar si s'ha detectat una cara o no
void setup() {
size(640, 480); // Definim la mida de la finestra
opencv = new OpenCV(this, 640, 480); // Inicialitzem l'objecte OpenCV amb la mateixa mida que la finestra
opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE); // Carreguem el fitxer XML que conté les característiques de les cares humanes
port = new Serial(this, Serial.list()[0], 9600); // Inicialitzem l'objecte Serial amb el primer port disponible i una velocitat de 9600 bauds
}
void draw() {
src = opencv.getSnapshot(); // Capturem la imatge de la webcam
image(src, 0, 0); // Mostrem la imatge a la finestra
opencv.loadImage(src); // Carreguem la imatge a l'objecte OpenCV
Rectangle[] faces = opencv.detect(); // Detectem les cares a la imatge
if (faces.length > 0) { // Si hi ha alguna cara...
faceDetected = true; // Actualitzem la variable faceDetected a true
for (int i = 0; i < faces.length; i++) { // Per cada cara detectada...
rect(faces[i].x, faces[i].y, faces[i].width, faces[i].height); // Dibuixem un rectangle al voltant de la cara
}
} else { // Si no hi ha cap cara...
faceDetected = false; // Actualitzem la variable faceDetected a false
}
port.write(faceDetected ? '1' : '0'); // Enviem un '1' o un '0' a Arduino segons el valor de faceDetected
}
// Codi d'Arduino
int ledPin = 13; // Definim el pin on està connectat el LED
char data; // Creem una variable per guardar les dades rebudes per serial
void setup() {
pinMode(ledPin, OUTPUT); // Definim el pin del LED com a sortida
Serial.begin(9600); // Iniciem la comunicació serial a 9600 bauds
}
void loop() {
if (Serial.available() > 0) { // Si hi ha alguna dada disponible per serial...
data = Serial.read(); // Llegim la dada i la guardem a la variable data
if (data == '1') { // Si la dada és un '1'...
digitalWrite(ledPin, HIGH); // Encenem el LED
} else if (data == '0') { // Si la dada és un '0'...
digitalWrite(ledPin, LOW); // Apaguem el LED
}
}
}
Idea que val 33% de la nota trimestral. Es valora innovació i realització amb diferents biblioteques de Processing. Per exemple comptar les cares en un mòdul lunar concret pot servir per regular la quantitat d'oxigen disponible i diòxid de carboni expulsat que es proporcional al número de personed presents detectades com a cares.
No puc donar-te en aquest projecte els dos codis per copiar i enganxar, perquè això seria una forma de plagi i no et beneficiaria en el teu aprenentatge. El que et puc oferir és revisar els codis anteriors, una explicació del codi a realitzar i alguns recursos addicionals que et poden ajudar a entendre’l millor. Així podràs modificar-lo i adaptar-lo a les teves necessitats. 😊
La part de Processing és la que s'encarrega de capturar la imatge de la càmera, detectar les cares amb OpenCV i enviar el nombre de cares detectades a Arduino per al port serial. La part d'Arduino és la que rep el nombre de cares per al port serial i encén els LEDs corresponents amb el sensor de distància.
La part de Processing té les següents seccions:
- La primera secció és on importem les llibreries Serial i OpenCV, que ens permeten comunicar-nos amb Arduino i detectar les cares, respectivament. També creem els objectes Serial, OpenCV i numFaces, que representen el port serial, l'objecte OpenCV i el nombre de cares detectades.
- La segona secció és on definim la funció setup, que s'executa una sola vegada quan iniciem el programa. En aquesta funció, definim la mida de la finestra, iniciem la comunicació amb Arduino pel primer port disponible i amb una velocitat de 9600 bauds, iniciem l'objecte OpenCV amb la mateixa mida que la finestra i carreguem el classificador de cares que ve amb la llibreria OpenCV.
- La tercera secció és on definim la funció draw, que s'executa contínuament mentre el programa està en marxa. En aquesta funció, carreguem la imatge de la càmera a l'objecte OpenCV, mostrem la imatge de la càmera a la finestra, no omplim els rectangles que dibuixarem després, obtenim una llista de rectangles que representen les cares detectades amb OpenCV, actualitzem el valor de numFaces amb el nombre d'elements de la llista, enviem el valor de numFaces a Arduino per al port serial i dibuixem els rectangles al voltant de les cares detectades.
La part d'Arduino té les següents seccions:
- La primera secció és on definim les constants i variables que utilitzarem en el programa. Les constants són els pins on connectarem els LEDs i el sensor de distància, i les variables són el nombre de cares rebudes per al port serial i les distàncies mesurades pel sensor.
- La segona secció és on definim la funció setup, que s'executa una sola vegada quan iniciem el programa. En aquesta funció, iniciem la comunicació serial amb una velocitat de 9600 bauds i configurem els pins dels LEDs com a sortides.
- La tercera secció és on definim la funció loop, que s'executa contínuament mentre el programa està en marxa. En aquesta funció, comprovem si hi ha dades disponibles per al port serial, si n'hi ha llegim el valor i l'emmagatzemem a la variable numFaces, fem un bucle per a cada LED i comprovem si el seu número és menor o igual que el nombre de cares, si és així encenem el LED corresponent i si no l'apaguem, fem un altre bucle per a cada sensor i llegim la distància mesurada pel sensor corresponent i l'emmagatzemem a la variable distance[i], on i és l'índex del sensor, i finalment fem un altre bucle per a cada LED i comprovem si la distància mesurada pel sensor corresponent és menor que un llindar determinat, si és així apaguem el LED corresponent i si no el deixem com està.
Espero que aquesta explicació et sigui útil per al teu projecte. 😊
Millora el projecte, fes que soni musica depenent de la posició x,y de la cara, etc... Pots buscar el GitHub del professor explicat a Madrid el 2015 i altres exemples i millora'ls.
Arduino Project Hub ofereix una àmplia gamma de projectes i tutorials d'Arduino amb codi i instruccions pas a pas.
La pàgina oficial de Processing ofereix exemples i tutorials per ajudar-te a començar amb la programació creativa. També pots trobar exemples incorporats a totes les biblioteques que amplien enormement les possibilitats de Processing
Consulta Instructables Arduino per trobar una gran col·lecció de projectes d'Arduino amb guies detallades i vídeos.
Adafruit Learning System proporciona tutorials d'Arduino i electrònica en general, amb una varietat de projectes interessants.
Cerca tutorials d'Arduino i Processing a YouTube. Hi ha molts creadors de contingut que comparteixen projectes i tutorials en vídeo.
Explora preguntes i respostes sobre projectes d'Arduino i Processing als fòrums de comunitats, com ara el fòrum d'Arduino o el fòrum de Processing.
Explora apartat 'Microcontrollers' i sobre projectes d'Arduino i Processing de blocs XTEC del professor F. Pérez.