Valors d'absorbància màxima dels colorants:

Comprobar el màxim d'asorbància 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 conventeix-la en RBG en la següent linia

A la figura 1 podem visualitzar la relació que té la longitud d'ona i el color

< input type="number" id="wavelength" value="550" min="380" max="780" >

El codi anterior que transforma 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 propietat 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 es una propietat molt importannt ja que es com el DNI i el cridarem en getElementById

< button onclick="convertWavelength()" > Converteix a RGB < /button >

La aparaula button crea un botó de forma automàtica que té una propietat o atribut anomenada onclick que està esperant ser clicada o no. Altres que poden existir onmouseover (quan estic a sobre), onkeydown (quan pressiono una tecla), on load (quan es carrega una pàgina o un element), onsubmeet (quan envio un formulari).

El contingut del botó s'escriu abans del 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 transfomar un valor que donem nosaltres inicialment, en un altre diferent. En 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, en aquest cas convertir la longitud d'ona i poso convertWaveLength(), en camelCase, i posem un parentesis buit perquè no depen de paràmetres o arguments.

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

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

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;
        }
  
  

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 introduït com a nm està fora de marges no facis res que vol dir 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 color és complexe i gamma i 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 < 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".

Projecte espectrofotòmetre amb Arduino, Python i PC

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

 
 
//Creem 6 variables de tipus 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 el que es conecta la pota R del Led RGB. Aquestes definicions ajuden a entendre el codi els humans 
// 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 pinLedR, pinLedG, pinLedB, pinLedUV, pinLedIR. En el cas del sensor LDR és un INPUT, 
vol dir que entra 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. Els rduino uno es comuniquen a 9600 bits per segon i els ESP-32 S3 es comuniquen a 115200 bits per segon
Serial.begin(9600); // Inicia la comunicació sèrie a 9600 bauds
}

void loop() {
if (Serial.available() > 0) {
//La comunicació sèrie ed a través d'un cable que antigament s'anomenava RS232 que tenia 9 pins, dels 9pins algúns eren per transmetre informació tipus dúplex que vl dir que envia informació des de l'ordinador a l'arduino i a l'inrevés. Internament el arduino i altres microcontrolador internament també tenen connexions fisiques i protocols de software RS232. El USB té 4 pins, els dos més allunyats dels centre són d'alimentació, per donar corrent(un dona càrrega positiva i l'altre és el terra), els altres  dos pins del centre un circula l'informació cap a dintre de l'ordinador i l'altre cap a fora. Serial.available és un mètode available que significa disponibleque apliquem per la sintaxi del punt a una classe Serial (en altres llenguatges hauriem de crearun objecte 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 no està conectat o dona error, i si és major a 0 significa que és capaç de rebre un carater ASCII.
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);
}
 

Els passos a seguir informàticament són els següents

• 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 analògic digital 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 o 15-16 bits? Que tenim 2 elevat al número de bits de mesures del sensor, es a dir pel de 10 bits 2¹⁰=1024 valors diferents des de 0 fins a 1023 per qualsevol sensor
• En el cas ADC de 12 bits que pertany al ESP32-S3, si connectem a qualsevol sensor es podrà donar 2¹²=4096 valors des de 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 ESP32-S3 pot ser 3V3(3.3 volts, es posa així perquè els punts es poden esborrar 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 anirà a voltatge, una altre anira a terra o GND per tancar el circuit i la tercera anirà les dades del sensor (números de 0 a 4095). Si hi ha més potes poden estar unides a un rellotge CLK o a pins de comuicació.


• Com està conectat a 5 voltsi és un Arduino UNO a l'imatge superior té 1024 nivells diferents, quant sería cada nivell en volts? 5V / 1024 = 0,0048828125V = 4,88 mV. Si el valor fos 314 quants serien els volts? 0,0048828125V x 314 = 1,533203125V.
• Què significa 1.53V? Equival a un nivell de radiació ultraviolada determinat, potser mesurada en mW / m² i potser relacionada amb el voltatge en una fórmula lineal que es troba en el full de característiques o datasheet
• En el codi següent veiem la trasnformació del valor que dona Arduino de 0 a 1023 a volts

       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 utilitzem la instrucció float sensorValue;

Això crearà un espai de memòria gran capaç d'emmagatzemar un número decimal = "número point number" = número amb coma flotant. Aquest espai de memòria el puc anomenar com vulgi, si l'anomenes valorSensor en castellà o en català només ho entrendriem aquí.

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

Es important el ; de cada línia perquè indica el final de l'instrucció.

En els microcontroladors petits que tenen molt poca memòria (Arduino UNO 16 KB, molt poc comparat a 512 KB del ESP32 S3) podrien gastar menys memòria definint variables més petites que números decimals com per exemple números sencers. En aquest darrer cas l'instrucció seria int sensorValue; perquè int significa integer number o número sencer i acepta 5 digits (5 espais de memòria) però només fins al número 64000 o 32000 i 1023 està dintre del margue.

Si tenim una variable float, quants digits guadra espai a la petita memòria del microcontrolador?

Com podem veure a la taula, posa que float acepta números de fins a 3.4028235E+38, que vol dir 3.4028235*10³⁸, es a dir 38 espais de memòria disponibles per aquesta variable

Si en comptes d'un sensor 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 255 es podria fer servir per una sortida analògica PWM de 8 bits, però estem parlant d'entrades analògiques de sensors

Convertidor analògic deigital ADC

Altres tipus de variables que consumeixen molt poca memòria es boolean. Boolean ve del nom d'un senyor Boole que va inventar àlgebra 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ó com 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 ASCII , 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*2⁶+1*2⁵+0*2⁴+0*2³+0*2²+0*2¹+1*2⁰= 0+64+32+0+0+0+0+1 = 97



En el cas 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àxima és de 2 MHz, (20000000 de mostres pers segon) però realment s'aprofita només 1000 per segon, via wifi. Aquests valors tan alts són teòrics

• Per exemple e codi següent utilitza una entrada analògica de 12 bits d'ESP32-S3 i on està conectat a un sensor UV anomenat GUVA-S12