PROJECTES amb Arduino, amb Raspberry Pi i amb PC
Projecte 1A. Arduino amb PC: Tkinter+ESO32-S3+Leds
Codi Arduino
int pinLedR = 12; // Pin per al LED vermell (RGB)
int pinLedG = 13; // Pin per al LED verd (RGB)
int pinLedB = 14; // Pin per al LED blau (RGB)
int pinLedUV = 15; // Pin per al LED ultraviolat
int pinLedIR = 16; // Pin per al LED infraroig
int pinLDR = 17; // Pin per al sensor LDR
void setup() {
pinMode(pinLedR, OUTPUT);
pinMode(pinLedG, OUTPUT);
pinMode(pinLedB, OUTPUT);
pinMode(pinLedUV, OUTPUT);
pinMode(pinLedIR, OUTPUT);
pinMode(pinLDR, INPUT);
Serial.begin(9600); // Inicia la comunicació sèrie a 9600 bauds
}
void loop() {
if (Serial.available() > 0) {
char comanda = Serial.read(); // Llegeix la comanda enviada pel port sèrie
switch(comanda) {
case ‘I’: // Encén o apaga el LED infraroig i llegeix el sensor LDR
digitalWrite(pinLedIR, !digitalRead(pinLedIR));
llegirLDR();
break;
case ‘U’: // Encén o apaga el LED ultraviolat i llegeix el sensor LDR
digitalWrite(pinLedUV, !digitalRead(pinLedUV));
llegirLDR();
break;
case ‘R’: // Controla el LED RGB i llegeix el sensor LDR
int r = Serial.parseInt();
int g = Serial.parseInt();
int b = Serial.parseInt();
analogWrite(pinLedR, r); // Controla el LED vermell
analogWrite(pinLedG, g); // Controla el LED verd
analogWrite(pinLedB, b); // Controla el LED blau
llegirLDR();
break;
}
}
// Altres parts de la teva lògica del programa
}
void llegirLDR() {
int valorLDR = analogRead(pinLDR);
Serial.print(“Valor LDR: “);
Serial.println(valorLDR);
}
Codi tkinter
import tkinter as tk
import serial
# Configuració de la connexió serial (canvia ‘COM3′ pel teu port serial)
port = “COM3″ # Canvia aquest port pel que utilitzis amb l’Arduino a Windows
baudrate = 9600
ser = serial.Serial(port, baudrate)
def encendre_apagar_led_ultraviolat():
ser.write(b’U\n’)
def encendre_apagar_led_infraroig():
ser.write(b’I\n’)
def canviar_colors_led_rgb():
r = slider_r.get()
g = slider_g.get()
b = slider_b.get()
dades = f”R{r} G{g} B{b}\n”
ser.write(dades.encode())
def llegir_ldr():
ser.write(b’L\n’)
valor_ldr = ser.readline().decode().strip()
label_ldr.config(text=f”Valor LDR: {valor_ldr}”)
root = tk.Tk()
root.title(“Control LEDs”)
slider_r = tk.Scale(root, from_=0, to=255, orient=tk.HORIZONTAL, label=”Red”)
slider_g = tk.Scale(root, from_=0, to=255, orient=tk.HORIZONTAL, label=”Green”)
slider_b = tk.Scale(root, from_=0, to=255, orient=tk.HORIZONTAL, label=”Blue”)
label_ldr = tk.Label(root, text=”Valor LDR: “)
btn_infraroig = tk.Button(root, text=”LED Infraroig”, command=encendre_apagar_led_infraroig)
btn_ultraviolat = tk.Button(root, text=”LED Ultraviolat”, command=encendre_apagar_led_ultraviolat)
btn_colors = tk.Button(root, text=”Canviar Colors”, command=canviar_colors_led_rgb)
btn_read_ldr = tk.Button(root, text=”Llegir LDR”, command=llegir_ldr)
slider_r.pack()
slider_g.pack()
slider_b.pack()
label_ldr.pack()
btn_infraroig.pack()
btn_ultraviolat.pack()
btn_colors.pack()
btn_read_ldr.pack()
root.mainloop()
SCAN Arduino
int pinLedR = 12; // Pin per al LED vermell (RGB)
int pinLedG = 13; // Pin per al LED verd (RGB)
int pinLedB = 14; // Pin per al LED blau (RGB)
int pinLDR = A0; // Pin per al sensor LDR
void setup() {
pinMode(pinLedR, OUTPUT);
pinMode(pinLedG, OUTPUT);
pinMode(pinLedB, OUTPUT);
pinMode(pinLDR, INPUT);
Serial.begin(9600); // Inicia la comunicació sèrie a 9600 bauds
}
void loop() {
if (Serial.available() > 0) {
char comanda = Serial.read(); // Llegeix la comanda enviada pel port sèrie
switch(comanda) {
case ‘S’: // Escaneja longituds d’ona
escanejarLDR();
break;
// Altres comandes si cal tractar-ne més…
}
}
}
void escanejarLDR() {
for (int i = 400; i <= 700; i++) {
int r = map(i, 400, 700, 0, 255);
int g = map(i, 400, 700, 0, 255);
int b = map(i, 400, 700, 0, 255);
analogWrite(pinLedR, r); // Controla el LED vermell
analogWrite(pinLedG, g); // Controla el LED verd
analogWrite(pinLedB, b); // Controla el LED blau
delay(100); // Espera un temps per cada longitud d’ona (100ms, ajusta’l si cal)
int valorLDR = analogRead(pinLDR);
Serial.print(i);
Serial.print(“,”);
Serial.println(valorLDR);
}
}
SCAN Python
import serial
import matplotlib.pyplot as plt
port = “COM3” # Canvia aquest port pel que utilitzis amb l’Arduino a Windows
baudrate = 9600
ser = serial.Serial(port, baudrate)
wavelengths = []
ldr_values = []
def scan():
ser.write(b’S\n’)
for _ in range(301): # Rep 301 punts de dades
data = ser.readline().decode().strip().split(‘,’)
if len(data) == 2:
wavelength, ldr = map(int, data)
wavelengths.append(wavelength)
ldr_values.append(ldr)
scan()
plt.plot(wavelengths, ldr_values)
plt.xlabel(‘Longitud d\’ona (nm)’)
plt.ylabel(‘Valor LDR’)
plt.title(‘Escaneig de Longituds d\’ona amb LDR’)
plt.grid(True)
plt.show()
———-
Projecte 1B. Arduino amb PC: Codi controlP5
Codi Processing
import processing.serial.*;
ControlP5 cp5;
Serial serialPort;
int pinLedR = 12; // Pin para el LED rojo (RGB)
int pinLedG = 13; // Pin para el LED verde (RGB)
int pinLedB = 14; // Pin para el LED azul (RGB)
int pinLDR = A0; // Pin para el sensor LDR
boolean connected = false;
void setup() {
size(400, 300);
cp5 = new ControlP5(this);
// Configuración del puerto serial
String portName = Serial.list()[0]; // Cambia el índice si es necesario
serialPort = new Serial(this, portName, 9600);
// Creación de controles de interfaz
cp5.addSlider(“sliderR”)
.setPosition(20, 40)
.setRange(0, 255)
.setValue(0)
.setLabel(“Red”);
// Agrega los otros sliders para Green y Blue
cp5.addButton(“LED Infrarojo”)
.setPosition(20, 120)
.setSize(80, 30)
.addListener(new ControlListener() {
void controlEvent(ControlEvent theEvent) {
serialPort.write(“I\n”);
}
});
// Agrega el botón para el LED Ultravioleta
cp5.addButton(“Cambiar colores”)
.setPosition(20, 160)
.setSize(80, 30)
.addListener(new ControlListener() {
void controlEvent(ControlEvent theEvent) {
int r = (int)cp5.getController(“sliderR”).getValue();
// Obtiene los valores de G y B de manera similar
serialPort.write(“R” + r + ” G” + g + ” B” + b + “\n”);
}
});
// Agrega el botón para leer el LDR
cp5.addButton(“Leer LDR”)
.setPosition(20, 200)
.setSize(80, 30)
.addListener(new ControlListener() {
void controlEvent(ControlEvent theEvent) {
serialPort.write(“L\n”);
}
});
// Inicialización de pines como salida o entrada según corresponda
pinMode(pinLedR, OUTPUT);
// Inicialización de los otros pines
}
void draw() {
// Código de dibujo si es necesario
}
void sliderR(float value) {
// Lógica para el slider de Red si es necesaria
}
// Función para manejar los mensajes recibidos por el puerto serial
void serialEvent(Serial p) {
String message = p.readStringUntil(‘\n’).trim();
if (message.equals(“Valor LDR:”)) {
// Lógica para manejar la lectura del sensor LDR
// Puedes usar split() para separar el valor del LDR del mensaje
}
}
SCAN Arduino
int pinLedR = 12; // Pin per al LED vermell (RGB)
int pinLedG = 13; // Pin per al LED verd (RGB)
int pinLedB = 14; // Pin per al LED blau (RGB)
int pinLDR = A0; // Pin per al sensor LDR
void setup() {
pinMode(pinLedR, OUTPUT);
pinMode(pinLedG, OUTPUT);
pinMode(pinLedB, OUTPUT);
pinMode(pinLDR, INPUT);
Serial.begin(9600); // Inicia la comunicació sèrie a 9600 bauds
}
void loop() {
if (Serial.available() > 0) {
char comanda = Serial.read(); // Llegeix la comanda enviada pel port sèrie
switch(comanda) {
case ‘S’: // Escaneja longituds d’ona
escanejarLDR();
break;
// Altres comandes si cal tractar-ne més…
}
}
}
void escanejarLDR() {
for (int i = 400; i <= 700; i++) {
int r = map(i, 400, 700, 0, 255);
int g = map(i, 400, 700, 0, 255);
int b = map(i, 400, 700, 0, 255);
analogWrite(pinLedR, r); // Controla el LED vermell
analogWrite(pinLedG, g); // Controla el LED verd
analogWrite(pinLedB, b); // Controla el LED blau
delay(100); // Espera un temps per cada longitud d’ona (100ms, ajusta’l si cal)
int valorLDR = analogRead(pinLDR);
Serial.print(i);
Serial.print(“,”);
Serial.println(valorLDR);
}
}
SCAN python
import serial
import matplotlib.pyplot as plt
port = “COM3” # Canvia aquest port pel que utilitzis amb l’Arduino a Windows
baudrate = 9600
ser = serial.Serial(port, baudrate)
wavelengths = []
ldr_values = []
def scan():
ser.write(b’S\n’)
for _ in range(301): # Rep 301 punts de dades
data = ser.readline().decode().strip().split(‘,’)
if len(data) == 2:
wavelength, ldr = map(int, data)
wavelengths.append(wavelength)
ldr_values.append(ldr)
scan()
plt.plot(wavelengths, ldr_values)
plt.xlabel(‘Longitud d\’ona (nm)’)
plt.ylabel(‘Valor LDR’)
plt.title(‘Escaneig de Longituds d\’ona amb LDR’)
plt.grid(True)
plt.show()
———–
Processing SCAN
import processing.serial.*;
import controlP5.*;
import grafica.*;
Serial serialPort;
int pinLedR = 12; // Pin para el LED rojo (RGB)
int pinLedG = 13; // Pin para el LED verde (RGB)
int pinLedB = 14; // Pin para el LED azul (RGB)
int pinLDR = A0; // Pin para el sensor LDR
int numReadings = 301; // Número de lecturas a realizar
int[] wavelengths = new int[numReadings];
int[] ldrValues = new int[numReadings];
int currentIndex = 0;
ControlP5 cp5;
GPlot plot;
void setup() {
size(800, 600);
cp5 = new ControlP5(this);
// Inicialización de la conexión serial
serialPort = new Serial(this, “COM3”, 9600); // Cambia el puerto según corresponda
// Configuración de los controles de la interfaz
cp5.addButton(“Start Scan”)
.setPosition(20, 20)
.setSize(80, 30);
// Creación del gráfico
plot = new GPlot(this);
plot.setPos(120, 60);
plot.setDim(600, 400);
plot.getXAxis().setAxisLabelText(“Longitud de onda (nm)”);
plot.getYAxis().setAxisLabelText(“Valor LDR”);
}
void draw() {
background(240);
fill(0);
text(“Escaneo de Longitud de Onda vs. Valor LDR”, 250, 40);
}
void controlEvent(ControlEvent theEvent) {
if (theEvent.isFrom(cp5.getController(“Start Scan”))) {
escanejarLDR();
}
}
void escanejarLDR() {
for (int i = 400; i <= 700; i++) {
int r = map(i, 400, 700, 0, 255);
int g = map(i, 400, 700, 0, 255);
int b = map(i, 400, 700, 0, 255);
serialPort.write(“S\n”); // Envía el comando para escanear al Arduino
delay(100); // Espera un tiempo para cada longitud de onda (ajústalo si es necesario)
int valorLDR = analogRead(pinLDR);
serialPort.write((i + “,” + valorLDR + “\n”).getBytes()); // Envía los datos al Arduino
wavelengths[currentIndex] = i; // Almacena los datos para graficar
ldrValues[currentIndex] = valorLDR;
currentIndex++;
if (currentIndex >= numReadings) {
dibujarGrafico();
break;
}
}
}
void dibujarGrafico() {
plot.clearPoints();
for (int i = 0; i < numReadings; i++) {
plot.addPoint(wavelengths[i], ldrValues[i]);
}
plot.defaultDraw();
}
Projecte 2. Només Arduino, botons, potenciòmetre i pantalleta
Codi Python
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1 // Cambia el número de pin si es necesario (no utilizado en todos los módulos)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
int pinLedR = 9; // Pin para el LED rojo (RGB)
int pinLedG = 10; // Pin para el LED verde (RGB)
int pinLedB = 11; // Pin para el LED azul (RGB)
int pinLedIR = 6; // Pin para el LED infrarrojo
int pinLedUV = 7; // Pin para el LED ultravioleta
int pinLDR = A0; // Pin para el sensor LDR
bool IRState = false; // Estado del LED IR
bool UVState = false; // Estado del LED UV
void setup() {
pinMode(pinLedR, OUTPUT);
pinMode(pinLedG, OUTPUT);
pinMode(pinLedB, OUTPUT);
pinMode(pinLedIR, OUTPUT);
pinMode(pinLedUV, OUTPUT);
pinMode(pinLDR, INPUT);
Serial.begin(9600);
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F(“No se ha encontrado el display SSD1306”));
while(true);
}
display.display(); // Limpiar la pantalla
delay(2000); // Esperar 2 segundos antes de comenzar
}
void loop() {
if (Serial.available() > 0) {
char comanda = Serial.read(); // Lee el comando enviado por el puerto serie
switch(comanda) {
case ‘S’: // Escanea longitud de onda
escanejarLDR();
break;
case ‘I’: // Enciende/apaga el LED infrarrojo
IRState = !IRState;
digitalWrite(pinLedIR, IRState ? HIGH : LOW);
break;
case ‘U’: // Enciende/apaga el LED ultravioleta
UVState = !UVState;
digitalWrite(pinLedUV, UVState ? HIGH : LOW);
break;
// Otros casos si se necesitan más comandos
}
}
}
void escanejarLDR() {
display.clearDisplay(); // Limpiar la pantalla antes de comenzar el escaneo
display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
for (int i = 400; i <= 700; i++) {
int r = map(i, 400, 700, 0, 255);
int g = map(i, 400, 700, 0, 255);
int b = map(i, 400, 700, 0, 255);
analogWrite(pinLedR, r);
analogWrite(pinLedG, g);
analogWrite(pinLedB, b);
delay(100); // Espera un tiempo para cada longitud de onda (ajústalo si es necesario)
int valorLDR = analogRead(pinLDR);
Serial.print(i);
Serial.print(“,”);
Serial.println(valorLDR);
display.setCursor(0, 0);
display.print(“Longitud: “);
display.print(i);
display.setCursor(0, 10);
display.print(“Valor LDR: “);
display.print(valorLDR);
display.display(); // Mostrar en la pantalla OLED
// Agregar más lógica aquí si necesitas controlar los LEDs basados en el valor del LDR
}
}
Projecte 3. RASPBERRY PI i pantalleta amb ESP32-S3
import smbus
import time
import RPi.GPIO as GPIO
# Dirección I2C de la pantalla LCD
LCD_ADDR = 0x27
# Define los registros para la pantalla LCD
LCD_CHR = 1
LCD_CMD = 0
LCD_BACKLIGHT = 0x08 # Enciende el backlight
ENABLE = 0b00000100 # Habilita el bit de Enable para la comunicación
# Líneas de datos del LCD (P0, P1, P2, P3, P4, P5, P6, P7)
LCD_LINE_1 = 0x80 # Dirección de la primera línea del LCD
LCD_LINE_2 = 0xC0 # Dirección de la segunda línea del LCD
# Pines GPIO para el sensor LDR
pinLDR = 11 # GPIO11 para el sensor LDR
# Configuración de pines como entrada
GPIO.setmode(GPIO.BCM)
GPIO.setup(pinLDR, GPIO.IN)
def lcd_init():
# Inicialización de la pantalla LCD
lcd_byte(0x33, LCD_CMD) # Inicialización de la pantalla en modo 4 bits
lcd_byte(0x32, LCD_CMD) # Inicialización de la pantalla en modo 4 bits
lcd_byte(0x06, LCD_CMD) # Mueve el cursor hacia la derecha
lcd_byte(0x0C, LCD_CMD) # Enciende el display
lcd_byte(0x28, LCD_CMD) # Establece el modo de 2 líneas
lcd_byte(0x01, LCD_CMD) # Limpia la pantalla
def lcd_byte(bits, mode):
# Envía datos a la pantalla LCD en modo 4 bits
# bits: Datos
# mode: 1 = Carácter, 0 = Comando
bits_high = mode | (bits & 0xF0) | LCD_BACKLIGHT
bits_low = mode | ((bits << 4) & 0xF0) | LCD_BACKLIGHT
# Envía datos
bus.write_byte(LCD_ADDR, bits_high)
lcd_toggle_enable(bits_high)
bus.write_byte(LCD_ADDR, bits_low)
lcd_toggle_enable(bits_low)
def lcd_toggle_enable(bits):
# Activa el bit Enable para la comunicación
time.sleep(0.0005)
bus.write_byte(LCD_ADDR, (bits | ENABLE))
time.sleep(0.0005)
bus.write_byte(LCD_ADDR, (bits & ~ENABLE))
time.sleep(0.0005)
def lcd_string(message, line):
# Envía un mensaje a la pantalla LCD
message = message.ljust(16, ” “) # Ajusta el mensaje a 16 caracteres
lcd_byte(line, LCD_CMD)
for i in range(16):
lcd_byte(ord(message[i]), LCD_CHR)
try:
# Inicialización del bus I2C
bus = smbus.SMBus(1)
lcd_init() # Inicialización de la pantalla LCD
lcd_string(“Valor LDR:”, LCD_LINE_1) # Mostrar etiqueta en la primera línea
while True:
ldr_value = GPIO.input(pinLDR) # Lee el valor del sensor LDR
lcd_string(f”{ldr_value}”, LCD_LINE_2) # Mostrar el valor del sensor LDR en la segunda línea
time.sleep(1)
except KeyboardInterrupt:
pass
finally:
GPIO.cleanup() # Limpiar pines GPIO al terminar
LED RGB SMD
#include <FastLED.h>
#define LED_PIN 6 // Pin del Arduino connectat al DIN del WS2812B
#define NUM_LEDS 1 // Nombre de LEDs que tenim connectats
CRGB leds[NUM_LEDS]; // Crea un array de LEDs
void setup() {
FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS); // Defineix el tipus de LED i connexió
}
void loop() {
leds[0] = CRGB(255, 0, 0); // Defineix el color (R,G,B) per al primer LED
FastLED.show(); // Mostra el color
delay(1000); // Espera 1 segon
}
Donar color igual que llegit
#include <Wire.h>
#include “Adafruit_TCS34725.h”
#include <FastLED.h>
#define LED_PIN 6 // Pin del Arduino connectat al LED RGB
#define NUM_LEDS 1 // Nombre de LEDs que tenim connectats
CRGB leds[NUM_LEDS]; // Crea un array de LEDs
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X); // Configuració del sensor
void setup() {
FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS); // Defineix el tipus de LED i connexió
tcs.begin(); // Inicialitza el sensor
}
void loop() {
uint16_t clear, red, green, blue;
tcs.getRawData(&red, &green, &blue, &clear); // Llegeix els valors de color del sensor
// Mapeja els valors de color a la intensitat del LED
leds[0].r = map(red, 0, 65535, 0, 255);
leds[0].g = map(green, 0, 65535, 0, 255);
leds[0].b = map(blue, 0, 65535, 0, 255);
FastLED.show(); // Mostra el color
delay(100); // Espera un temps per a la següent lectura
}
_——-
#include <Wire.h>
#include <Adafruit_AS726x.h>
#include <FastLED.h>
#define LED_PIN 6 // Pin del Arduino conectat al LED RGB
#define NUM_LEDS 1 // Nombre de LEDs que tenim conectats
#define AS726X_ADDR 0x49 // Adreça I2C del sensor AS726X
CRGB leds[NUM_LEDS]; // Crear un array de LEDs
Adafruit_AS726x ams;
void setup() {
FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS); // Definir el tipus de LED i connexió
Wire.begin(); // Inicialitzar la comunicació I2C
ams.begin(AS726X_ADDR); // Inicialitzar el sensor AS726X amb l’adreça especificada
// Configurar el sensor AS726X
ams.setMeasurementMode(AS726X_MEAS_MODE_Continuous, AS726X_MEAS_450);
ams.setIndicate(1); // Encendre l’indicador del sensor
}
void loop() {
// Llegir les dades del sensor AS726X
if (ams.dataAvailable()) {
ams.readCalibratedValues();
// Convertir els valors llegits a valors RGB per controlar el LED
leds[0] = CRGB(ams.calibratedR, ams.calibratedG, ams.calibratedB);
FastLED.show(); // Mostrar el color
}
}
Lllllllllllllllll
#include <Wire.h>
#include <Adafruit_AS726x.h>
#include <FastLED.h>
#define LED_PIN 6 // Pin del Arduino conectat al LED RGB
#define NUM_LEDS 1 // Nombre de LEDs que tenim connectats
#define AS726X_ADDR 0x49 // Adreça I2C del sensor AS726X
CRGB leds[NUM_LEDS]; // Crear un array de LEDs
Adafruit_AS726x ams;
void setup() {
FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS); // Definir el tipus de LED i connexió
Wire.begin(); // Inicialitzar la comunicació I2C
ams.begin(AS726X_ADDR); // Inicialitzar el sensor AS726X amb l’adreça especificada
// Configurar el sensor AS726X
ams.setMeasurementMode(AS726X_MEAS_MODE_Continuous, AS726X_MEAS_450);
ams.setIndicate(1); // Encendre l’indicador del sensor
}
void loop() {
// Emetre llum amb FastLED
leds[0] = CRGB(255, 0, 0); // Emetre llum vermella
FastLED.show(); // Mostrar el color
// Llegir les dades del sensor AS726X
if (ams.dataAvailable()) {
ams.readCalibratedValues();
// Fer quelcom amb les dades llegides (per exemple, imprimir-les)
Serial.print(“R: “); Serial.print(ams.calibratedR);
Serial.print(” G: “); Serial.print(ams.calibratedG);
Serial.print(” B: “); Serial.println(ams.calibratedB);
}
delay(1000); // Esperar un temps abans de repetir el bucle
}