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 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 la 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 introudïr qualsevol tipus de valor pel teclat, però la propietat o atribut de input anomenat type està definida com a number i només permet introduïr números. El value és una propietat o atribut de input que fa que surti com a valor predeterminat, mín i màx sés els valors mínim i màxim. No s'acceptaràn valors fora del marge. La Id és una propietat molt important perquèés com el DNI i el cridarem en getElementByID

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

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

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..

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

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

En el cas de R

Projecte espectrofotometre amb arduino, Phyton i PC

El codi d'Arduino és el segúent

      
//creem 6 varibles de tipus integer(int), vol dir que els pins del 12 al 17, els hi donem noms per identificarlos perquè és més fàcil 
//entendre pinLedR que 12 que vol dir que al pin en el que es conecta la pota R del Led RGB. Aquestes definicions ajuden a entendre el codi als 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 es obligatori de aclarar on diem que els pinMode que és el mode de conexió de cada pin, que por ser sortida
//(OUPUT) perquè el lumm surt cap a fora. En el cas del pinLedR, pinLedG, pinLedB, pinLeDuv, pinLedIR. en el cas del sensor LDR és un INPUT vol dir qu entra informació, en aquest cas la llum 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 elarduino i l'ordinador.
Serial.begin(9600); // Inicia la comunicació sèrie a 9600 bauds
}

void loop() {
if (Serial.available() > 0) {
//La comunicació sèrie és a traves d'un cable que antigament s'anomenaba sèrie o RS232 que tenía 9 pins, d'aquest alguns eran d'alimentació i d'altres de transsmició de tipus duplex. És a dir, que envía informació dese l'ordinador a l'Arduino i a l'inreves. Internament a l'Arduino i altres microcontroladors hi tenen actualment connexions físiques i protocols de sofware RS232. L'USB té 4 pins, els de la vora són d'alimentació, per donar corrent( un dona càrrega positiva i l'altre el terra,negativa). Els 2 pins del centre, una circula l'informació capa a dintre e l'ordinador i l'altre capa a fora.Serial.available és un mètode avaiable que significa disponible, que apiliquem en la sintaxi del punt en una classe anomenada Serial(en altres llengüatges hauríem de crear un objecte, és a dir, Serial serial; o Serial=new Serial();). El mètode available només admet 2 resultas, major a 0(significa que és capaz de rebre un caràcter ASCII) o igual a 0(significa que no esta conncectat al cable o hi ha un error).
char comanda = Serial.read(); // Llegeix la comanda enviada pel port sèrie
//La comanda és uun caracter, perquè el port sèrial o USB envía caracters ASCII. El serial.rea(); està rebent pel mètode read caracters que esta llegint.
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' envira el caràcter I a traves del cable mitjançant les instruccions serialavalabel i serialread, i quan arribi la I a l'Arduino anirà al prsoccessador de l'Arduino AVR i torbarà aquest codi que diu case I que significa que si es produeix 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 ultraviolat. Amés de encendre els LED 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 com els LEDs anteriors perquè té 16 milions 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 integer o numero cencee, i amb Serial l'envia a l'Arduino i emmagatzema 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 emmmagatzemada r, g i b correspón a un valor entre 0 i 255 que introduint en las 3 intrsuccions anteriors amb analogWrite per encendre cada LED. La diferència entre digitalWrite que utilitzaven per el LED ultraviolat 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 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 número de pin on esta conectat, per exemple el LED vermell (pota vermella del LedRGB) és 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 esta a la meitat de la intensitat màxima, perquè? Realment el que observo és el LEED menys intens, però el que esta pasant es que la meitat del temps s'esta apagant i l'altre meitat s'esta encenen de forma molt ràpida 01010101. Per exemple quan escrivim 64 es representaria com una quarta 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 000000000 i e valor 255 seria 111111...
llegirLDR();
break;
}
}
// Altres parts de la teva lògica del programa
}

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