Vidéo sur mon télescope à réalité augmentée

J’ai réalisé une vidéo sur mon projet de télescope à réalité augmentée. Je l’ai présenté en long et en large dans les articles précédents. L’ajout dont je n’ai pas parlé est l’arduino et le BMP085 (un capteur de température et de pression), permettant d’afficher sur l’écran LCD les données de température et d’altitude en temps réel. L’arduino envoie une commande par un port série à la carte Nextion, qui actualise les données affichées à l’écran. Le code arduino, basé sur les exemples de Nextion (je n’arrive plus à retrouver le lien) est le suivant :

#include <SoftwareSerial.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP085.h>

SoftwareSerial mySerial(10, 11); /*Even though you can use the hardware serial port in this case I think it is better to
leave the hardware serial open for debugging purposes*/

Adafruit_BMP085 bmp = Adafruit_BMP085(10085);

float temperature;

void setup() {

Serial.begin(57600); //open the hardware serial port
while (!Serial) { // wait for serial port to connect. Needed for native USB port only
;
}
/* Initialise the sensor */
if(!bmp.begin())
{
/* There was a problem detecting the BMP085 … check your connections */
Serial.print(« Ooops, no BMP085 detected … Check your wiring or I2C ADDR! »);
while(1);
}

Serial.println(« Serial On »); //Print this messages when the serial port is connected
mySerial.begin(9600); // set the data rate for the SoftwareSerial port
}

void loop() {
/* Get a new sensor event */
sensors_event_t event;
bmp.getEvent(&event);

/* Display the results (barometric pressure is measure in hPa) */
if (event.pressure)
{
/* Display atmospheric pressue in hPa */
Serial.print(« Pressure: « );
Serial.print(event.pressure);
Serial.println( » hPa »);

/* Calculating altitude with reasonable accuracy requires pressure *
* sea level pressure for your position at the moment the data is *
* converted, as well as the ambient temperature in degress *
* celcius. If you don’t have these values, a ‘generic’ value of *
* 1013.25 hPa can be used (defined as SENSORS_PRESSURE_SEALEVELHPA *
* in sensors.h), but this isn’t ideal and will give variable *
* results from one day to the next. *
* *
* You can usually find the current SLP value by looking at weather *
* websites or from environmental information centers near any major *
* airport. *
* *
* For example, for Paris, France you can check the current mean *
* pressure and sea level at: http://bit.ly/16Au8ol */

/* First we get the current temperature from the BMP085 */
float temperature;
bmp.getTemperature(&temperature);
Serial.print(« Temperature: « );
Serial.print(temperature);
Serial.println( » C »);

/* Then convert the atmospheric pressure, SLP and temp to altitude */
/* Update this next line with the current SLP for better results */
float seaLevelPressure = SENSORS_PRESSURE_SEALEVELHPA;
Serial.print(« Altitude: « );
float alt = bmp.pressureToAltitude(seaLevelPressure,
event.pressure,
temperature);
Serial.print(alt);
Serial.println( » m »);
Serial.println(«  »);
String sendThis = «  »; //Declare and initialise the string we will send

delay(300); //Probably unneccessary, but I give the screen some time to respond
sendThis = « n0.val= »; //Build the part of the string that we know
sendThis.concat(int(temperature)); //Add the variable we want to send
writeString(sendThis); /*Use a function to write the message character by character to the Nextion because
mySerial.write(sendThis) gives you an error due to a datatype mismatch*/
delay(300); //Probably unneccessary, but I give the screen some time to respond
sendThis = « n1.val= »; //Build the part of the string that we know
sendThis.concat(int(alt)); //Add the variable we want to send
writeString(sendThis); /*Use a function to write the message character by character to the Nextion because
mySerial.write(sendThis) gives you an error due to a datatype mismatch*/
}
else
{
Serial.println(« Sensor error »);
}

}

//NOTE: A great big thanks to: RamjetX for writing this function. You can find his/her post here: http://forum.arduino.cc/index.php?topic=89143.0. Please go give him/her some Karma!
void writeString(String stringData) { // Used to serially push out a String with Serial.write()

for (int i = 0; i < stringData.length(); i++)
{
mySerial.write(stringData[i]); // Push each char 1 by 1 on each loop pass
}

mySerial.write(0xff); //We need to write the 3 ending bits to the Nextion as well
mySerial.write(0xff); //it will tell the Nextion that this is the end of what we want to send.
mySerial.write(0xff);

}// end writeString function

Défrichage de fibre optique pour l’imagerie oxymétrique

Parce que oui, c’est possible de faire autre chose que des sapins de Noël avec de la fibre en PMMA à 10¢ le mètre. Je me suis lancé sérieusement, dans les derniers jours, dans mon projet d’imagerie oxymétrique. Pour commencer, j’ai découpé 147 bouts de 30 centimètres afin d’avoir une image composée d’un carré de 7×7 (ou toute autre forme comprenant 49 bouts de fibre sur l’image de la caméra).

Sources lumineuses

En utilisant deux sources de longueur d’onde différente, l’une dans le rouge, l’autre dans l’infrarouge, il est possible de déterminer le taux d’hémoglobine oxygénée par rapport à l’hémoglobine désoxygénée, en se basant sur les courbes d’absorption particulières. Ce principe est largement utilisé dans les sphygmo-oxymètres optiques, mesurant la concentration d’oxygène en un point (normalement un doigt) et supposant qu’elle est homogène dans le reste du corps. Or, la consommation d’oxygène par les organes varie selon l’effort énergétique qu’ils doivent fournir. En ayant une méthode qui permet de mesurer les variations d’oxygénation dans un volume donné, on ouvre la porte à toutes sortes d’applications intéressantes, comme l’imagerie spectroscopique proche infrarouge fonctionnelle (functional near-infrared imaging, fNIR, en anglais), ce qui est très excitant puisqu’elle permet de visualiser les processus mentaux en temps réel avec, ce que je souhaite vérifier, du matériel très peu coûteux et facile à trouver.

 (source : http://www.oximetry.org/pulseox/principles.htm)

Atténuation de la fibre

Résultats de recherche d'images pour « attenuation pmma fiber »

L’atténuation dans le proche-infrarouge pour le PMMA grimpe rapidement, comme on peut le voir sur le graphique. À 850nm, on a environ 5dB/m d’atténuation. Il faut donc garder les bouts de fibre très courts. Avec 30 centimètres, les pertes sont de 1,5dB (~71% du signal est transmis), ce qui fait mal, mais pas trop, espérons-le.

Matériel

Pour mes sources lumineuses, j’utilise deux DEL à très haute puissance optique (2,6W) afin d’être certain d’avoir suffisamment de signal. J’aurais pu utiliser des lasers, mais mon objectif était d’injecter simultanément toutes les fibres, le plus simplement possible. De plus, les DEL sont moins coûteuses et moins dangereuses (quoique à cette puissance, même si ce n’est pas un faisceau cohérent, j’ai tendance à être prudent quand même).

Je les avais déjà préalablement soudées l’année passée, lorsque j’avais commencé ce projet. Je leur ai rajouté un petit cylindre imprimé en 3D, qui se met directement autour du petit bulbe-lentille de la DEL et qui est suffisamment large pour y faire tenir les 49 fibres.

J’utilise pour les alimenter un power supply d’ordi, qui me donne 15V et 5A, le tout régulé à 700mA par diode par des régulateurs spécialisés pour cette application.

J’ai remarqué qu’allumées à pleine puissance, elles deviennent très chaudes très rapidement, ce qui va être à tenir en compte dans la suite du projet. Il va falloir soit les utiliser périodiquement avec un rapport cyclique faible, soit rajouter un système de refroidissement adéquat, ou bien y aller avec une combinaison de ces deux approches.

À 850nm, l’oeil perçoit un rouge très faible, sûrement la limite inférieure du spectre de la diode, qui est en fait bien plus lumineuse, tel qu’on peut l’observer avec la caméra qui lui donne une couleur mauve.

  

La DEL à 660nm est extrêmement brillante, puisque la quasi-totalité de son spectre est dans le visible. On peut voir que les fibres contiennent bien le faisceau.

Pour la caméra, j’utilise une caméra de drone de marque RunCam qui a une sensibilité absolument phénoménale pour son prix abordable : jusqu’à 0,0001 Lux (elle m’avait coûté 50$US si je me souviens bien). Je lui ai imprimé en 3D un petit adaptateur qui rassemble toutes les fibres et y fait tenir la caméra. Toutefois, comme on peut le voir sur la dernière image, ce sera à refaire puisque le focus de la caméra est à l’infini, ce qui mélange toutes les fibres en un gros blob de lumière. Il va donc falloir rajouter de l’optique pour imager correctement les fibres et arriver à les distinguer individuellement afin de pouvoir traiter le signal. C’est le pari à relever en ce moment dans ce projet.