Benvinguts al projecte d'espectofotometria!

L'objectiu és compendre com funcina la llum mitjançant elecrofotometres i programació i en el meu cas poder lleguir la quantitat de llum que reben diferents leds rgb de colors vermell, verd, groc, blau i blanc, per tal de relacionar-ho amb l'efecte MIMS Neocities.

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

Hem de buscar de buscar la bibliogràfia a google sobre el màxim d'absorbancia

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 conventeix-la en RBG en la següent linia

A la figura 1 podem visualtizar la relació que té longitud d'on ai color

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 anomenada "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

La paraula button crea un butó de forma automàtica que té una propietat o atribut anomenada onclick que esta 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)i onsubmit (quan envió un formulari).

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

Quan detecti que onclick es igual a true s'executara una funció que no té cap parametre 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 una funció creada en javascript més endevant que convertirà la longitud d'ona que escric en RGB.

< div id="ressult" > </div >

Un div és un divisor que és un paràgraf en aquest cas buit que té un identificador anomenat result que només es veura i s'executarà després, es a dir, quan es carrega la pàgina està buit i 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 de transformar 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 paso convertWaveLenght(), 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ó agrafa el valor (.value) de la longitud que s'ha introduït a l'input, i ho identifica perquè l'agafa amb el getElementById, i l'emmagatzxema amb un nom concret (waveLenght) 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 número sencer o integer. Si el número introduït com a nm esta 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 > 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".

Projecte espectofotometre amb Arduino, pyhthon i Pc

El codi d'Aruino es el següent:

//Creem 6 variables de tipus integer (int), vol dir que als pins del 12 al 17, els donem noms perquè així és més fàcil 
//entendre pinLedR que 12 es el pin en el que es conecta la pota R del led RGB. Aquestes definicions ajuden a entendre el codi
//com a humans i tenir més 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ó obligatoria de declarar on diem que els pinMode és el mode de conexió de cada pin, i que
//pot ser una sortida de informació (OUTPUT) perquè la llum surt cap a fora en el cas de pinLedR, pinLedG, pinLedB, pinLedUV,
//pinLedIR. En el cas del sensor LDR és un INPUT, que vol dir que la informació del exterior es transmessa cap a l'interior (llum).
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) {
//La comunicació serie es a traves d'un cable que antigament s'anomenava o RS232 que tenia 9 pins, alguns dels quals eren per
  transmetre infotrmació tipus duplex. Això vol dir que envia la informació de l'ordinador a l'arduino i a l'inrevés. Internament
  l'arduino i altres microcontroladors tenen, actualment, connexions físiques i protocols de software RS232. El USB té 4 pins, 
  els dos als extrems són l'alimentació, per donar corrent (una dona càrrega positiva i l'altre és "el terra"), els altres dos pins
  que es troben al centre transportan l'informació: un cap a dintre de l'ordinador i altre cap a fora. Serial.aviable és un métode
  aviable que significa disponible, que apliquem per la sintaxi del punt a una classe serial (en altres llenguatges hauriem de crear
  un objecte es a dir Serial (en majuscules puc sospitar que es tracta d'un tipus de classe) serial; o serial=new Serial(); ). El
  mètode aviable només acepta dos resultats major a 0 o igual a 0, si és igual significa que no està conectat o dona un error, i si
  és major vol dir que és capaç de rebre un caràcter ASCII. 
  
char comanda = Serial.read(); // Llegeix 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 caràcters ASCII, i el port serial esta rebent pel mètode read caràcter que esta llegint.

switch(comanda) {
case ‘I’: // Encén o apaga el LED infraroig i llegeix el sensor LDR
digitalWrite(pinLedIR, !digitalRead(pinLedIR)); //true= no true. Es fa el contrari del que s'indica
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 través del cable mitjançant les instruccions serialAviable i serialRead i quan
arribi la I a l'arduino, anirà al processador de l'Arduino AVR i trobarà aquest codi que diu "case" i que significa que si es 
produeix apretant una I ha de fer un digitalWrite o encentre el LED infraroig. Passarà el mateix amb la tecla "U", però en comptes
d'encendre el LED infraroig encendrà el LED ultraviolat. A més de encendre els LED també els apagarà en el cas de que estiguin
encessos amb l'instrucció !, per últim en amdós casos també llegirà 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 anterior perquè té 16milions de combinacions, al ser 255 tons vermells múltiplicats per
255 blaus i verds. Hem d'indicar un valor concret que pugi ser introduït per l'usuari, i amb SerialParceInt agafa aquest valor. Si 
és un caràcter o número decimal el transforma en un número int o integer, o número sencer. Amb Serial l'envia a l'Arduino i
l'emmagatzema cada número en una variable sencera anomenada 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 enmmagatzemada r,g i b correspon a un valor entre 0 i 255 introduït en les 3 instruccions anterior amb analogWrite per
encendre cada LED. La diferència entre digitalWrite que utilitzavem per al LED ultraviolat e infraroig anterior i analogWrite que
estem utilitzant en LED RGB és que el digitalWrite i l'analogWrite és que la pimera és una funció digital en la qual només es
possible fer 2 funcions (0 o 1 o LOW i HIGH) i la segona permet 255 valors. Les dues funcions tenen en comú que tenen dos parámetres
o arguments entre parentèsis, el primer paràmetre és el número de pin on està conectat, per exemple el LED vermell (pota vermella
del LEDRGB) és pinLdr 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 s'encendrà. De 0 a 255 és una tecnología que realment no és analògica, sinó
PWM. Per exemple, quan escric 127 esta a la meitat de l'intensitat màxima, perquè? Perquè el que observo és el LED menys intens,
però realment que pasa esque la metitat del temps s'esta apagant i l'altra meitat encenent constantment i ràpidament (en milisegons)
(0001000100010001). Això fa que no pugem veure que s'apaga. 

llegirLDR();
break;
}
}
// Altres parts de la teva lògica del programa
}

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

Aquest son els pasos a seguir informàticament

• Primer: tenir instalat arduino IDE 2.2.1 i instal·lar un enllaç a Arduino > Preferences > que permetra instal·lar una placa adicional de ESP32
• Segon: la instal·lació anterior fa que sortim més opcions en el menu Herramientas > Placa > Gestor de placas i busquem la nostra placa, per exemple ESP32 S3 i s'intal·laran els drivers
• Tercer: hem de comprobar els errors de driver mirant a l'apartat Herramientas > Gestor de placas > Esp32S3 Dev Module i ha de quedar un ✔ al costat, es a dir, ESP32 A3 Dev Module ✔ i ha de quedar el port que en el cas de windows s'anomena COMx, per exemple des de COM9 amb tick al costat de COM3 ✔. Si no esta el tick, no està sel·lecionat el port i la placa, s'ha d'anar a l'administrador de dispositivos (es per anar des de l'inici).
• Quart: Si no surt el port o la placa s'ha d'anal al Administrador de Dispositivos de Inicio. Si dona error s'ha d'apretar amb el botó dret i comprobar que no diu funciona correctamente. Si no funciona correctament amb el boto dret li podeu donar a Actualizar Controlador des de Windows o buscar en el meu ordinador i he d'instalar previament el driver CP102
• Cinqué: Hem d'entendre perfectament el nostre microocontrolador especialment les capacitats de cada pin, es a dir si acepta entraddes analògiques (analog input, a través de convertidor analògic digital de 10 12 16 bits), entrades digitals (digital input), sortides analògiques (analog output produït per PWM o Pulse with Modulation) i sortides digitals (digital output)
• Sisè: Explicem el pin out 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 son ADCS concerament 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 recomenable utilitzar alguns d'aquests ADC per conectar alguns sensors degut a que tenen altres capacitats aquests pins i perdem aquestes capacitats o funciona malament l'aparell o que el propi fabricant no recomana conectars alguns pins.
• L'ADC es un conversor anàlogic digital de 12 bits en el cas de ESP32-S3 i Genuino 101, de 10 bits en el cas d'Arduino UNO i de 15-16 bits en el cas del ADS 1115 que es pot conectar a Arduino i a Rasperry Pi o Banana Pi
• Que significa de forma practica ADC de 10 12 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 de ADC que pertany al ESP32 S3, si connectem un sensor ens podrá donar 2⁼¹²=4096 valors des de 0 a 4095.
• Que significa aquests valors de 0 a 4095? No tenen unitats, però és poden trasformar a voltage què en el cas de ESP32 S3 pot ser 3V3 (3.3volts, es posa així perquè els punts poden esborrar tocant la placa al igual que 4k7 vol dir 4700 Ohms) o 5volts ja que el sensor pot tenir 3 potes o més, una anirá a voltatge, una altra a GND (per tancar el circuit) i la tercera anirá a les dades del senor (números de 0 a 4095). Si hi ha més potes poden estar unides a un rellotge CLK o a pins de comunicació.

• Com esta conectat a 5 volts és Arduino UNO a l'imatge superior té 1024 nivells diferents, quant seria cada nivell en volts? 5v / 1024 = 0,0048828125v = 4,88mV. Si el valor fos 314 quants serien els volts? 0,0048828125v x 314 = 1,533203125v.
• Que 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 transformació del valor que dona arduino de 0 a 1023 volts

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

Tipus de variables a 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

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

Un cop que hem entés els tipus de variables d'Arduino parlem del ADC i com una senyal totalment continua la transformem en 1 i 0

Entrades analògiques

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