Herbs drugs from EMA

Comprobar el màxim d'absorbancia amb codi

Utilitzarem codis que faràn un escaneig o un scan, de forma que encendràn els llums red, green and blue del led RGB de forma que generarem longituds d'ona que van se 380 nanaomètes a 780 nanòmetres

Escriu la longitud d'ona en nanòmetres i converteix-la en RGB en la segúent línea

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

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

  
    

Projecte espectrofotòmetre amb Arduino, Phython i Pc

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

    
    
    //Creem 6 variables de tipo integrer(int), que els pins del 12 al 17, aixì els hi donem noms per a identificarlos perquè és més 
    //fàcil. Entendre pinLesR que 12 ja que vol dir el pin que es conecta la pota R del Led RGB. Aquestes definicions ajuden a 
    //entendre el codi els humans i tenir-ho 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 perquè la llum surt ca a fora (output) en el cas del pinLedR, pinLedG, pinLedUV, pinLedIR. En el cas del sensor
//LDR és un INPUT, que 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 arduinos UNO es comuniquen a 9600 bits per segon i els ESP-32 S3 es comuniquen a 118000
Serial.begin(9600); // Inicia la comunicació sèrie a 9600 bauds
}

void loop() {
if (Serial.available() > 0) {
//La comunicació série es a través de un cable que antigament s'anomenava o RS232 que tenia 9 pins, entre aquest 9 pins alguns eren per transmetre informació tipus dúplex que vol dir que envia informació des de d'ordinador a l'arduino i a l'inrevés. Internament l'arduino i altres microcontroladors internament tanbé tenen connexions fisiques i porotocols de software de RN232. El USB té 4 pins. Els 2 que estan més allunyats del centre, són d'alimentació per  donar corrent (un dona càrrega positiva i l'altre és el terra), els dos pins de dins, al 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 disponible, s'aplica per la sintaxi del punt a una classe Serial ( en altres llenguatges hauriam de crear un objecte, es a dir Serial serial; o serial=new Serial();). El mètode avaliable només acepta 2 resultatas, 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 caracter ASCII.

char comanda = Serial.read(); // Llegeix la comanda enviada pel port sèrie
//La comanda és un caracter perquè ho definim així i perquè el port serial o USB envia caracters ASCII, i el port serial està revent pel mètode read caracters que està llegin.

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;
//Si pressiono la tecla 'I' enviarà el caracter ASCI a través del cable mitjançant les instruccions serialavailable i serialread, i quan arribi la I a l'Arduino anirà al precessador de l¡Arduino AVR i trobarà aquest codi que diu case I que significa que si es prueix apretant una I ha de fer un digitalwrite o encendre el LED infraroig. Passarà el mateix amb la tecla 'U', per en contes de encendre el LED infraroig encendrà el Led ultravioleta. Amés de encendre els LEDs els apagarà si estan encessos amb l'instrucció!, per últim en els dos 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 comn els LEDs anteriors perquè té 16 milions de combinacions, perquè són 255vermells multiplicats per 255 blaus. Hem de posar un valor concret que pot ser intruït per l'usuari i amb SerialparceInt agafa el valor introuït per l'usuari i si és un caracter o un número decimal el transforma en un número int o integer o numero cencer, i amb Serial l'envia a l'Arduino i emagatzema cada número en 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 introduit en las 3 instroduccions anteriors amb analogWrite que encendre cada LED. la diferencia entre digitalWrite que utilitzaven per el LED ultravioleta e infraroig anterior i analogWrite que estem utilitzant en LED RGB és que el digitalWrite és una funció digital que només es possible fer 2 funcions ( 0 o 1), o LOW i HIGH. En canvi analogWrite permét fer 255 valors. Les dues funcionstenen en comú, que tenen 2 arguments entre parentesis, el primer paràmetre és el número de pin on està conectat el LED vermell (pota vermella del LED RGB), és pinLdr que és el mateix que escriure un número 12 i el segon argument és r que pot ser 0 o 1, o 0 a 255 i és intruí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 està a la meitat de la intensitat màxima, perquè? Realment el que observo és el LED menys intens, però el que està pasant es que la meitat del temps s'està apagant i l'altre meitat s'està encenen de forma molt ràpida 0101010101. Per exemple quan escrivim 64 es representa com una quarte part de la intensitat màxima, aleshores seria 0001000100010001 a tota velocitat i no veiem que s'apaga, perquè l'orde 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 i el valor 255 seria 11111111111...
llegirLDR();
break;
}
}
// Altres parts de la teva lògica del programa
}

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