Semaine 7 : Les découpeuses Laser

Merci d’avoir regardé cette vidéo sur les principes de fonctionnement de la découpeuse laser.

Comme il existe de très nombreux logiciels pour passer d’un fichier informatique aux instructions machines (le fameux .gcode dont nous parlions les semaines passées), nous n’avons pas souhaité rentrer dans la partie logicielle des découpeuses. Nous vous invitons plutôt à visiter un FabLab qui dispose d’une machine de ce type et à regarder la vidéo ci-dessous produite par Dimitri du FabLab de Lyon (car sa vidéo est pédagogique et efficace).

Merci à John Lejeune, FabManager du FabLab de Rennes pour ce cours

Si vous voulez télécharger le pdf de la vidéo c’est par ici.

La découpe laser par Dimitri

Fonctions et boucles

Comme beaucoup de questions ont été soulevées les semaines passées sur les boucles et les fonctions, nous avons jugé bon de revenir sur deux concepts importants lorsque l’on développe :

Les boucles

Les boucles permettent de répéter une séquence d’instructions tant que la condition d’arrêt n’est pas vraie. Nous avions ainsi pu voir dans les semaines passées la boucle for. Rappelez-vous, elle nous permettait de faire bouger notre servomoteur d’une position de départ vers une postion d’arrivée avec un pas donné.

Sachez qu’il existe d’autres boucles comme while. Cette boucle tant que boucle sans fin, et indéfiniment, jusqu’à ce que la condition ou l’expression entre les parenthèses () devienne fausse. N’oubliez donc pas de modifier doit modifier la variable testée, sinon la boucle while ne se terminera jamais !

Si nous reprenons l’exemple Sweep que nous avions vu en semaine 5 et que nous souhaitons remplacer les boucles for par des boucles while. Voici ce que ça pourrait donner :

Avec for

for(pos = 0; pos < 180; pos += 1)  
{                                  
  myservo.write(pos);              
  delay(15);                       
}                                  
for(pos = 180; pos >= 1; pos -=1 ) 
{                                  
  myservo.write(pos);              
  delay(15);                       
}                                  

Avec while

pos = 0;             
while(pos < 180)     
{                    
  myservo.write(pos);
  delay(15);         
  pos += 1;          
}                    
pos = 180;           
while(pos >= 1)      
{                    
  myservo.write(pos);
  delay(15);         
  pos-=1;            
}                    

Les fonctions

Quoi de mieux que citer le wiki ! Une fonction permet d’encapsuler du code avec une petite latitude de paramétrage. L’intérêt est que cela évite de dupliquer des instructions et qu’en découpant le code en série de fonctions celui-ci devient plus clair et plus compréhensible.

Une fonction peut accepter des paramètres en entrée et renvoyer une valeur en sortie. Aussi bien les paramètres que la valeur retournée sont facultatifs. La déclaration classique d’une fonction se fait comme ceci :

typeSortie nomFonction(type1 paramètre1, type2 paramètre2)
{
  // instructions... 
}

où typeSortie et type* sont des types (comme par exemple int pour un nombre entier). Nous allons prendre comme exemple une fonction qui allume une LED pendant une durée exprimée en millisecondes. Cette fonction ne retournera pas de valeur mais prendra deux paramètres : la broche où la LED est raccordée et la durée pendant laquelle la LED devra être allumée. Cela se traduit de la façon suivante :

void allumerLED(int broche, int duree)
{   
    digitalWrite (broche, HIGH);
    delay (duree);
    digitalWrite (broche, LOW);
}

Si on reprend le TP n°2 mais en utilisant cette nouvelle fonction, loop() se réduit à :

void loop ()
{
    allumerLED(verte, 3000);
    allumerLED(orange, 1000);
    allumerLED(rouge, 3000);
}

Même avec cet exemple très simple l’intérêt est assez évident et immédiat.

Il est également possible d’utiliser une fonction pour effectuer une opération et de retourner un résultat. Pour retourner une valeur l’instruction return est utilisée, par exemple pour une fonction qui réalise une addition :

int addition(int a, int b)
{   
    return (a+b);
}

Merci à fb251, DDR et mary1in pour avoir rédigé et corrigé ce cours sur le wiki.

Les Transistors (enfin)

Sujet très, très vaste : il y a pléthore de bouquins sur les transistors et leur mise en œuvre…

Ici (car moi je suis loin de tout connaître à ce sujet), nous allons rester simple et nous abordons quelques petits points au sujet de quelques types de transistors.

Nous allons parler principalement de deux familles de transistors : les transistors bipolaires (les transistors classiques) et les transistors à effet de champ ("Field-Effect Transistors" en anglais – d’où leur petit nom de FET).

Dans nos montages autour des microcontrôleurs, l’utilisation des transistors se limite souvent à alimenter (marche / arrêt) quelque chose qui a besoin de plus de puissance que celle fournie directement par les broches du microcontrôleur (qui fournissent de l’ordre de 20mA maximum), où l’alimentation des composants fonctionnent à des tensions autres que les 3,3v ou 5v disponibles en sortie des microcontrôleurs. Ex. des moteurs, des LEDs de puissance, une ampoule…

Nous allons regarder comment faire. D’abord, quelques symboles :

Notez bien que, comme pour les diodes, la flèche indique le sens du courant.  Dans les deux familles on trouve une variante de type ’n’ (ou NPN) et une variante de type 'P' (ou PNP). Pour l’instant on va regarder la variante ’n’ car c’est la plus pratique pour un grand nombre de nos montages.

Les transistors bipolaires fonctionnent un peu comme une vanne pilotée : un petit courant qui traverse les bornes Base-Emetteur est capable de 'contrôler' un plus gros courant qui traverse les bornes Collecteur-Emetteur – avec deux conditions qui nous intéressent beaucoup : le cas où le courant C-E est bloqué (condition arrêt), et le cas où l’intensité C-E est ou maximum (condition marche).

Pour les FET le fonctionnement est similaire, mais c’est la tension Gate-Source qui contrôle l’intensité Drain-Source.

On va sauter tout de suite dans les montages, espérant que nous comprendrons quelque chose à la fin !

Transistor NPN comme interrupteur (de puissance)

C’est peut-être l’utilisation première des transistors autour des microcontrôleurs. Une fois n’est pas coutume : le montage sur la 'planche à pain’…

Notez que j’ai mis un transistor NPN dans Fritzing, sans vérifier si l’orientation "EBC" correspond à l’orientation standard pour ces transistors.  Il faut vérifier avec la bonne fiche technique.

Voici le schéma…

Quelques questions pour voir si vous avez bien suivi jusque-là :

Réponses :

Retournons à nos moutons : ce montage de transistor. Si la sortie (pin 13) est maintenue au niveau "low" (0v) la base et l’émetteur du transistor se trouvent au même potentiel, pas de courant B-E et le transistor reste bloqué : pas de courant entre collecteur et émetteur et le moteur ne tourne pas.

Si maintenant la sortie est basculée "high", un courant traverse la résistance R2 et la jonction B-E du transistor. L’intensité B-E dépend de la tension appliquée (ici c’est 5v), et la valeur de la résistance. Si l’intensité est suffisante, le transistor entre en conduction et la tension entre les bornes C-E chute pour s’approcher de 0v. Le moteur se trouve branché entre le 5v et (presque) 0v et va donc tourner.

Regardons cela de plus près avec un exemple concret - le transistor BC337 :

Fiche technique : Transistor BC337

Plus : IC_MAX : 500mA ; IB_MAX:200mA ; VCE_MAX :50v ;VBE_MAX:5v ; P_TOT:625mW

Mais non, mais non. OK j’admets - c’est en anglais ce qui (vous) complique pas mal la chose ! C’est la première difficulté en électronique : trouver les informations concernant les composants que l’on souhaite utiliser ! Beaucoup de fiches techniques existent en anglais, il faut pas mal fouiner sur internet pour en trouver en français…

Bon, c’est quoi tout ce charabia ?

Quelques paramètres sont assez simples à comprendre :

• P_TOT : Puissance totale : 625mW  (dépasser ce seuil ça sent le cramé !)
• IC_MAX : Intensité qui traverse la borne C ( idem ) ;
• IB_MAX : Intensité qui traverse la borne B ( idem ) ;
• VCE_MAX : Tension maximale entre les bornes C-E ;
• VBE_MAX : … je pense que vous avez compris le système, non ?

Autrement dit : vous êtes prévenus ! Pour que le transistor reste de ce monde, il ne faut pas trop jouer au malin !

Dans le tableau nous ne nous soucions que de quelques valeurs :

• h_FE (parfois appelé Beta ou β) : le gain ou amplification d’intensité ;
• V_BE : la chute de tension entre les bornes B-E

Laissons les autres valeurs aux puristes…

C’est le gain qui nous intéresse le plus. La valeur minimale de 100 veut dire qu’une petite intensité traversant B-E provoque une intensité 100 fois plus grande entre C et E. C’est ça l’intérêt des transistors !

Je remets le même schéma, simplifié :

La 'charge' peut être le moteur, un relais, une ampoule 6v, un haut-parleur…

J’ai 'oublié' la diode, mais c’est obligatoire pour les charges dites 'inductives’ : bobine, relais, moteur.

Examinons une valeur de la fiche technique à ne pas dépasser :

IC_MAX : (Intensité qui traverse la borne C) : 500mA.

Ça va jusque là ? Ce n’est pas si dur, hein ?

Last question (oups – je me suis laisser emporter) :

C’est un poil plus compliqué, mais pas beaucoup. Allons voir…

Le courant qui traverse R2 traverse aussi la jonction B-E du transistor. Ce n’est pas dit dans le texte, mais cette jonction est exactement comme une DIODE. Et nous avons vu qu’une diode provoque TOUJOURS une chute de tension d’environ 0,7v. Dans le tableur il est indiqué une valeur de 1,2v maximale, mais cette valeur varie avec la température ambiante (la température à l’intérieur du transistor, plutôt).

Restons donc avec nos 0,7v fétiches. Pour que I_BE ne dépasse pas 5mA avec une tension de 'pilotage' de 5v (la sortie de l’Arduino), nous devons 'chuter' $5 – 0,7 = 4.3 V$ quand I_BE = 0,005A.

La valeur minimum de R2 est donc $R = \frac{U}{I} = \frac{4.3}{0.005} = 860 \Omega$.

Par sécurité (et facilité) je mets toujours une résistance de 1K pour R2.

Voila ! On est content ?

Notez que j’ai choisi la valeur de β la plus faible : vous avez vu dans le tableur que la valeur maximum peut être jusqu’à six fois plus. C’est encore mieux pour nous : cela veut dire que le transistor est vraiment en conduction maximum avec les 5mA de I_BE.

Voilà, pour cette semaine, les transistors.

Merci à Glenn Smith pour ce cours !

Arduino thermomètre avec diode pour sonde

Deuxième partie

La semaine dernière nous avons vu qu’une simple diode pouvait fonctionner comme sonde de température avec notre Arduino.  Cette semaine nous allons continuer avec ce montage afin de le faire fonctionner sur une plage de températures de 0°C à 100°C.  Souvenez-vous que nous avions (OK, moi j’ai) choisi un point arbitrairement sur la courbe comme point de repère.  J’ai pris un point qui correspondait à une chute de tension de 600mV à 20°C.

Le montage et le "Arduino Sketch" de la semaine dernière nous ont permis de régler le potentiomètre (résistance variable) afin de calibrer ce point précis.  La grande difficulté est de savoir si la diode est bien à 20°C au moment de ce réglage!  À la fin de ce module je vous donnerai une autre façon de calibrer le montage.  Mais, finissons avec la version "Approximation et triche" !

Trichons…

La triche ici est que nous allons supposer une correspondance linéaire entre la température et la chute de tension de -2mV / °C. De plus, nous avons décidé que, à 20°C, la chute de tension était de 600mV.  À partir de cette valeur on peut déduire que, à 0°C la chute de tension devrait être de $600 mV + (20 \times 2 mV)= 640 mV$.  Dans l’autre sens, la chute de tension à 100°C devrait être de $600 mV - (80 \times 2 mV) = 440 mV$.

Les valeurs retournées par la fonction analogRead() ne sont pas directement en mV, il faut les convertir.  Souvenez-vous que nous avons demandé à l’Arduino de nous donner des valeurs avec une référence à 1,1V.  Un résultat de 1023 équivaut 1,1V donc chaque intervalle de 1 est l’équivalent de 1,1 / 1023 = 1.075mV.  Nous pouvions trouver la valeur qui correspond aux 640mV (point 0°C) : $\frac{640}{1.075} = 595$.  Et, idem, pour le point 100°C : $\frac{440}{1.075} = 409$.

Reste à faire en sorte de traduire une gamme de valeurs allant de 595 à 409 en température de 0°C à 100°C.

Comment faire ?

Nous avons déjà vu une fonction Arduino très intéressante : map()

La syntaxe (c’est à dire la bonne façon de l’écrire) de cette fonction est : 

map(valeur_en_entrée, gamme_départ_bas, gamme_départ_haut, gamme_résultat_bas, gamme_résultat_haut)

Nous pouvons donc écrire :

// Lire la valeur
DiodeValue = analogRead(Diode);
// Traduire valeur en degrés C
Température = map(DiodeValue, 595, 409, 0, 100);

Voici un exemple de Sketch complet :

/*
  Montage pour faire un thermomètre avec une diode pour sonde
  Deuxième partie : thermomètre fonctionelle (approximative)
  La diode est montée en sens 'conduction' (cathode branche sur GND)
  avec une résistance fixe de 4.7k et une résistance variable de
  préférence de 10k en serie.
  
  Il faut d'abord régler le montage pour que le résultat de analogRead();
  donne 558 (environ 600mV) a 20°C (Sketch "Diode_Thermo_1")
  
  Ne plus toucher le potentiomètre après !
  
  Avril 2014 MOOC Fabrication Numérique

*/
// Définition des broches
#define Diode A0 // Broche pour la diode

// variables:
int DiodeValue = 0;  // valeur lue sur la diode
int Temperature = 0; // Brrrrr
float Result = 0.0;  // pour les calculs

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
  // Réference maximum pour le convertisseur ADC = 1,1v
  // au lieu des 5v par défaut.
  analogReference(INTERNAL);
}

void loop() {
  // Lire la valeur
  DiodeValue = analogRead(Diode);
  Serial.print("Valeur : ");
  Serial.print(DiodeValue);
  // Traduire valeur en degrés C
  Temperature = map(DiodeValue, 595, 409, 0, 100);
  // Puis afficher
  Serial.print("\t environ ");
  Serial.print(Temperature);
  Serial.println(" °C");
  delay(10000);
}

Sonde flexible

Ce montage est utile pour nous donner une indication de la température ambiante autour de l’Arduino.  Si on veut mesurer la température à un endroit précis, ou si on veut calibrer le système avec des températures connues, il faut fabriquer une sonde "déportée" et flexible.  Voici comment le faire, étape par étape. Vous aurez besoin de :

• Une diode 1N4148 ou équivalent;
• Deux fils flexibles de même longueur mais de couleurs différentes;
• Quelques petites longueurs de gaine thermorétractable (ou - si vous êtes patient - un peu de mastic silicone);
• Savoir souder avec un fer à souder…

Allons-y !

1. Couper le fil Cathode (bande colorée) à environ 15mm de long, et couper un morceau de gaine d’environ 3cm:

   

2. Souder un des fils sur la Cathode (et notez la couleur choisie !).  Astuce : si vous n’êtes pas très expérimenté encore avec le fer à souder, tenir la diode par le fil Cathode avec une pince à bec fin (tenir entre le corps de la diode et la soudure) - ceci évite les doigts brûlés mais, surtout, aide à éviter la surchauffe de la diode.

   

3. Laisser l’ensemble se refroidir puis faire glisser le morceau de "gaine thermo" sur votre soudure en couvrant bien au moins la moitié du corps de la diode.  Faire chauffer la gaine rapidement avec un briquet jusqu’à un rétrécissement total.

   

4. Côté Anode, couper le fil à environ 1cm et faire la deuxième soudure.  Laisser refroidir.

   

5. Couper un deuxième morceau de gaine, glissez-le sur l’ensemble en faisant bien chevaucher la première gaine : faire chauffer (vite!)  Si vous n’avez pas de la gaine thermorétractable vous pouvez enduire l’ensemble soudures / diode avec un mastic silicone APRÈS avoir tordu les fils dans leur forme définitive.

6. Plier un des deux fils contre la diode afin de donner une forme de sonde.  Si vous avez de la gaine avec un diamètre un peu plus grand vous pouvez recouvrir l’ensemble.

   

7. Si vous avez la possibilité de mettre des connecteurs à l’autre extrémité des deux fils flexibles votre sonde sera plus facile à brancher sur la platine d’expérimentation.  Sinon dénuder environ 15mm et faire étamer (couvrir d’une fine couche de soudure) les deux fils.

   

Ça y est !

Calibration avec deux points connus

Pour améliorer ce montage il faut noter la valeur retournée par la fonction analogRead() avec une température connue basse et une température connue haute.  Notre sonde flexible sera utile car, si vous avez bien protégé les soudures, vous pouvez l’immerger dans un liquide…  Un verre d’eau plein de glaçons nous donnera une référence pour 0°C, de l’eau bouillante pour 100°C (ne faites pas chauffer la diode trop longtemps, par contre - juste le temps pour que le résultat se stabilise).

Ensuite vous n’avez qu’à mettre vos nouvelles valeurs dans la commande map()

Suite

Maintenant que la fonctionnalité de base est maîtrisée, à vous de modifier et d’améliorer le Sketch pour le rendre encore plus utile.  La semaine prochaine je vous donnerai quelques pistes et un montage plus complet.

Merci à Glenn Smith pour ce cours !