Oscillographe C1-94

J'ai acquis dernièrement un oscilloscope collector, le C1-94. Un oscilloscope provenant de la "production de l'URSS". Cette article a pour but d'aider les nouveaux acquéreurs afin de les guider pour leurs premiers pas. Je ne prétends pas être as de la configuration de cette oscillo, mais croyez moi, j'aurais bien aimé tomber sur cette article en cherchant sur Google ! C'est d'ailleurs là, le but premier de ce carnet/blog de réalisation : aider les recherches, donner des pistes, tracer un petit chemin pour rejoindre la grande route de l'électronique !

Oscillographe C1-94

Pour utiliser l'oscilloscope :

1) Brancher la sonde exotique sur l'oscilloscope.

2) Brancher la banane rouge à la masse du circuit sur lequel l'on va procéder à des mesures.

3) Brancher la pointe de touche à l'endroit où l'on veut afficher la tension.

Sonde exotique

Rien de compliquer me direz-vous, mais pas évident non plus !

Un petit exemple de tracé sur l’oscilloscope avec Arduino : la MLI

Introduction

Une technique largement répandue en électricité est la modulation de largeur d'impulsions (MLI ; en anglais : Pulse Width Modulation, soit PWM). Ce procédé permet de faire varier la tension sans changer la "valeur initiale", en alimentant de manière "tout-ou-rien" où rien est appelé état "discret". Ainsi "en appliquant une succession d'états discrets pendant des durées bien choisies, on peut obtenir en moyenne sur une certaine durée n'importe quelle valeur intermédiaire" (cf Wikipédia MLI).

Prenons un exemple. Nous alimentons une machine à courant continu à une tension initiale de 24V. Nous souhaitons que le moteur tourne moins vite, il suffit de diminuer la tension d'alimentation. Mais en sortie, nous ne pouvons avoir que 24V. Il faut donc appliquer une succession d'état discret afin de moduler la tension moyenne !

En haut, sans MLI. En bas, avec MLI.

La tension se calcul ainsi  :

Tension moyenne = (Tension max. * durée tension max) / temps période

Pour notre exemple (fréquence = 3Hz = 3 éventements pas seconde) :

Tension moyenne = 12 * (1/3) = 4V

MLI et Arduino

Afin de donner un exemple d'utilisation de cet oscilloscope, je vous invite à lire l'exemple de mon-club-elec.fr. C'est celui-ci que j'utilise dans la vidéo ci-dessous.

Tracer une tension MLI

Fréquence faible, lumière intense.

Fréquence élevée, lumière faiblarde.

Afin de "figer" l'image, de la stabiliser, vous devez activer le mode "Déclencher" :

1. Enfoncer le bouton "Decl".
2. Enfoncer les deux boutons du carré vert foncé "Decl"
3. Régler le niveau de déclenchement avec le potard du milieu.

Le reste des réglages (balayage et amplification) est identique à un oscilloscope plus récent. Pour plus d'information, n'hésitez pas à commenter l'article !

Détecteur sonore avec amplification simple

Aujourd'hui, après une longue absence, je vais vous présenter un petit système que je cherche à réaliser depuis bien longtemps : un détecteur sonore.

J'ai enfin trouvé un schéma électronique pour amplifier simplement une tension issue d'un microphone de type électret, ci-dessous. Avec ce composant, le but est de mesurer l'intensité sonore ambiante, de l'amplifier et à terme de détecter un bruit.

Micro électret

L'amplificateur

Le signal issus de l'électret étant trop faible pour être interprété tel quel par un microcontrôleur, il faut l'amplifier. Cela consiste a augmenter les variations de tension issues du capteur. 

Le schéma de l'amplificateur que j'utilise provient du blog lowvoltage.wordpress.com. N'hésitez pas à consulter le site pour plus d'informations sur le fonctionnement du circuit.

Amplificateur pour électret

Le composant clé de se montage est le LM358. Cette puce 8 broches contient deux amplificateurs opérationnels , qui, comme leurs noms l'indiquent, amplifient une différence de potentiel à ses entrées. Le LM358 est conçu pour un usage général comme les amplificateurs , les filtres passe-haut et bas, les filtres passe-bande et les additionneurs analogiques.
Avant d'utiliser un nouveau composant, il est toujours utile de consulter sa fiche composant (datasheet), voici quelques éléments que j'ai sélectionné :

1. Large DC Voltage Gain: 100 dB.
2. Wide Power Supply Range: Single Supply: 3V to 32V.
3. Very Low Supply Current Drain (500 μA)—Essentially Independent of Supply Voltage
4. Le circuit interne qui nous permet de savoir comment le brancher par rapport à notre schéma ci-dessus. On utilise donc soit l'entrée A soit la B (mais pas les deux en même temps hein !) :

Circuit interne du LM358

Les deux condensateurs C1 et C2 sont dits "chimiques"; ils sont donc polarisés (borne + et -). Attention aux branchements !
Je préfère vous prévenir car javais fait l'erreur, attention à bien lire le schéma : il y a des fils qui se croisent mais où il n'y a pas de jonction !

! Afin d'améliorer l'amplification, il est possible d'ajouter un condensateur de 100nF entre VCC et GND, comme proposer par l'auteur.

Voilà, l'amplificateur est prêt, il ne reste plus qu'à brancher A0 sur une entrée analogique de l'Arduino par exemple !

L'amplificateur sur une plaque d'essai

Deux scripts pour utiliser ce microphone avec l'Arduino

L'article de lowvoltage.wordpress.com étant bien fait, il propose un petit exemple très intéressant. En effet, on remarque que le bruit peut être gênant en utilisant l'exemple du programme de l'Arduino "AnalogReadSerial", on manque de précision, la tension oscille bizarrement. Pour pallier ce problème, l'article propose de tester plusieurs fois (sur un intervalle de temps très court inférieur à la seconde) la valeur analogique lue par A0, de noter la valeur minimale et maximale, et de faire la différence. Et ça marche !

L'exemple lowvoltage.wordpress.com traduit et commenté :

/**
 * Mesure la tension sur une broche analogique sur une période de temps de ~1s
 * et retourner les valeurs Min, Max et Diff sur le port Serial.
 *
 * Auteur: Dimitar Kovachev, http://lowvoltage.wordpress.com/
 * Traduction: Théophile D.
 *

* Released under the Creative Commons Attribution Share-Alike 3.0 license
 * http://creativecommons.org/licenses/by-sa/3.0/
 */
const int analogPin = 0;

void setup() {
  Serial.begin(9600); 
}

void loop() {
  int mn = 1024;     // mn diminution seulement
  int mx = 0;        // mx diminution seulement


  // Exécuter 10000 lectures. Mettre à jour mn et mx à chaque fois.
  for (int i = 0; i < 10000; ++i) {
    int val = analogRead(analogPin);
    mn = min(mn, val);
    mx = max(mx, val);
  }

  // Envoyer le min, le max et delta sur le port Serial
  Serial.print("m=");
  Serial.print(mn);  
  Serial.print(" M=");
  Serial.print(mx);  
  Serial.print(" D=");
  Serial.print(mx-mn);  
  Serial.println();  
}

Mon exemple version détecteur sonore :

const int analogPin = 0;

const int led = 12;

const int seuil = 80;

void setup() {
  pinMode(led, OUTPUT);
}

void loop() {
  int mn = 1024;
  int mx = 0;

  for (int i = 0; i < 10000; ++i) {
    int val = analogRead(analogPin);
    mn = min(mn, val);
    mx = max(mx, val);
  }
  //Si la différence "seuil" est dépassée, on allume la led
  if(mx-mn>seuil)
  {
    digitalWrite(led, HIGH);
    delay(1000);
    digitalWrite(led, LOW); // il faut éteindre la led ensuite pour éviter les interférence...
    delay(100); 
  }
}

Et voilà, n'hésitez pas à commenter !

Contrôler du 230V/Ac à l'aide d'un relais sur un circuit 5V

Utile, simple et efficace, voici comment utiliser un relais pour contrôler du 230V/Ac à l'aide d'un relais sur un circuit 5V.

En effet, on peut être amené au cours de certain montage à utiliser une tension supérieur pour faire fonctionner un moteur, une lampe... Le relais, placé sur un premier circuit (de tension max. 5V par exemple), permet de contrôler un interrupteur sur un second circuit ayant une tension max. plus importante, le tout sans contact physique entre les deux circuits. Le système du relais est simple : lorsque une bobine reçois du courant, elle génère un champ magnétique qui vient pousser ou tirer une lame aimantée dans l'autre partie du relais.

Voilà un exemple de ce que l'on peut réaliser :

Remarques :

1. Le relais est représenté par le composant RL1. On distingue la partie bobine (l'espèce de ressort) et l'"interrupteur".
2. Penser à la diode ! Elle permet d'éviter la casse en cas de surtension lorsque le courant chute dans la bobine.
3. Certains relais peuvent demander plus (parfois beaucoup plus) de 100mA. Or sur une Arduino, une broche digitale ne peut fournir que 40mA, d'où le système d'amplification du courant (que l'on retrouve sur la gauche).
4. Attention au 230V !

Pour en savoir plus je conseille de visiter le très bon site sonelec-musique.com et l'article sur les relais.

Simuler un système complet avec ISIS

Vérifier qu'un système (programme+circuit) fonctionne c'est possible avec Proteus, un logiciel de Labcenter Electronics. Ce logiciel permet, entre autres, la création de schémas et la simulation électrique mais aussi, grâce à des modules additionnels, ISIS est également capable de simuler le comportement d'un microcontrôleur (PIC, Atmel, 8051, ARM, HC11...) et son interaction avec les composants qui l'entourent.

Se procurer le logiciel (il existe une démo) : labcenter.com

Pour vous montrer un peu comment il fonctionne, nous allons simuler un compteur d'impulsion avec affichage sur écran LCD en utilisant un Atmega328, le pic de l'Arduino (tiens tiens !).

Etape 1 : écrire le programme et le compiler avec le logiciel Arduino

On pourrait passer par un autre logiciel, peut-être plus pratique, mais cela nous évites de réinstaller quoique ce soit.
Le but étant de faire simple, on utilise deux exemples que l'on bidouille l'un dans l'autre: HelloWord et StateChangeDetection. Ce qui donne :

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int buttonPin = 0;
// Variables will change:
int buttonPushCounter = 0;   // counter for the number of button presses
int buttonState = 0;         // current state of the button
int lastButtonState = 0;     // previous state of the button 

void setup() {
  pinMode(buttonPin, INPUT);
  
  // set up the LCD's number of columns and rows: 
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("Compteur:"); // "counter"
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // Print the number
  lcd.print(buttonPushCounter);
  // print the number of seconds since reset:
  buttonState = digitalRead(buttonPin);

  // compare the buttonState to its previous state
  if (buttonState != lastButtonState) {
    // if the state has changed, increment the counter
    if (buttonState == HIGH) {
      // if the current state is HIGH then the button
      // wend from off to on:
      buttonPushCounter++;
    }
  }
  // save the current state as the last state, 
  //for next time through the loop
  lastButtonState = buttonState;
}

Rien de compliqué, si vous avez besoin de commentaire, laissez m'en un justement...

Etape 2 - Récupérer le fichier .hex

Nous, simples mortels, sachons lire et écrire en C (le language Arduino). Mais il en est autrement pour les microcontrôleurs et les ordinateurs de manière générale. Le logiciel fait la conversion entre C et hexadécimal au moment du téléversement sur le PIC. Pour la simulation, nous avons besoin du fichier encodé, en hexa donc.
Pour le récupérer, c'est un peu casse-tête. D'abord il faut enregistrer le programme et le compiler. Pendant cette opération, il est envoyé dans les fichiers temporaires de l'ordinateur. Cherchez où ce cache (c'est bien le cas de le dire) ce dossier. Sous Windows 8 c'est : C:\Users\Théophile\Local Settings\Temp" (oui je m'appelle Théophile).
Une fois dans ce dossier des fichiers temporaires, classez les fichiers par date et par ordre décroissante. Votre fichier .hex ce trouve dans le premier dossier, en tête, commençant par "build" (pour ce tuto le miens réponds au doux nom de "build9199467709888312371.tmp").
Copiez-le ailleurs.

Etape 3 - Réaliser le montage virtuel

Sélection des composants

Pour sélectionner un composant, cliquer sur "P" dans Devices.

Dans la base de donnée, préparer les composants suivant :

• Atmega328p
• PG24064F (l'afficheur 16*2)
• RES10K
• BUTTON
• Un condensateur (capacitor) 10nF

Réaliser le circuit

C'est intuitif, je vous laisse découvrir comment faire : placer les composants et reliez-les comme sur mon schéma :

Ces circuits sont la combinaisons des deux exemples (à retrouver ici et là) , soient:

J'ai juste ajouter un petit filtre sur le bouton pour supprimer les rebonds.

Pour savoir comment se nomme chaque broche, on utilise une carte du microcontrôleur :

Configurer l'ATmega328

Il faut configurer l'ATmega328. Double-cliquez dessus. Dans l'absolut, il faut régler la vitesse d'horloge mais là on ne se sert pas du timer donc on peut laisser les valeurs par défaut  Il vous suffit donc de sélectionner votre fichier .hex.

Ok pour sauvergarder.

Simuler

Lancez la simulation. Cliquez plusieurs fois sur le boutons poussoirs et admirez !

N'ayant détaillé que très peu, n'hésitez pas à poser des questions. Télécharger les fichiers.

Astuce : Comment utiliser une carte Arduino comme programmeur FTDI ?

Dernièrement, j'ai commandé une carte Arduino Ethernet dans l'optique de réaliser un système d'alarme (je présenterai le système dans un futur article). Seulement je n'avais pas consulté en détail les caractéristiques et il se trouve que cette Arduino ne possède pas de port USB mais 6 broches pour un adaptateur FTDI.

Il faut donc utiliser un programmeur pour charger des programmes. Il en existe dans le commerce mais pourquoi ne pas se débrouiller tout seul comme un grand ? Il vous suffit d'avoir une Arduino Uno (OU Duemilanove, Diecimila, Mega 2560, Mega 1280 ou Nano), dans le but de programmer : Arduino Pro / Pro Mini / Mini / LilyPad (ou tout Arduino avec  ATmega168 / ATmaga328). Attention, seules les cartes 5V.

Préparer la carte Uno, celle qui servira de programmeur

Retirer le PIC (ATmega328) de la carte en prenant soin de ne pas tordre les broches. Penser avant tout à noter le sens.

Puis préparer les fils de cette manière (on remarque que le PIC a été enlevé) :

Utiliser votre nouveau programmeur

Vous pouvez connecter votre Uno programmeur à la carte que vous voulez programmer. Pour le sens, il faut vérifier la position de la broche GND (masse). Exemple :

Brancher votre nouveau programmeur sur l'ordinateur (par câble USB), le voyant power de la carte qui va être programmée doit s'allumer. Dans le logiciel Arduino, sélectionner le nom de la carte programmée dans la Outils / Type de carte. C'est prêt, n'hésiter pas à téléverser un exemple pour vérifier.

Réaliser un thermomètre électronique avec Arduino

Internet, je te salut et je te remercie pour l'accueil !

Bien, aujourd'hui je vais vous expliquer comment réaliser un thermomètre électronique sans trop de difficulté. Il vous faudra :

• Une carte Arduino (celle utilisée est une Uno)
• Un breadbord
• Un résistance 2,2k
• Une sonde de température deux broches
• J'utilise une KTY 10-5 (référence exacte: Q62705-K110), je vous invite à consulter la fiche technique.

Ce genre de sonde est en faite une résistance variable. Lorsque la température augmente, la résistance augmente. Pas proportionnellement malheureusement.

Etape 1 : Ohmmetre

Une Arduino ne peut mesurer directement la valeur d'une résistance sur ses ports analogiques, il faut réaliser un pont diviseur de tension. En cherchant un peu, on peut trouver facilement un montage dans le genre, par exemple celui de wiki.t-o-f.info.

Voici mon montage :

Pour trouver la valeur de la résistance R1, on utilise le calcul suivant:

Or, à 25°C, la sonde résiste à une valeur de 1950 à 1990Ω. Donc la résistance minimal doit être au alentours de 100Ω et la maximale de 50k environs... 2,2K convient.

Cependant, pour plus de précision, j'ai vérifier la valeur de R1 avec un ohmmètre du commerce pour être plus précis car une résistance n'est jamais à la valeur exacte indiquée. J'ai donc trouvé R1=2178Ω.

On branche les fils, on programme l'Arduino et c'est fini !

La résistance de droite corresponds à R2 (pour cette mesure, elle vaut 220Ω)

Le programme (à copier-coller dans le logiciel) :

int Vcc = 5; //V
int R1 = 2178; //omh (résistance fixe = racine carrée(valeur minimale de la résistance variable * valeur maximale de la résistance variable)   )
float U1;
float R2;

void setup() {
  Serial.begin(9600);
}

void loop() {
    // tension U1 en mv
    U1 = analogRead(A0)*5.0/1023.0;

    // valeur de la résistance R | Pont diviseur de tension
    R2 = ((Vcc - U1)*R1)/U1;

    // envoi de la valeur de la résistance sur le port serie
    Serial.println(R2);
}

 Etape 2: conversion de la résistance en température

Maintenant que l'on est capable de mesurer une résistance, c'est un jeu d'enfant. On consulte la fiche technique du composant (rappel: KTY 10-5) et on récupère la fonction qui donne la température en fonction de la résistance. Soit:

On code ça en language Arduino:

// tension U1 en mv
U1 = analogRead(A0)*5.0/1023.0;

// valeur de la résistance R | Pont diviseur de tension
R2 = ((Vcc - U1)*R1)/U1;

Kt = R2 / R25;
    
temperature = 25 + ( sqrt ( pow(alpha,2) - 4 * beta + 4 * beta * Kt) - alpha ) / ( 2 * beta );

 Avec (définit plus haut dans le programme):

//Conversion resistance => température
int R25 = 1970;
float alpha = 7.88*pow(10,-3);
float beta = 1.937*pow(10,-5);
float Kt;
float temperature;

On peut à présent afficher la température sur le port série en remplacement  Serial.println(R2); par Serial.println(temperature);.

Etape 3:

Un afficheur LCD c'est mieux qu'un écran d'ordinateur, n'est-ce pas ? Le but de cet article n'étant pas d'apprendre à utiliser un LCD, je ne détaillerai pas. Cependant voilà comment brancher :

Le code complet:

// inclure la librairie pour le LCD
#include <LiquidCrystal.h>

// preparer les broches du lcd
LiquidCrystal lcd(11,10,5,4,3,2);

int Vcc = 5; //V
int R1 = 2178; //omh (résistance fixe = racine carrée(valeur minimale de la résistance variable * valeur maximale de la résistance variable)   )
float U1;
float R2;

//Conversion resistance => température
int R25 = 1970;
float alpha = 7.88*pow(10,-3);
float beta = 1.937*pow(10,-5);
float Kt;
float temperature;

void setup() {
  lcd.begin(16, 2);
  lcd.print("Temperature :");
}

void loop() {
    // tension U1 en mv
    U1 = analogRead(A0)*5.0/1023.0;

    // valeur de la résistance R | Pont diviseur de tension
    R2 = ((Vcc - U1)*R1)/U1;
    
    Kt = R2 / R25;
    
    temperature = 25 + ( sqrt ( pow(alpha,2) - 4 * beta + 4 * beta * Kt) - alpha ) / ( 2 * beta );
    
    // envoi de la valeur de la température
    lcd.setCursor(0, 1);
    lcd.print(temperature);
    lcd.print("  ");
    lcd.write(11011111);
    lcd.print("C");
    delay(500);
}

Petit photo preuve !