PING PONG CONTROLAT AMB LLUM I ARDUINO
https://www.instructables.com/Pong-With-Processing/
# CODI ARDUINO
const int sensorPin = A0; // Pin analògic on està connectat el LDR
void setup() {
Serial.begin(9600);
}
void loop() {
int sensorValue = analogRead(sensorPin);
Serial.println(sensorValue);
delay(100); // Ajusta el retard segons les necessitats
}
Aquest codi llegeix el valor analògic del sensor LDR i el transmet a través del port sèrie. Recorda que el valor llegit pot variar segons les condicions de llum, i hauràs de calibrar els límits en el teu codi de Processing per adaptar-los a la teva configuració específica.
Per crear una simulació amb Processing que mostri una pala dibuixada en pantalla i utilitzi un sensor LDR connectat a Arduino, pots seguir aquests passos generals:
Configuració de l’Arduino:
Connecta el sensor LDR a l’Arduino com s’ha descrip en la resposta anterior.
Carrega un codi senzill a l’Arduino per llegir les dades del LDR i enviar-les a través del port sèrie.
Codificació amb Processing:
Escriu un script en Processing per llegir les dades del port sèrie i dibuixar la pala en pantalla.
Utilitza les dades del LDR per determinar la posició vertical de la pala en la pantalla.
Exemple de codi en Processing:
#CODI PROCESSING
import processing.serial.*;
Serial arduinoPort;
float palaY;
void setup() {
size(800, 600);
arduinoPort = new Serial(this, “COMX”, 9600); // Reemplaça “COMX” amb el port correcte de l’Arduino
palaY = height / 2; // Posició inicial de la pala al mig de la pantalla
}
void draw() {
background(255);
llegirDadesArduino();
dibuixarPala();
}
void llegirDadesArduino() {
while (arduinoPort.available() > 0) {
String dades = arduinoPort.readStringUntil(‘\n’);
if (dades != null) {
palaY = map(float(dades), 0, 1023, 0, height); // Ajusta segons el rang del teu sensor lo
}
}
}
void dibuixarPala() {
float palaAlçada = 80; // Alçada de la pala
rect(30, palaY – palaAlçada / 2, 10, palaAlçada); // Dibuixa la pala a la posició calculada
}
Recorda reemplaçar “COMX” amb el port correcte de l’Arduino.
Aquest exemple és molt senzill i pot ser necessari ajustar-lo segons la configuració exacta del teu sistema. També pots millorar-lo afegint lògica de límits per assegurar-te que la pala no surti de la pantalla i adaptant els valors segons les característiques del teu sensor LDR.
Espectrofotòmetre
#include <Wire.h>
#include <Adafruit_TCS34725.h>
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
void setup() {
Serial.begin(9600);
if (tcs.begin()) {
Serial.println(“Sensor OK”);
} else {
Serial.println(“No es pot trobar el sensor. Comprova les connexions!”);
while (1);
}
}
void loop() {
uint16_t clear, red, green, blue;
tcs.setInterrupt(false);
delay(60);
tcs.getRawData(&red, &green, &blue, &clear);
tcs.setInterrupt(true);
float illuminance = (0.136 * red) + (1.269 * green) + (-0.324 * blue);
Serial.print(“Illuminance: “); Serial.println(illuminance);
delay(1000);
}
GUVA-S12SD: Sensor UV
El GUVA-S12SD és un sensor de llum ultraviolada dissenyat per mesurar la radiació ultraviolada en una banda específica. Aquest tipus de sensors són útils per a la detecció de la intensitat de la llum UV, que pot tenir implicacions en la salut humana i ser útil en aplicacions com la protecció solar, el monitoratge ambiental o fins i tot en la prevenció de riscos ambientals.
const int analogPin = A0; // Connecta el pin de sortida del sensor UV a l’entrada analògica A0
const int uvLevelMax = 1023; // Valor màxim del sensor en condicions de radiació UV màxima
void setup() {
Serial.begin(9600);
}
void loop() {
int uvLevel = analogRead(analogPin);
// Escalat del valor llegit a una escala de 0 a 10V (o el rang que necessitis)
float uvIndex = map(uvLevel, 0, uvLevelMax, 0, 10);
// Mostra el valor a la consola sèrie
Serial.print(“UV Level: “);
Serial.println(uvIndex);
delay(1000);
}
Emisor i sensor UV
const int uvLEDPin = 9; // Pin digital per al LED UV
const int uvSensorPin = A0; // Pin analògic per al sensor UV
void setup() {
pinMode(uvLEDPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
// Encén el LED UV
digitalWrite(uvLEDPin, HIGH);
// Mesura el valor del sensor UV
int uvValue = analogRead(uvSensorPin);
// Imprimeix el valor a la consola sèrie
Serial.print(“UV Value: “);
Serial.println(uvValue);
// Apaga el LED UV
digitalWrite(uvLEDPin, LOW);
// Espera un temps abans de fer la següent mesura
delay(1000);
}
Llegir temperatura amb mòbil per Serial amb descàrrega a Playstore de “Serial Bluetooth Terminal” o similar
#include <SoftwareSerial.h>
const int sensorPin1 = A0; // Pin A0 per al primer sensor LM35
const int sensorPin2 = A1; // Pin A1 per al segon sensor LM35
const int sensorPin3 = A2; // Pin A2 per al tercer sensor LM35
SoftwareSerial BTserial(2, 3); // Configura el Bluetooth: RX a pin digital 2, TX a pin digital 3
void setup() {
Serial.begin(9600); // Inicialitza la comunicació sèrie a 9600 bps
BTserial.begin(9600); // Inicialitza el Bluetooth a 9600 bps
}
void loop() {
int lectura1 = analogRead(sensorPin1); // Llegeix el valor analògic del primer sensor
float temperatura1 = (lectura1 * 0.48828125); // Converteix el valor a temperatura en graus Celsius
int lectura2 = analogRead(sensorPin2); // Llegeix el valor analògic del segon sensor
float temperatura2 = (lectura2 * 0.48828125); // Converteix el valor a temperatura en graus Celsius
int lectura3 = analogRead(sensorPin3); // Llegeix el valor analògic del tercer sensor
float temperatura3 = (lectura3 * 0.48828125); // Converteix el valor a temperatura en graus Celsius
BTserial.print(“Temperatura Sensor 1: “);
BTserial.print(temperatura1);
BTserial.println(” °C”);
BTserial.print(“Temperatura Sensor 2: “);
BTserial.print(temperatura2);
BTserial.println(” °C”);
BTserial.print(“Temperatura Sensor 3: “);
BTserial.print(temperatura3);
BTserial.println(” °C”);
delay(1000); // Espera 1 segon abans de llegir les temperatures de nou
}
Codi tmp36
const int pinSensor = 8; // Define el pin GPIO8 como la entrada del sensor TMP36
void setup() {
Serial.begin(115200); // Inicializa la comunicación serial
}
void loop() {
int sensorValue = analogRead(pinSensor); // Lee el valor analógico del sensor
float voltage = sensorValue * (3.3 / 4095.0); // Convierte el valor a voltaje (ESP32-S3 opera a 3.3V y tiene una resolución ADC de 12 bits)
float temperatureC = (voltage – 0.5) * 100; // Convierte el voltaje a temperatura en grados Celsius
Serial.print(“Temperatura: “);
Serial.print(temperatureC);
Serial.println(“°C”);
delay(1000); // Espera 1 segundo antes de tomar otra lectura
}
//Color i temperatura
#include <Adafruit_NeoPixel.h>
const int pinSensor = 32; // Sensor TMP36 connectat a GPIO32
const int pinLED = 13; // LED RGB connectat al GPIO13 (aquest pin varia segons la teva placa)
#define NUM_PIXELS 1 // Només tenim un LED RGB
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUM_PIXELS, pinLED, NEO_RGB + NEO_KHZ800);
void setup() {
Serial.begin(115200); // Inicialitzar la comunicació serial
pixels.begin(); // Inicialitzar el LED RGB
}
void loop() {
for (int colorValue = 0; colorValue <= 255; colorValue++) {
int sensorValue = analogRead(pinSensor); // Llegir el valor del sensor
float voltage = sensorValue * (3.3 / 4095.0); // Convertir el valor a voltatge (3.3V, resolució ADC de 12 bits)
float temperatureC = (voltage – 0.5) * 100; // Convertir el voltatge a temperatura en graus Celsius
// Mapejar la temperatura a valors de color (r, g, b) per a l’LED RGB
int color = map(temperatureC, 0, 100, 0, 255); // Escalar la temperatura al rang de colors (0-255)
// Encendre l’LED amb el color corresponent
pixels.setPixelColor(0, Wheel(colorValue)); // Configurar el color de l’LED basat en la variable de bucle
pixels.show(); // Actualitzar el LED amb el color nou
// Mostrem el valor de color, temps i temperatura per la consola serial
Serial.print(“Color: “);
Serial.print(colorValue);
Serial.print(“, Temperatura: “);
Serial.print(temperatureC);
Serial.println(“°C”);
delay(1000); // Esperar 1 segon abans de passar al següent color
}
}
// Funció per generar un color d’arc iris
uint32_t Wheel(byte WheelPos) {
WheelPos = 255 – WheelPos;
if (WheelPos < 85) {
return pixels.Color(255 – WheelPos * 3, 0, WheelPos * 3);
} else if (WheelPos < 170) {
WheelPos -= 85;
return pixels.Color(0, WheelPos * 3, 255 – WheelPos * 3);
} else {
WheelPos -= 170;
return pixels.Color(WheelPos * 3, 255 – WheelPos * 3, 0);
}
}
Genuino 101 i DS18B20
#include <OneWire.h>
#include <DallasTemperature_Curie.h>
// Configuració del pin on està connectat el sensor DS18B20
const int pinSensor = 2; // Canvia aquest valor amb el pin que estiguis utilitzant
OneWire oneWire(pinSensor);
DallasTemperature sensors(&oneWire);
void setup() {
Serial.begin(9600);
sensors.begin();
}
void loop() {
sensors.requestTemperatures(); // Inicia la lectura de la temperatura
// Obté la temperatura en graus Celsius
float temperaturaC = sensors.getTempCByIndex(0);
if (temperaturaC != DEVICE_DISCONNECTED_C) {
Serial.print(“Temperatura: “);
Serial.print(temperaturaC);
Serial.println(” °C”);
} else {
Serial.println(“No es pot llegir la temperatura. Comprova la connexió del sensor.”);
}
delay(2000); // Espera 2 segons abans de llegir la temperatura de nou
}
El GUVA-S12SD és un sensor de llum ultraviolada dissenyat per mesurar la radiació ultraviolada en una banda específica. Aquest tipus de sensors són útils per a la detecció de la intensitat de la llum UV, que pot tenir implicacions en la salut humana i ser útil en aplicacions com la protecció solar, el monitoratge ambiental o fins i tot en la prevenció de riscos ambientals.
Algunes característiques del GUVA-S12SD podrien incloure:
- Rang d’ona: Normalment, està calibrat per mesurar en la banda UV-A i possiblement UV-B.
- Sortida analògica: El sensor pot produir una sortida analògica que varia segons la intensitat de la llum UV detectada.
- Alimentació: S’ha de connectar a una font d’alimentació adequada i, a vegades, calibrar-lo per obtenir lectures precises.
Per utilitzar aquest sensor, es podria connectar a una placa de desenvolupament com Arduino o Raspberry Pi i llegir les seves lectures mitjançant els pins analògics o entrades/sortides.
ESP32-S3:
L’ESP32-S3 és un microcontrolador desenvolupat per Espressif com a part de la sèrie ESP32. Aquesta sèrie de microcontroladors és coneguda per la seva connectivitat WiFi i Bluetooth integrada, a més de les capacitat de processament i emmagatzematge.
const int pinSensor = 34; // Canvia aquest valor amb el pin que estiguis utilitzant
void setup() {
Serial.begin(115200);
}
void loop() {
int lecturaAnalogica = analogRead(pinSensor);
// Calibració per a la conversió a intensitat de llum (mW/cm^2)
float intensitatLlum = map(lecturaAnalogica, 0, 4095, 0, 25.0);
// Imprimeix la lectura
Serial.print(“Lectura analògica: “);
Serial.print(lecturaAnalogica);
Serial.print(“\t Intensitat de llum: “);
Serial.print(intensitatLlum);
Serial.println(” mW/cm^2″);
delay(1000); // Espera 1 segon abans de llegir de nou
}
GUVA i Genuino Uno 101
const int pinSensor = A0; // Canvia aquest valor amb el pin analògic que estiguis utilitzant
void setup() {
Serial.begin(9600);
}
void loop() {
int lecturaAnalogica = analogRead(pinSensor);
// Calibració per a la conversió a intensitat de llum (mW/cm^2)
float intensitatLlum = map(lecturaAnalogica, 0, 1023, 0, 25.0);
// Imprimeix la lectura
Serial.print(“Lectura analògica: “);
Serial.print(lecturaAnalogica);
Serial.print(“\t Intensitat de llum: “);
Serial.print(intensitatLlum);
Serial.println(” mW/cm^2″);
delay(1000); // Espera 1 segon abans de llegir de nou
}
BH1750 (sensor de luminositat) i ESP32-S3
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BH1750.h>
Adafruit_BH1750 bh1750;
void setup() {
Serial.begin(115200);
if (!bh1750.begin()) {
Serial.println(“No s’ha pogut inicialitzar el sensor BH1750. Comprova la connexió.”);
while (1);
}
}
void loop() {
uint16_t luminositat = bh1750.readLightLevel();
Serial.print(“Luminositat: “);
Serial.print(luminositat);
Serial.println(” lux”);
delay(1000); // Espera 1 segon abans de llegir de nou
}
Genuino 101 i BH1750
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BH1750.h>
Adafruit_BH1750 bh1750;
void setup() {
Serial.begin(115200);
if (!bh1750.begin()) {
Serial.println(“No s’ha pogut inicialitzar el sensor BH1750. Comprova la connexió.”);
while (1);
}
}
void loop() {
uint16_t luminositat = bh1750.readLightLevel();
Serial.print(“Luminositat: “);
Serial.print(luminositat);
Serial.println(” lux”);
delay(1000); // Espera 1 segon abans de llegir de nou
}
Esp32-S3 i MLX90614 (sensor de temperatura IR)
#include <Wire.h>
#include <Adafruit_MLX90614.h>
#define SDA_PIN 21 // change to your SDA pin, 8?
#define SCL_PIN 22 // change to your SCL pin 9?
Adafruit_MLX90614 mlx = Adafruit_MLX90614();
void setup() {
Serial.begin(115200);
Wire.begin(SDA_PIN, SCL_PIN);
mlx.begin();
}
void loop() {
float tempAmbient = mlx.readAmbientTempC();
float tempObject = mlx.readObjectTempC();
Serial.print(“Ambient Temperature: “);
Serial.print(tempAmbient);
Serial.println(” °C”);
Serial.print(“Object Temperature: “);
Serial.print(tempObject);
Serial.println(” °C”);
delay(1000);
}
________
#include <Wire.h>
#include <Adafruit_MLX90614.h>
#define SDA_PIN 8 // change to your SDA pin
#define SCL_PIN 9 // change to your SCL pin
Adafruit_MLX90614 mlx = Adafruit_MLX90614();
void setup() {
Serial.begin(115200);
Wire.begin(SDA_PIN, SCL_PIN);
if (!mlx.begin()) {
Serial.println(“Error: Unable to communicate with MLX90614 sensor. Check connections.”);
while (1);
}
}
void loop() {
float tempAmbient = mlx.readAmbientTempC();
float tempObject = mlx.readObjectTempC();
if (isnan(tempAmbient) || isnan(tempObject)) {
Serial.println(“Error: Invalid temperature readings. Check sensor and connections.”);
} else {
Serial.print(“Ambient Temperature: “);
Serial.println(String(tempAmbient) + ” °C”);
Serial.print(“Object Temperature: “);
Serial.println(String(tempObject) + ” °C”);
}
delay(1000);
}
ADS1115 amb Arduino
L’ADS1115 és un convertidor analògic-digital (ADC) que pot ser utilitzat per llegir valors analògics en un microcontrolador com ara el Raspberry Pi o Arduino. Aquest dispositiu permet convertir una senyal analògica en una forma digital que pot ser llegida i processada pel microcontrolador. Es un “convertidor analògic-digital de 16 bits amb amplificador d’instrumentació” per a mesurar valors analògics amb una alta resolució i precisió en projectes que requereixen aquesta característica.
Connecta el pin VCC del ADS115 a 5V en Arduino.
- Connecta el pin GND del ADS115 a GND en Arduino.
- Connecta el pin SDA del ADS115 a un dels pins analògics en Arduino, com A4.
- Connecta el pin SCL del ADS115 a altre pin analògic en Arduino, com A5.
#include <Wire.h>
#include <Adafruit_ADS1015.h>
Adafruit_ADS1115 ads; // Utiliza Adafruit_ADS1015 si estás utilizando el ADS1015
void setup(void) {
Serial.begin(9600);
if (!ads.begin()) {
Serial.println("No se encontró el módulo ADS115.");
while (1);
}
}
void loop(void) {
int16_t adc0;
adc0 = ads.readADC_SingleEnded(0);
Serial.print("Valor ADC en el canal 0: ");
Serial.println(adc0);
delay(1000);
}
Raspberry Pi i ADS1115
Connecta el pin VCC del ADS1115 a 3.3V en Raspberry Pi.
Connecta el pin GND del ADS1115 a GND en Raspberry Pi.
Connecta el pin SDA del ADS1115 al pin SDA en Raspberry Pi (GPIO 2).
Connecta el pin SCL del ADS1115 al pin SCL en Raspberry Pi (GPIO 3).
from gpiozero import ADS1115
from time import sleep
ads = ADS1115()
while True:
value = ads.read(0, gain=1) # Lee el canal 0 con ganancia 1
print("Valor ADC en el canal 0:", value)
sleep(1)
L’ADS1115 és un convertidor analògic-digital (ADC) que permet llegir senyals analògiques amb alta precisió i resolució. El GUVAS12, com ja es va esmentar anteriorment, és un sensor de llum ultraviolada. Aquí tens un exemple de com connectar un ADS1115 a una Raspberry Pi i llegir dades d’un sensor GUVAS12 amb Python:
Connexions físiques:
ADS1115 a Raspberry Pi:
Connecta VCC de l’ADS1115 a 3.3V a la Raspberry Pi.
Connecta GND de l’ADS1115 a GND a la Raspberry Pi.
Connecta SDA de l’ADS1115 a SDA (pin 3) a la Raspberry Pi.
Connecta SCL de l’ADS1115 a SCL (pin 5) a la Raspberry Pi.
GUVAS12 a ADS1115:
Connecta la sortida analògica del GUVAS12 (OUT) al canal analògic de l’ADS1115 (pots utilitzar qualsevol canal A0 a A3).
Codi en Python amb la llibreria Adafruit_ADS1x15:
Assegura’t de tenir instal·lada la llibreria Adafruit_ADS1x15. Si no la tens instal·lada, pots fer-ho amb la comanda següent:
pip install adafruit-ads1x15
Ara, pots utilitzar aquest codi:
import time
import Adafruit_ADS1x15
# Configuració de l'ADS1115
ads1115 = Adafruit_ADS1x15.ADS1115()
# Canal al qual està connectat el GUVAS12
canal_guvas12 = 0
def llegir_dades_guvas12():
# Llegeix el valor analògic del canal del GUVAS12
valor_adc = ads1115.read_adc(canal_guvas12, gain=1)
return valor_adc
# Bucle principal
while True:
valor_guvas12 = llegir_dades_guvas12()
print(f'Valor del GUVAS12: {valor_guvas12}')
time.sleep(1)
Aquest codi utilitza la llibreria Adafruit_ADS1x15 per llegir el valor analògic del canal al qual està connectat el GUVAS12 cada segon. Assegura’t que el canal especificat (canal_guvas12) sigui el correcte segons la connexió física que has realitzat. La funció llegir_dades_guvas12 llegeix el valor analògic del GUVAS12 i imprimeix el resultat.
Espero que aquest exemple t’ajudi a connectar l’ADS1115 amb una Raspberry Pi i llegir dades d’un sensor GUVAS12.
Per implementar una interfície gràfica (GUI) i afegir un LED UV amb una representació gràfica dels valors GUVA al llarg del temps, podem utilitzar la biblioteca Tkinter per la interfície gràfica i Matplotlib per generar gràfics. Primerament, assegura’t d’haver instal·lat les llibreries necessàries amb les següents comandes:
pip install matplotlib
sudo apt-get install python3-tk
A continuació, pots utilitzar el següent codi com a exemple. Aquest codi utilitza la llibreria tkinter per la GUI i la llibreria matplotlib per al gràfic en temps real:
import time
import tkinter as tk
from tkinter import ttk
import Adafruit_ADS1x15
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
import threading
# Configuració de l'ADS1115
ads1115 = Adafruit_ADS1x15.ADS1115()
# Canal al qual està connectat el GUVAS12
canal_guvas12 = 0
# Configuració de la finestra principal
root = tk.Tk()
root.title("Lectura GUVA-S12SD")
# Variables globals per controlar el LED i les dades del grafic
led_ences = False
temps_inici = time.time()
temps = []
dades_guva = []
# Funció per llegir les dades GUVA
def llegir_dades_guvas12():
while led_ences:
valor_adc = ads1115.read_adc(canal_guvas12, gain=1)
temps_actual = time.time() - temps_inici
# Afegir les dades a les llistes
temps.append(temps_actual)
dades_guva.append(valor_adc)
# Actualitzar l'etiqueta amb el valor actual
etiqueta_valor.config(text=f'Valor GUVA: {valor_adc}')
# Actualitzar el gràfic
ax.clear()
ax.plot(temps, dades_guva)
ax.set_xlabel('Temps (s)')
ax.set_ylabel('Valor GUVA')
canvas.draw()
time.sleep(1)
# Funció per canviar l'estat del LED
def canviar_estat_led():
global led_ences
led_ences = not led_ences
if led_ences:
temps.clear()
dades_guva.clear()
temps_inici = time.time()
threading.Thread(target=llegir_dades_guvas12).start()
else:
# Apagar el LED i netejar les llistes
led_ences = False
gpio.cleanup()
temps.clear()
dades_guva.clear()
# Crear etiqueta per mostrar el valor actual de GUVA
etiqueta_valor = ttk.Label(root, text="Valor GUVA: ")
etiqueta_valor.pack()
# Crear botó per encendre/apagar el LED i començar a llegir dades
boton_led = ttk.Button(root, text="Encendre / Apagar LED", command=canviar_estat_led)
boton_led.pack()
# Crear gràfic en temps real
figura, ax = plt.subplots()
canvas = FigureCanvasTkAgg(figura, master=root)
canvas_widget = canvas.get_tk_widget()
canvas_widget.pack()
# Iniciar bucle principal de la GUI
root.mainloop()
Aquest codi crea una finestra amb un botó per encendre i apagar un LED UV, una etiqueta per mostrar el valor actual de GUVA i un gràfic en temps real de les dades GUVA. A més, es neteja les dades quan el LED es desactiva per permetre començar un nou registre.
Nota: Aquest codi assumeix que ja tens un LED UV connectat a la Raspberry Pi, i el pin corresponent està configurat. Si no és així, hauràs d’adaptar el codi segons la teva configuració específica.
Instal.lar BananaPi M5