Projecte de fotònica

L'objectiu es comprendre com funciona la llum mitjançant microcontroladors i programació i en el meu efecre mims a través de leds de diferents colors, vermell, verd, groc, i blanc. També leds RGVNeocities.

El procediment per construïr un espectrofòmetre consta de les seguents parts:

Trobar el màxim d'absorbància de cada colorant

Hem de buscar la bibliografia a google scholar el màxim d'absorbància de: <>àcid carmínic, luteïna i FCF

Comprobar el màxim d'absorbancia amb codi

Utilitzarem codis que faran un escaneig o scan de forma que encendrán els llums red,green and blue del led RGB de forma que generarem longitud d'ona que van des de 380 nanomètres a 780 nanomètres

Escriu la longitud d'ona en nanomètres i converrteix-la en RGB en la següent linia

En aquesta immatge podem veure la relació entre la ona i el color.

El codi anterior que trnsforma longitud d'ona en valor RGB funciona de la següent manera: Longitud d'ona té una etiqueta o tag anomenat "label".

L'etiqueta input permet introduir qualsevol tipus de valors pel teclat, però la propeitat o atribut de input anomenat type esta definida com a number i només permet introduir números. El value és una propietat o atribut de input que fa que surti com a valor predeterminat i min i max són els valors mínims i máxims i no s'acceptaran valors fora de marge. La Id s una propeietat molt important ja que es com el DNI i el cridarem en getElementById

La paraula button crea un botó de forma automàtica que té una propietat o atribut anomenada onlick que està esperant ser clickada o no. Altres que poden existir onmouseover (quan estic a sobre), onkeydown (quan pressiono una tecla), onload (quan es carrega una pàgina o un element), onsubmit (quan envío un formulari).

El contigut del botó s'escriu abans de final de button.

Quan detecti que onclick és igual a true s'executarà una funció que no té cap paràmetre ni argument perquè té dos parèntesis buits. La funció s'anomena convertWavelenght i està definida més endevant amb la paraula function convertWavelenght(){...instruccions aquí...}. Això vol dir que quan clicko a un botó creat amb html crido a una funció creada en javaScript més endevant que convertirà la longitud d'ona que escric en RGB.

<div id="result"></div>

Un div és un divisor que és com un paràgraf en aquest cas buit que té un identificador anoomenat resul que només es veurà i s'executarà desprès, és a dir, quan es carrega la pàgina està buit u quan clickem el botó de convertir farà la seva funció.

 
 
 function convertWavelength() {
        const wavelength = document.getElementById("wavelength").value;
        const R = Math.round(getRGBValue(wavelength, 'R'));
        const G = Math.round(getRGBValue(wavelength, 'G'));
        const B = Math.round(getRGBValue(wavelength, 'B'));
        const result = `RGB values: (${R}, ${G}, ${B})`;
        document.getElementById("result").textContent = result;
      }
      
      

Una funció és una manera que tenim de transformar un valor que donem nosalatres inicialment , en un altre diferent. Em aquest cas volem transformar el valor de la longitud d'ona en tres valors: RGB.

Sempre que escric la paraula function, per crear una funció, he de posar al costat el nom de la funció, en anglés, que expliqui el que fa aquest cas convertir la longitud d'ona i posa convertWaveLength(), en camelCase, i posem un parentesis but perquè no depen de peràmetres o arguments.

Dins de la funció tenim diversas instruccions agrupades en una clau

Les primeres 5 línies de la funció defineixen constant locals perquè s'apliquen dins de la funció i no afecten a tot el codi, a diferència de les constant globals que es posen fora de les funcions i afectan a tot el codi ( constant PI= 3,14;).

parseFloat transforma qualsevol variable en un float o número decimal i posteriorment en una altra funció Math round el transformarà en un numero sencer o integer. Si el número intruduït com a nm està fora de marges no facis res que vol dir return 0

1. La primera línia de la funció agafa el valor (.value) de la longitud que s'ha introduït a l'input, i l'identifica perquè l'agafa amb el getElementById, i l'emmagatzemem amb un nom concret (wavelength) que no pot variar dins de la funció, però si globalment.
2. const R = Math.round(getRGBValue(wavelength, 'R'));
   const G = Math.round(getRGBValue(wavelength, 'G'));
   const B = Math.round(getRGBValue(wavelength, 'B'));
   El que fa aquestes línia és agafar una funció que s'anomena RGBValue i que té dos paràmteres o arguments interns que són: primer la longitud d'ona introduïda per l'usuari i el segón, el valor RGB que generem. El valor del càlcul matemàtic que obté la funció getRGBValue, de RGB és un float(número decimal), i nosaltres el convertim en un int(integer o número sencer), i el guardem en una variable constant local anomenada R, G o B.
3. const result = `RGB values: (${R}, ${G}, ${B})`;
   document.getElementById("result").textContent = result;
   El result col·loca els valors obtinguts anteriorment amb el sel·lector "$", dins del div buit amb identificador "result".

  
  function getRGBValue(wavelength, color) {
        const gamma = 0.8;
        const factor = 0.1;
        let R, G, B;
        const nm = parseFloat(wavelength);
        if (nm < 380 || nm > 780) {
          return 0;
        }
  
  

1. La funció getRGBValue, té dos arguments interns que són: la longitud d'ona i el color, i necessita dos constants (gamma i factor) per fer la transformació matemàtica entre longitud d'ona i valor RGB, ja que el colorn és complexe i gamma i factor corregeixeni factor corregeixen les fòrmules que veurem més endavant perquè aquí la fòrmula és molt simple: si l'usuari introdueix un valor entre 380 nm i 780 nm, es donarà un valor 0 perquè estem fora de marge de la longitud d'ona visible.

       if (nm < 380 || nm > 780) {
          return 0;
        }
        if (nm >= 380 && nm < 440) {
          R = -(nm - 440) / (440 - 380);
          G = 0;
          B = 1;
        } else if (nm >= 440 && nm < 490) {
          R = 0;
          G = (nm - 440) / (490 - 440);
          B = 1;
        } else if (nm >= 490 && nm < 510) {
          R = 0;
          G = 1;
          B = -(nm - 510) / (510 - 490);
        } else if (nm >= 510 && nm < 580) {
          R = (nm - 510) / (580 - 510);
          G = 1;
          B = 0;
        } else if (nm >= 580 && nm < 645) {
          R = 1;
          G = -(nm - 645) / (645 - 580);
          B = 0.0;
        } else if (nm >= 645 && nm < 781) {
          R = 1;
          G = 0;
          B = 0;
        }
        if (color === 'R') {
          return 255 * Math.pow(R, gamma);
        } else if (color === 'G') {
          return 255 * Math.pow(G, gamma);
        } else if (color === 'B') {
          return 255 * Math.pow(B, gamma);
        }
      }
    
     

1. Si el valor que s'introdueix es troba entre els dos valors, es fa una divisió entre el valor en específic, menys el valor màxim de marge, entre la resta dels dos marges, donant el valor d'un dels tres colors.
2. En el cas de R, la transformació és més complicada ja que hem de obtenir un nombre i multiplicar-lo per B elevat a gamma, ja que Math.pow, significa "elevat".

Projecta esspectoftrofotòmetre amb Arduino, Python i Pc

El codi d'arduino és el següent:

 
 // Creem 6 variables de tipu integer(int), vol dir que els pins del 12 al 17, així els donem noms per identificarlos perquè és mès fàcil 
 //Entendre pinLedR que 12 ja que vol dir el pin es conecta la pota R del Led RGB. Aquestes definicions ajuden a entendre el codi els humanos 
 // I tenir ordenat el codi
 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

/*setup és una funció de configuració que és obligatori declarar on diem que els pinMode que és el mode de conexió de cada pin, que pot ser sortida
(OUTPUT) perquè la llum surt cap a fora (output) en el cas del pinedR,pinedG, pinedB, pinedUV, pinedIR. En el cas del sensor LDR és un INPUT, vol 
dir que entre informació, en aquest cas llum de l'exterior
*/
void setup() {
pinMode(pinLedR, OUTPUT);
pinMode(pinLedG, OUTPUT);
pinMode(pinLedB, OUTPUT);
pinMode(pinLedUV, OUTPUT);
pinMode(pinLedIR, OUTPUT);

pinMode(pinLDR, INPUT);
/* serial està en majúscula perquè és una classe que controla la comunicació en sèrie entre el arduino i l'ordinador. Elr Arduin UNO es comuniquen
a 9600 bits per segon y els ESP-32 53 es comuniquen a 11
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
// La comunucació sèrie és a través d'un cable que antiguament s'anomenava o RS232 que tenia 9 pins, dels 9 pins algúns eren pero trasnemtre
informació tipus dúplex que vol dir que envia informació des de l'ordinador a l'arduino i a l'inreves. Internament el arduino i altres micrcontrolador 
internament també tenen connexions fisiques i protocols de sofware RS232.El  USB té 4 pins, els dos més allunyats dels centres són d'alimentació, per
donar corrent ( una dona càrrega positiva i l'altre és el terra), els dos pins del centre un circula l'informació  cap a dontre de l'ordinador i l'altre cap a fora. Serial.available és un mètode available que significa disponibeque apliquem per sintaxi del punt a una classe Serial. ( En altres lebguatges hauriem de crear un objecta es a dir Serial serial; o serial=new Serial();). El mètode avaliablle només acepta dos resultats mayor a 0 o igual a 0, si és igual a 0 significa que el cable o està conectat i dona error, i si és mayor a 0 significa que és capaz de rebre i caracter ASCII.
char comanda= Serial.read(); // Llegueix la comanda enviada pel port sèrie
//La comanda és un caràcter perquè ho definim així i perquè el port serial o USB envia caraters ASCII, i el port serial està rebent pel mètode read caracters que està llegint.
 
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;
// Si pressiono  la tecla "I" enviara el caràcter I a traves del cable mitjançant les instruccions saerialavalabel i serialread,i quan arribi la I a l'Arduino anirà al prosoccesador de l'Arduino AVR i trobarà aquest codi que diu case I que significa que si es produeix aparentant una I ha de fer un digitalwrite o encendre el LED infraroig. Passarà el matix amb el tecla 'U', però en contes de encendre  el LED infraroig encendrà el LED ultraviolat. Amés de encendre els LED els apagarà si estan  encessos amb l'instrucció !, per últim en els dos casos també els LDR perquè hem cridat la funció llegirLDR();.

case ‘R’: // Controla el LED RGB i llegeix el sensor LDR
int r = Serial.parseInt();
int g = Serial.parseInt();
int b = Serial.parseInt();
//El LED RGB no es pot encendre com els LEDs anteriors peroquè té 16 millions de combinacions, perquè són 255 vermells multiplicats per 255 blaus. Hem de posar un valor concret que pot ser introduït per  l'usuari i amb SerialparceInt agafa el valor introduït per l'usuari i si és un caracter o un número decimal el transforma en un número int o numero cence, i amb Serial l'envia a l'Arduino i emmagatzema cada número rn una variable sencera nomenada r,g o b.
analogWrite(pinLedR, r); // Controla el LED vermell
analogWrite(pinLedG, g); // Controla el LED verd
analogWrite(pinLedB, b); // Controla el LED blau
//La variable emmagatzemada r, g i b correspón a un valor entre 0 i 255 que intriduint en las 3 instrsuccions anteriors amb analogWrite que utilitzaven per el LED ultraviolat e infraroig anterior i analogWrite que estem utilitzant en LED RGB és que funció digital que només es possible fer 2 funcions (0 o 1) o LOW i HICH. En canvi analogWrite permet fer 255 valors. Les dues funcions tenen en comú que tenen dos paràmetres o arguments entre parentesis, el primer paràmetre és el numero de pin on està conectat,per exemple el LED varmell (pota vermella del LedRGB) por ser pinLedr, que és el mateix que escriure el número 12 i el segon paràmetre és r que pot ser 0 o 1, o 0 a 255 i és introduït per l'usuari que ens diu l'intensitat en que sencendrà. De 0 a 255 és una tecnología que realment no és analógica,sino PWM.Per exemple quan escric 127 a la mitad de la intensitat màxima, perquè?Realment el que observo és el LED menys intens, però el que esta pasant es que la meitat del temps s'esta apagant i l'altre meitat encenen de forma molt ràpida 01010101. Per  exemple quan escrivim 64 es repesentaria com una quarta part de la inensitat màxima,aleshores seria 0001000100010001 a tota velocitat i no veiem que s'apaga, perquè l'ordre de temps és milisegons i el nostre ull no l'observa. Per últim amb 190 seria tres quarts encesos 1110111011101110. El valor 0 analógic seria 0000000000 y el valor 255 seria 1111...
llegirLDR();
break;
}
}
// Altres parts de la teva lògica del programa
}

void llegirLDR() {
int valorLDR = analogRead(pinLDR);
Serial.print(“Valor LDR: “);
Serial.println(valorLDR);
}
//

L'objectiu és comprendre com funciona la llum mitjançant microcontroladors i programació. En el meu cas, és la transmissió de la llum a través de colorants de diferents colors.

Aquests són els passos a seguir informaticament:

• Primer: Tenir instalat Arduino IDE 2.2.1 i instal·lar un enllaç a Archivo > Preferencias > que premetrà instal·lar plaques adicionals de ESP32
• Segon:La instal·lacio anterior fa que surtin mes opcions en el menú Herramientas > Placa > Gestor de placas i busquem la nostra placa, per exemple ESP32 S3 i s'instal·latran els drivers.
• Tercer: Hem de comprobar els errors de drivers mirant a l'apartat Herramientas > Gestor de placas > esp32 > ESP32S3 Dev Module i ha de quedar un ✔ al costat Es a dir ESP32S3 Dev Module ✔ i ha de quedar el port que en el cas de windows s'anomena COMx per exemple des de COM3 fins a COM9 Amb un tick al costat COM3 ✔ si no esta el tick no esta seleccionat el port, el port i la placa.
• Quart: Si no surt el port o la placa s'ha d'anar al Administrador de Dispositivos des de Inicio. Si dona errors s'ha d'apretar amb el botó dret i comprobar que no diu funciona correctamente. Si no funciona correctament amb el boto dret lipodeu donar a Actualizar Controlador des de Windows o buscar en el meu ordinador i en el meu ordinador he d'instalar previament el driver CP102
• Cinquè: Hem de entendre perfectament el nostre microcontrolador especialment capacitats de cada pin, es a dir accepta entrades analògiques (analog imput, a trevés de convertidor analogic digital de 10, 12, 16 bits), entrades digitals (digital imput), sortides analògiques (analog output produït per PMW o Pulse With Modulation) i sortides digitals (digital output).
• Sisè: Expliquem el "pinout" del ESP32-S3 (Espressif, Shangai, Xina) a través d'aquesta imatge

• GPIO Significa General Purpose Input Output que vol dir entrada i sortida de propósit general
• Alguns GPIO són ADC Concretament 20 GPIO. Això vol dir que són possibles llocs per conectar un sensor perquè poden convertir una senyal analògica continua per exemple de llum UV en un senyal digital format només per 0 i 1 perquè es un ADC (Analog Digital Converter). Malauradament no és recomanable utilitzar alguns d'aquests ADC per conectar alguns sensors degut a que tenen altres capacitats aquests pins i perdem Aquestes capacitats o l'aparell funciona de manera incorrecta o que el propi fabricant no recomana conectar en alguns pins.
• L'ADC es un conversor de 12 bits, en el cas de ESP32-S3 i Genuino 101, de 10 bits en el cas Arduino UNO i de 15-16 bits en el cas del ADS 1115 que es pot conectar a Arduino i a Raspberry Pi o Banana Pi
• Que significa de forma practica ADC de 10 12 15-16 bits ?
• Que tenim 2 elevat al numero de bits de mesures del sensor, es a dir pel de 10 bits 2¹⁰=1024valors diferents des de 0 fins a 1023 per qualsevol sensor
• En el cas de ADC 12 bits que pertany al ESP32-S3, si connectem a qualsevol sensor es podra donar 2¹²=4096 valors des del 0 a 4095
• Què significa aquest valors de 0 a 4095? No tenen unitats, però es poden transformar a voltatge què en el cas de ESP2-S3 pot ser 3V3 (3.3 volts es posa aixi perquè els punts es poden esborarr tocan la placa al igual de 4k7 vol dir 4700 Ohms) o 5 volts ja que el sensor pot tenir 3 potes o més una anira a viltatge un altra a terra o GND per tanca el circuit i la tercera les dades del sensor (números de 0 a 4095). Si hi ha mes potes poden estar unides a un rellotge o clook o a pins de comunicació.

• Com està conectat a 5 volt si és un Arduino UNO a l'imatge superior té 1024 nivells diferents, quan sería cada nivell en volts? 5V/1024= 0,0048828125 =4,88 mV , si el valor fos 3014 quants serien els volts? 0,0048828125V x 314= 1,533203125V
• Què significa 1,53V? Equival a un nivell de radicó ultraviolada determinant, potser mesurada en mW/m² i potser relacionada amb el voltatge en una fórmula lienal que es troba en el full de caracteristiques o detasheet
• En el codi seguüent veiem la transdormacio del valor que dona Arduino de 0 a 1023 a volts

      float sensorValue;
      
      sensorValue = analogRead(A0);
      sensorVoltage = sensorValue/1024*5.0;
      

Tipus de variables en arduino

Primer de tot hem de crear una variable anomenada sensorValue i per crear-la utilitezem la istruccio float sensorValue;

//Això crearà un gran espai de memòria capaç d’emmagatzemar un número decimal, també conegut com a “floating point number” o número amb coma flotant. Aquest espai de memòria el pots anomenar com vulguis. Si l’anomenes valorSensor en castellà o català, només ho entendríem aquí.

El posem en anglès en estil camelCase o lletra de camell. Hi ha altres estils com snake_case,, kebab-,PascalCase. És a dir, la variable que emmagatzemarà els valors del sensor pot anomenar-se en els estils anteriors com sensorValue (camelCase), sensor_value (snake_case), sensor-value (kebab-case), SensorValue (PascalCase). Sempre s’ha de veure el mateix estil en un codi i el més utilitzat és el camelCase.

És important el punt i coma al final de cada línia perquè indica que l’instrucció s’ha acabat.

En els microcontroladors petits que tenen molt poca memòria (Arduina UNO 16kB molt poc comparat amb 512kB del ESP32-S3) podrien gastar menys memòria definint variables més petites que números decimals, com per exemple números enters. En aquest darrer cas seria int sensorValue; perquè int significa “integer number” o número sencer i accepta 5 digits ( 5 espais de memòria)pero només fins al número 64000 o 32000 i 1023 està dintre del marge.

Si tenim una variable float, guants digits guarda a la petita memòria del microcontrolador?

Com podemo veure a la taula. posa que float acpeta númers de fins a 3.4028235E+38, que vol dir 3.402835*10 ³⁸, és a dir 38 espais de memòria disponibles per aquesta variable.

Si en comptes d'un senor fos una sortida analògica de 8 bits que és igual a 2⁸ igual a 255,quina variable utilitzaries?

SI vull utilitzar byte no arribaria a 1023 si no a 255 i no serviria per un sensor que llegeix de 0 a 1023. Aquest de 255es podria fer servir per una sortida analògica PWM de 8 bits, però estem d'entrades analògiques, de sensors.

En el cas de arduino UNO, la velocitat de mstreig del rellotge inclós el ADC , és 125 kHz que vol dir 125000 cicles per segon. En el cas de ESP32-S3, la seva velocitat màxim és de 2 MHz, (200000 de mostres per segon) però realment s'aprofita només 1000 per segon via wifi. Altres tipus de variable que consumeixen molt poc memòria es Boolean. Boolean ve del nom d'un senyor que va inventar àlegbra basada en 0 i 1, o en el seu equivalent false i true. Es pot fer servir per començar un moviment. Primer es false i després es true si es compleix una condició co per exemple pressionar una tecla

Char es un altre tipus de variable, que vol dir caràcter i és compatible amb arduino, i que inclou els caràcters ASCIII, on podem veure que els caràcters són números tant decimals com binaris. Per exemple la lletra a és el número decimal 97 i el número binari 01100001. Perquè 0*2⁷+1^{+1*26+1*25+0*24+0*23+0*22+0*21+0*20=0+64+32+0+0+0+0+1= 97}



Cnvertidor analògic digital ADC

En el cas de arduino UNO, la velocitat de mostreig del rellotge inclós el ADC, és 125 kHz que vol dir 125000 cicles per segon . En el cas de ESP32-S3, la seva velocitat màxim és de 2MHz, (2000000 de mostre per segon) peró h2relament s'aprofita només 1000nper segon,via wifi.Aquest valors ta alts són teòrics

Codi per manipular una entrada analògica (sensor)

const int uvLEDPin = 5;// Pin digital per al LED UV const in uvSensorPin = 11; // Pin analògic per al senosr UV

Al principi de tot codi sempre hi ha les constants i les variables que utilitzarem. En aquest cas tot són constants globals i no hi ha cap biblioteca inicial importada. Una constant global vol dir que afecta totes les funcions de tot el codi. En canvi una variable local està definida dins d'una funció i no la podem cridar desde fora de la funció. Les constants signifiquen que jo en comptes d'escriure el nombre 5 he d'escriure uvLEDPin, i en comptes d'escriure 11 escric uvSensorPin, fent el codi molt més llarg, però més comprensible per un humà, perquè s'enten molt millor si és un sensor o un led ultravioleta quejo connecto. Normalment es posa en anglès camelCase.

void setup() { pinMode(uvLEDPin, OUTPUT); Serial.begin(9600); }

El void setup és una funció obligatoria del programa arduino i significa la configuració del hardware, o maquinari del propi arduino. Ens diu en primer lloc si els pins que tenim connectats són entrades o sortides, amb l'argument OUTPUT, si és una sortida, o argument INPUT, si és una entrada. Ens hem d'adonar que pinMode és una funció predefinida d'arduno que accepta dos arguments. El primer és el número o nom del pin, i el segon és si és una entrada o sortida. Serial.begin és un mètode construït amb la sintaxi del punt, això vol dir que Serial és un objecte predefinit de la classe Serial

void loop() { // Encén el LED UV //digitalWrite(uvLEDPin, 80); analogWrite(uvLEDPin, 80); // 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); }

Per exemple el codi seguent utilitza una entrada analògica de 12 bits d'ESP32-S3 i on esta conectat un sensor UV anomenat GUVA-S12