Forum Électro-Bidouilleur
Sections => Vos projets et Montages d'Électronique => Discussion démarrée par: bubblecat le Avril 09, 2016, 09:57:03 am
-
Salut à tous,
En regardant une video de jipihorn sur un traceur de courbe "du pauvre" ( https://www.youtube.com/watch?v=Bv5mPc9fVIU ) J'ai eu l'idée de reproduire l'opération avec un arduino et excel. Le but n'étant pas de faire quelque chose d'abouti mais juste de voir si en partant d'une idée, j'arrive à obtenir quelque chose qui fonctionne. Etant débutant avec l'arduino et les microcontrolleurs actuels en général et ayant pratiquement tout oublié de ce que j'ai appris à l'école il y a ...euh... longtemps ^^ Je voulais juste "essayer un p'tit truc" ;)
Le principe est simple, on injecte un courant via une tension et une resistance dans la base d'un transistor, on applique une tension variable de 0 à 5v au collecteur du transistor et on recupere la tension emetteur. Ensuite on passe à un autre palier de tension de base (8 paliers de 5v/8) et on recommence. Les données de la tension emetteur sont envoyées dans une feuille excel et ensuite il suffit faire un graphique. Dans la video, Jipi utilise 2 générateurs de fonctions et une oscillo. Ici je vais générer les différentes tensions avec la pwm et récupérer la tension émetteur à l'aide de l'arduino.
Premier problème : avoir une tension dc constante et lisse à partir de la pwm. Solution : video du bidouilleur sur le projet de charge fictive ^^ N'ayant que des condensateurs de 1µ, j'ai cependant doublé le filtre afin d'avoir quelque chose de lisse (l'arduino de base à un pwm à 500Hz je crois).
Second problème, envoyer le tout dans excel : J'ai trouvé une feuille avec tout de pret pour lire le port série, tout le mérite reviens au créateur Roberto Valgolio qui a fait un outil bien utile je trouve, la feuille est dispo ici : http://www.robertovalgolio.com/sistemi-programmi/arduino-excel
Troisième probleme : les filtres de la pwm ne sont pas efficaces pour peu qu'on leur demande un courant et augmenter la taille des condensateurs ralentirait tout le systeme. Je passe donc par des ampli-op montés en buffer et là tout va bien. Je n'avais que des lm324 et donc je me mange 0.5v de rail, ce qui fait qu'en fait je ne balaye que de 0.5 à 4.5v environ. Et augmenter la tension d'alimentation de lm324 n'est pas une bonne idée, l'arduino etant sensible à tout ce qui dépasse les 5v, il vaut mieux ne pas prendre de risques inutiles en cas de défaillances.
au final ça donne ceci dans excel :
(http://img15.hostingpics.net/pics/51353839tc.jpg)
le tracé brun est celui d'un bd139, le vert celui d'un bc547 et le bleu un bc 337. Les valeurs en abscisse et ordonnée ne sont pas significative, c'est excel qui les a mis par défaut. (Je connais pas trop ce systeme de chart dans excel).
le circuit est relativement simple :
(http://img15.hostingpics.net/pics/683417tccircuit.jpg)
le transistor est celui qui est testé. les filtres R20k +C1µ en série arrivent à lisser correctement la pwm émise par les pin 9 et 10 de l'arduino, le signal résultant est envoyé dans l'ampli op via une R de 100k (histoire de ne vraiment pas déranger le lissage de la pwm). les ampli op sont montés en buffer donc VS = VE (aux tensions de rail pres). Les diverses tensions sont récupérées par A0, A1 et A2. Les ampli op sont alimentés par le +5v de l'arduino.
le code :
//Traceur de courbe du tres pauvre
// initialisation des variables
int i;
int j;
int VCC;
int VRB;
int VEG;
int RB;
int RE;
int idx = 0;
int VRBpin = 9;
int VCCpin = 10;
int VEGpin = A0;
int VCCinpin = A2;
int VRBinpin = A1;
float VCCf;
String eCol="ABCDEFGHIJKLMNO"; //chaine servant à déterminer quelle colone on utilise dans excel
char cCol;
String tempCol="X";
String commandCol="";
int countStr = 0;
float VRBf;
float VEGf;
float VCEf;
void setup() {
//Initialisation des pins
pinMode(VRBpin,OUTPUT);
pinMode(VCCpin,OUTPUT);
pinMode(VEGpin,INPUT);
Serial.begin(9600);
idx = 0 ;
}
void loop() {
countStr = 0;
for (i=0;i<256;i=i+(256/8)){ // Ici on incrémente la tension de base de 0 à 5 v par pas de 5v/8
analogWrite(VRBpin,i);
delay(40);
cCol = eCol.charAt(countStr);//opération servant à déterminer quelle colone utiliser dans excel
tempCol.setCharAt(0,cCol);
for (j=0;j<256;j++){ // Ici on incrémente la tesion du collecteur de 0 à 5v pour chaque "pas" de la tension de base
analogWrite(VCCpin,j);
delay(20);
VEG = analogRead(VEGpin); // on récupère la tension émetteur
VCC = analogRead(VCCinpin);// on récupère la tension appliquée au collecteur
VRB = analogRead(VRBinpin);// on récupère la tension appliquée à la base
VEGf = (float)VEG/1023*5.0;// on convertit la valeur en échelle 5V
VCCf = (float)VCC/1023*5.0;// on convertit la valeur en échelle 5V
VRBf = (float)VRB/1023*5.0;// on convertit la valeur en échelle 5V
commandCol = ("XLS,write,Sheet2," +tempCol); //on commence l'envoi des données dans excel
Serial.print(commandCol);
Serial.print(idx + 1);
Serial.print(",");
Serial.print(VEGf);
Serial.print("\n");
idx++;;
}
analogWrite(VCCpin,0);
idx++;;
delay(300); // delai servant à decharger les condensateurs de filtrage
countStr++;
idx = 0 ;
}
idx++;;
analogWrite(VRBpin,0);
analogWrite(VCCpin,0);
delay(20000);
}
Dans le montage et le code, je récupère via A1 et A2 les tensions appliquées à la résistance de base et au collecteur mais je ne les récupère pas dans excel. J'ai du chipotter un peu avec la façon dont les données sont inscrites dans la feuille excel (la string eCol). Au final j'obtient 8 colonnes (les 8 paliers de la tension de RB) de 256 valeurs (les valeurs de la tension émetteur en fonction de la tension collecteur).
La feuille dans laquelle sont envoyée les données se nomme "Sheet2", vous pouvez changer le nom dans cette ligne : commandCol = ("XLS,write,Sheet2," +tempCol); ;) (cette feuille ne se trouve pas dans le fichier excel original) ;)
Voilà , c'est pas tres génial mais bon, ça fonctionne. Faudrait que j'améliore le coté "chart" de la feuille histoire d'avoir quelque chose d'un peu plus parlant. Pas évident de réaliser tout ça sans oscillo (je me suis débrouillé avec l'entree de la carte son et un oscillo-carte son freeware pour analyser le filtrage de la pwm ^^ ).
merci d'avoir lu :)
Bubblecat
-
À vaincre sans péril, on triomphe sans gloire... Tout le mérite vous revient d'avoir imaginé une méthode simple et flexible sans l'utilisation outils de mesure plus onéreux. Un peu de fignolage, et vous aurez une solution tout à fait fonctionnelle. Ça donne des idées! Bravo! :)
-
Merci :)
Une prochaine étape sera aussi d'essayer de remplacer l'arduino par un microcontroleur plus modeste et surtout pour pouvoir avoir un montage "indépendant". J'ai pensé à un ATtiny ou un PIC (ça me permettrait de découvrir le monde des PIC par la même occasion :) et il y a moyen de les programmer facilement via l'arduino uno). Mais j'ai aussi d'autres idées de projets et d'expérimentations ;) Et en passant merci à vous pour vos videos, elles font partie de celles qui m'ont donné l'envie de ressortir mon fer :)
-
bonne réalisation, attention EB c'est contagieux LoL
Arduino est une plateforme vraiment géniale et n'as de limite que l'imagination.
-
j'avoue être tombé accro à "... je vous l'donne en mille : le condensateur électrolytique..." ;D
Et effectivement l'arduino est bien pratique pour toute sorte de réalisations, et un bon outil pour l'apprentissage des microcontrolleurs et de l'électronique :)
-
Même mes garçons m'agacent avec ce "... je vous l'donne en mille : le condensateur électrolytique...". ;)
Ma foi, mais c'est devenu une phrase mythique! 8)
En passant, le petit clip vidéo en question est totalement fictif, et a été enregistré seulement pour les fins de la vidéo thème. Vous ne trouverez pas ce clip ailleurs!
-
Bonsoir,
Désolé de remonter un sujet vieux de plus d'un an.
Je ne sais pas ou en est notre ami bubblecat mais comme je m’intéresse aussi à un traceur de courbes, je voudrais vous faire connaître ce projet que j'ai sous le coude depuis quelques mois.
Il est basé sur un Arduino, de quelques composants et du logiciel Processing comme environnement graphique.
(Processing n'est pour ma part, pas très intuitif mais il est très puissant)
Bon, je voulais mettre le pdf du projet mais il est trop gros.
Je peux vous mettre à la place le lien de la page (je ne sas pas si c'est permis) sinon j'enverrai le fichier par mail aux membres intéressés)
-
Hello. On peut mettre des liens vers des fichiers, pour ma part je suis preneur
Merci
-
Bonjour à tous,
Alors, voici le lien pour ce traceur de courbes : http://www.instructables.com/id/Arduino-BiCMOS-Curve-Tracer/ (http://www.instructables.com/id/Arduino-BiCMOS-Curve-Tracer/)
Le lien pour charger Processing : https://processing.org/ (https://processing.org/)
Et éventuellement le lien pour Octave : http://www.gnu.org/software/octave/download.html (http://www.gnu.org/software/octave/download.html)
Bonne lecture
Jean-Paul
-
Bonjour Jean-Paul,
Merci d'avoir soumis votre circuit pour le bénéfice de tous. Il faut être imaginatif pour faire de l'analogique avec un microcontrôleur, et vous avez atteint votre objectif. Bravo!
Je tente de comprendre comment vous mesurez le courant de collecteur. Ç'est peut-être évident, mais je n'arrive pas à voir... :-[ Vous mesurez le courant à l'émetteur, mais pas au collecteur (du moins je ne vois pas). Assumez-vous que les courants de l'émetteur et du collecteur sont les mêmes? Vous avez des entrées analogiques de disponibles sur l'Arduino. Pourquoi ne pas mesurer le courant au collecteur?
Merci!
-
Petit détail. Votre appelation BiCMOS porte à confusion. BiCMOS est une technologie de semiconducteur combinant Bipolaire et CMOS. Je présume que ce n'est pas à cela que vous faites référence...
https://fr.wikipedia.org/wiki/BiCMOS
-
Bonjour,
Vous m'attribuez un montage qui n'est pas le mien... ;D
J'avais trouvé cet "Instructable" il y à quelques mois et j'avais mis ce projet de côté avec l'idée de l'essayer un jour, ayant tout le matériel à disposition.
Je m'en suis souvenu en lisant le présent post et j'ai publié le lien.
Et en fait, vous êtes allé bien plus loin que moi dans l'étude...
Je n'ai donc pas les réponses à vos questions
-
Très bien :D C'est quand même de la bonne nourriture pour réflexion...
-
Bonjour à tous,
En ce dimanche pluvieux, je n'ai pas sorti mon fer à souder mais j'ai fait un peu travailler ma matière grise.
En furetant sur internet, j'ai trouvé un moyen de faire de l'acquisition de données Arduino en temps réel directement dans un graphique OpenOffice Calc.
J'ai un peu galéré mais les résultats sont plutôt prometteurs... 8)
Je vous en dirai plus par la suite.
-
C'est bien. Je ne savais pas que OpenOffice / LibreOffice pouvait recevoir les données directement d'un port série. Très, très intéressant, lorsque combiné aux macros. Je crois qu'il s'agit de VBScript. Tiens-nous au courant!
-
hello
tien tien sympa ça sa m’intéresse pas mal, à suivre donc je suivrais
-
Bonjour,
Mes 1ers essais sur platine breadboard et envoi des 2 courbes dent de scie (future tension Vce) et steps (futur Ib) sous libreoffice.
Mon AOP rail to rail étant un LM358 (pas mieux en réserve), le pwm est limité à environ 770 /1023, soiit environ 3V7 au lieu de 5V.
Mais pour les essais, ce n'est pas bien gênant.
J'ai un fort taux d'ondulation sur les steps (mais ce sont des 10èmes de µA) , il va falloir que je revoie ma cellule de filtrage ou que je lisse les valeurs lues en en faisant la moyenne par programmation.
-
Bonjour à tous,
J'ai un peu travaillé sur le code mais je ne suis pas expert en programmation, loin s'en faut :-[
Voilà où j'en suis rendu
const int nEchantillons = 126;//valeur de comptage max
int echantillon[nEchantillons]; // un tableau pour stocker les échantillons lus
int indice = 0; // indice de l'échantillon courant
float total = 0; // somme des échantillons mémorisés
float moyenne = 0;
float intensite = 0;
int tri = 5; // Triangle sur D5
int vg = 3; // Voltage step sur D3
int j = 0; //pente Vce
int k = 0; // steps Ib
int slope = 4;//pente du triangle
int incomingByte; // variable de stockage des données entrantes
int comptage=0;// comptage du nombre d'échatillons
int bouclecomptage=0;// nombre de comptages
//int row = 0;// pour renvoi de colonnes à LibreOffice
float tensionVce;
float tensionVb;
float intensiteIb;
void setup()
{ Serial.begin( 9600);
Serial.println("CLEARDATA");// Directives pour LibreOffice
Serial.println("LABEL,Time,Vce,Ib");// Directives pour LibreOffice
pinMode( tri, OUTPUT);
pinMode( vg, OUTPUT);
for (int i = 0; i < nEchantillons; i++) {
echantillon[i] = 0;
}
} // setup
void loop()
{
Serial.print("DATA,TIME,"); // Directives pour LibreOffice
total = total - echantillon[indice];
{ if (Serial.available() > 0);
{ incomingByte = Serial.read();
int valeur0 = analogRead(A0);//Nbr de pas PWM Vce
// valeur en volts
int valeur1 = analogRead(A1);//Nbr de pas PWM Vb
tensionVce = map(valeur1, 0, 1023, 0, 5000);//en millivolts
//intensite=tensionVce/200000.0000;//calcul Ib avec Rb=200K
echantillon[indice]=(valeur0);
total = total + echantillon[indice];
indice++;
comptage++;
// si on est à la fin du tableau ...
if (indice >= nEchantillons) {
// ...retour au début
indice = 0;
}
// calcul de la moyenne
moyenne = total / indice;
tensionVb = map(moyenne, 0, 1023, 0, 5000);//en millivolts
//tensionVb/1000 pour valeurs en volt
Serial.print(tensionVb/1000);
Serial.print(",");
Serial.println(tensionVce/1000);
delay( 10);
}
j = j+slope;
analogWrite( tri, j);
analogWrite(vg, k);
delay( 10);
if (j > 250) slope = -4 ;
if (j < 1)
{ slope = 4 ;
bouclecomptage++;
comptage=0;
indice = 0;
total = 0;
moyenne = 0;
for (int i = 0; i < nEchantillons; i++) {
echantillon[i] = 0;
}
k = k + int(255/5);
//row=row+1;
}
if (k > 255 ) k = 0 ;
}
} // loop()
Pour la partie hardware, voyez le schéma ci-dessous (c'est celui du site "Instructables" que j'ai cité + haut, ainsi qu'une partie de code)
Je suis preneur de vos remarques et suggestions / améliorations...
A vous lire.
-
Petite remarque sur le contenant. Ton code C est très difficile à suivre, car le positionnement des accolades { et } n'est pas consistent et mal aligné à travers le code. Même chose pour les indentations (les tabulations). Ça rend ton code difficile à comprendre et peu invitant aux autres. Je te conseille fortement d'implémenter une belle hiérarchie des formats, sinon tu vas avoir énormément de difficulté à déverminer. Juste un petit exemple:
void loop()
{
Serial.print("DATA,TIME,"); // Directives pour LibreOffice
total = total - echantillon[indice];
if (Serial.available() > 0)
{
incomingByte = Serial.read();
int valeur0 = analogRead(A0);//Nbr de pas PWM Vce
// valeur en volts
int valeur1 = analogRead(A1);//Nbr de pas PWM Vb
tensionVce = map(valeur1, 0, 1023, 0, 5000);//en millivolts
...
}
...
}
Vois cela comme un commentaire constructif! ;)
-
Bonjour,
Je sais tout ce que tu viens de dire mais j'ai fait ça à l'arrache et moi même je ne m'y retrouve pas.. :-\
Je vais tout bien ordonner promis
Voilà , c'est fait :
const int nEchantillons = 126; //valeur de comptage max
int echantillon[nEchantillons]; // un tableau pour stocker les échantillons lus
int indice = 0; // indice de l'échantillon courant
float total = 0; // somme des échantillons mémorisés
float moyenne = 0;
float intensite = 0;
int tri = 5; // Triangle sur D5
int vg = 3; // Voltage step sur D3
int j = 0; // pente Vce
int k = 0; // steps Ib
int slope = 4; // pente du triangle
int incomingByte; // variable de stockage des données entrantes
int comptage=0; // comptage du nombre d'échatillons
int bouclecomptage=0; // nombre de comptages
//int row = 0;// pour renvoi de colonnes à LibreOffice
float tensionVce;
float tensionVb;
float intensiteIb;
void setup()
{ Serial.begin( 9600);
Serial.println("CLEARDATA"); // Directives pour LibreOffice
Serial.println("LABEL,Time,Vce,Ib"); // Directives pour LibreOffice
pinMode( tri, OUTPUT);
pinMode( vg, OUTPUT);
for (int i = 0; i < nEchantillons; i++) {
echantillon[i] = 0;
}
} // setup
void loop()
{
Serial.print("DATA,TIME,"); // Directives pour LibreOffice
total = total - echantillon[indice];
{ if (Serial.available() > 0);
{ incomingByte = Serial.read();
int valeur0 = analogRead(A0);//Nbr de pas PWM Vce
int valeur1 = analogRead(A1);//Nbr de pas PWM Vb
tensionVce = map(valeur1, 0, 1023, 0, 5000);//en millivolts
//intensite=tensionVce/200000.0000;//calcul Ib avec Rb=200K
echantillon[indice]=(valeur0);
total = total + echantillon[indice];
indice++;
comptage++;
// si on est à la fin du tableau ...
if (indice >= nEchantillons) {
// ...retour au début
indice = 0;
}
moyenne = total / indice; // calcul de la moyenne
tensionVb = map(moyenne, 0, 1023, 0, 5000); //en millivolts
Serial.print(tensionVb/1000); //tensionVb/1000 pour valeurs en volt
Serial.print(",");
Serial.println(tensionVce/1000);
delay( 10);
} // incomingByte = Serial.read();
j = j+slope;
analogWrite( tri, j);
analogWrite(vg, k);
delay( 10);
if (j > 250) slope = -4 ;
if (j < 1)
{ slope = 4 ;
bouclecomptage++;
comptage=0;
indice = 0;
total = 0;
moyenne = 0;
for (int i = 0; i < nEchantillons; i++) {
echantillon[i] = 0;
}
k = k + int(255/5);
//row=row+1;
} // slope = 4 ;
if (k > 255 ) k = 0 ;
} // if (Serial.available() > 0);
} // loop()
-
Bonjour à tous,
Ça faisait un petit moment que je n'étais pas intervenu sur le forum et j'en profite pour relancer cette discussion.
J'ai abandonné le projet basé sur le couple Arduino / Openoffice.
Je suis en cours d'étude d'un autre projet basé sur un réseau R2R associé à de la logique CMOS (j'ai une boite pleine de circuits logiques de toute sorte récupérés depuis des décennies ;D ).
Mon cahier des charges :
Automatisme complet pour la génération des rampes VCE et des courants de base.
Tension VCE possible jusqu'à 15V
8 valeurs de courant de base
Échantillonnage de la tension VCE sur 8 bits
Pas de composants exotiques
Sortie de visualisation sur un oscilloscope en XY ou avec un microcontrôleur pour ma part ce sera un Arduino nano avec visu des courbes par un programme en Python.
Explication du fonctionnement :
Le DAC des rampes est basé sur un réseau R2R de 8 bits (255 valeurs).
Le balayage est fait par 2 compteurs binaires 4 bits 74HCT393 en cascade et cadencés par un astable basé sur un 555.
Les valeurs des composants R et C donnent une fréquence de 66kHz avec un rapport cyclique de quasi 50%.
Les compteurs bouclent jusqu'à l'obtention des 7 valeurs de courant de base.
Le DAC des courants de base est réalisé par un réseau R2R 3 bits (7 valeurs).
Le balayage est fait par 3 bascules JK CD4027 en cascade
La fin du comptage de pas et l'arrêt des rampe est fait par portes logiques AND à 3 et 4 entrées (CD4073 & 74HCT21).
Le signal RST de commande du 555 est géré par une bascule D CD4013 (en fait je ne pense pas que ce soit nécessaire).
Voilà en gros le principe de fonctionnement.
Il me reste encore beaucoup de choses à améliorer et notamment l'inversion des rampes qui vont de 0 à -12V (si quelqu'un a un idée pour les faire varier de 0 à +12V car je sèche, allez savoir pourquoi ;) )
l faudra aussi prévoir le fonctionnement PNP / NPN et l'interfaçage avec un microcontrôleur pour visu des courbes.
Ci-dessous, quelques courbes ainsi que le schéma.
Le fichier .asc est à disposition pour les gens intéressés à modifier et améliorer ce montage.
-
Beau projet, de retour à la base! On comprends que vous ne voulez pas vous servir d'un vrai DAC..ou d'un simple microcontrôleur. Correct. Ça grossit donc le projet.
Vous devriez être capable de remplacer U2 par une configuration inverseuse et un décalage, pour ramener le tout du côté positif.
Bon travail! :)
-
Bonjour,
Effectivement, un DAC + microcontrôleur m'auraient simplifié le projet mais je voulais me prouver qu'on pouvait faire avec des composants de base.
De plus, pour cette utilisation, on a pas besoin de la précision d'un DAC 14 bits... :)
Je n'ai rien trouvé d'approchant sur internet mais néanmoins je trouve que mon approche peut présenter un certain intérêt pédagogique.
Cette ébauche pourrait servir de base pour un projet commun avec les participant du forum.
Pour votre remarque, effectivement, je vais voir côté U2 pour régler ce problème de tension.
J'ai modifié le schéma en mettant des compteurs / décompteurs CD4516 et en modifiant au passage quelque peu la logique connexe.
Je trouve que le fonctionnement est mieux (voir image détail rampe comparaison).
-
C'est définitivement pédagogique, pas de doute là -dessus! C'est beaucoup d'apprentissage en un seul projet.
-
Oui, ça touche quelques domaines et c'est peut-être un peu "hard" pou certains bidouilleurs débutants :-[
J'ai résolu le problème de tension en sortie grâce à l'utilisation de l'ampli opérationnel en montage non inverseur ;)
-
Ah bon, excellent. J'avais même pas noté que U2 était déjà un inverseur :-[
-
Et voici la dernière mouture du schéma avec tensions positives et une belle courbe Ic f(Vce) pour un NPN 2222.
Étape suivante, mise au propre du schéma et câblage sur breadboard.
-
Testeur partie NPN quasi terminé.
Ajout d'une source de courant pour tester les transistors de puissance et pour limiter le courant débité par l'AOP à quelques mA, mais la solution que j'ai adoptée n'est pas très optimisée car la résistance de charge doit dissiper une grande puissance. Je vais voir pour une source de courant à LM317 par exemple.
Une petite image pour finir. ( son nom est erroné, c'est bien la version NPN) :)
Bonne nuit à vous, car il est minuit en France
Ci-joint fichier LTspice (enlever le .txt pour l'ouvrir)
-
En parallèle, je développe une appli sous python pour visualiser les courbes. C'est une première ébauche à mon avis très prometteuse.
Le montage sur la carte arduino comporte 2 AOP, une poignée de résistances. Le transistor en test est un 2N2222.
L'arduino fabrique la rampe et le signal en marches d'escalier pour polariser le transistor.
2 ports analogiques servent à mesurer les signaux IC et VCE envoyés sur le port série et récupérés par python pour analyse et mise en forme.
Les courbes de caractéristiques sont un peu crades car aucune valeur n'est lissée.
-
Un plaisir de programmer en Python. Quelle flexibilité, et quelle simplicité! Tout est assez bien documenté sur la toile.
Pour les courbes, j'utilise PyChart.
-
J'ai utilisé les librairies numpy, matplotlib et drawnow.
La librairie drawnow est plutôt réticente à installer et il a fallu que je régresse en version pour qu'elle consente à fonctionner.
-
PyChart n'est pas récent, mais il fonctionne toujours bien. Je m'en sert pour générer des courbes en PDF. Plus simple que la suite que vous utilisez. Nécessite Ghostscipt, qui s'installe séparément.
-
Je ne connais pas encore pyChart et j'ai commencé python hier, avant je ne m'en étais jamais servi.
Par contre, avec les librairies que j'utilise, le code se résume à quelques lignes. (Oui, je sais, il n'est pas renseigné, mais il est tellement simple...) :-[
import serial
import numpy
import matplotlib.pyplot as plt
from drawnow import *
Vce0= []
Ic0= []
arduinoData = serial.Serial ('com3', 115200)
plt.ion()
cnt=0
def makeFig():
plt.title('TRACEUR DE COURBE TRANSISTORS')
plt.xlabel('VCE Volt')
plt.plot(Vce0, Ic0)
plt.grid(True)
plt.ylabel('Ic mA')
while True:
while (arduinoData.inWaiting() ==0):
pass
arduinoString = arduinoData.readline()
dataArray = arduinoString.split(',')
VCE = float(dataArray[1])
IC = float(dataArray[0])
Vce0.append(VCE)
Ic0.append(IC)
drawnow(makeFig)
plt.pause(.000001)
cnt=cnt+1
if(cnt>1023):
Vce0.pop(0)
Ib0.pop(0)
-
En effet, c'est simple. Et c'est souvent le cas avec Python. Bravo de vous être initié au serpent!
-
Bonjour,
Dernière mouture du testeur version NPN. L'alimentation passe d'une alimentation symétrique à une alimentation simple et modif transistor sortie rampe.
Il me reste à faire la version PNP et surtout de voir pour une inversion simple PNP / NPN
-
Bonjour à tous,
Avancement de mon étude théorique du schéma.
J'ai un peu (beaucoup) galéré pour trouver un solution d'inverseur NPN / PNP. Après mûre réflexion, il suffisait d'alimenter les bascules JK avec une alimentation symétrique +/- et d'aiguiller les signaux avec des diodes.
Par contre, il m'a fallu bidouiller les directives spice de mes modèles car les circuits logiques n'acceptaient pas une tension négative (http://retro-forum.com/images/smilies/icon_mrgreen.gif)
J'ai gardé mes rampes générées avec 2 CDA R2R (une rampe positive et une négative)
La sortie se fait à travers un AOP qui attaque un push-pull complémentaire.
Ci-dessous une capture d'écran des rampes générées avec 3 valeurs de résistance pour 21 valeurs de courants de base.
Et plus tard, la suite pour la rampe VCE... ;)
-
Ouin, on tombe dans le "spécial" avec des portes logiques avec alimentation différentielle! Y'a rien de trop beau pour faire fonctionner un circuit! Amusez-vous bien... :D
-
Et oui, il faut savoir sortir des sentiers battus... :)
J'ai attaqué la rampe VCE sur le même principe mais comme j'utilise un CD4040 (compteur 12 bit), mon PC rame à mort quand je lance la simulation.
Je vais me limiter à 8 bit pour la mise au point sous LTspice, simplement pour valider le principe et je gagnerai du temps.
Dommage qu'il n'existe pas à ma connaissance un compteur binaire 8-bits série 40xx ou 45xx.
-
Bonjour à tous,
J'ai abandonné l'idée ci-dessus avec les diodes et je suis revenu à mon idée de départ.
Une idée lumineuse m'a été suggérée sur un autre forum : l'utilisation de cmos de la famille CD405x " CMOS Single 8-Channel Analog Multiplexer/Demultiplexer With Logic-Level Conversion ".
Je me suis donc intéressé à la chose mais comme je n'ai trouvé aucun modèle sous LTspice j'ai utilisé de simples DPDT commandés en tension. Ce n'est pas parfait, mais pour valider le principe, c'est suffisant.
J'ai quand même gardé les alimentations différentielles pour les cmos ;D
Je vous mets le schéma en pdf ci-dessous. Le transistor en essai est un PNP mais j'ai simulé aussi un NPN.
Je vous mets les 2 courbes en capture d'écran.
-
Les multiplexeurs analogiques sont souvent oubliés comme solution pratique. Pourtant, on peut s'en servir autant comme solution de commutation analogique que logique. Il en existe qui roulent à plusieurs dizaines de MHz. Très, très commodes. Mais on n,a pas tendance à y avoir recours.
En tout cas, votre circuit est tout un apprentissage. Vous avez autant de la logique que de l'analogique, que programmation logicielle. Bravo!
-
Bonsoir Bertrand,
Merci pour vos encouragement qui me font bien plaisir mais je suis déçu que ce projet n'intéresse pas grand monde... :'(
C'est un peu dommage car il y a matière à débattre.
Bonne soirée.
-
Il y a beaucoup de viande dans ce projet. Voici d'après moi deux possibilités pour expliquer le bas niveau d'intérêt (apparent, du moins):
- Je crois que peu de gens s'intéressent à la capacité de tester des semi-conducteurs de façon paramétrique. Personnellement, je n'ai pas cette capacité, et je n'en ressens pas le besoin.
- Vous avez choisi d'exclure les micro-contrôleurs, et de n'utiliser que des composants simples, ce qui alourdit de beaucoup la solution. Qu'on le veuille ou non, le schéma paraît complexe. Bien sûr c'est votre choix, et c'est très respectable. Mais moi je n'aurais pas procédé de la sorte.
Quoi qu'il en soit, ne cessez pas de nous informer de votre progrès. Ceux qui le lisent peuvent apprendre des techniques et concepts en analysant votre solution. Il y a beaucoup de valeur dans votre démarche, et c'est tout en votre honneur de partager vos projets. Lâchez pas!
-
Bonjour à tous,
Pas mal de modifictions à mon projet depuis ma dernière visite :
Passage de l'alimentation du 555 et des Cmos en tension simple 12V.
Ajout de 2 "amplificateurs d'instrumentation" à gain variable pour visualisation sur oscilloscope en X-Y ou pour sortie sur Arduino.
Lecture de la valeur absolue de Vce et de Ib.
Suppression des bascules JK CD4027 et remplacement par un compteur / décompteur binaire ou décade CD4029.
Passage des rampes courant de base sur 4bits car il me restait un emplacement sur un CD4053.
Mais un schéma vaut mieux qu'un grand discours...
-
Bonjour,
Bien, je continue mon monologue...
beaucoup de travail sur le projet, quasi une refonte complète, mais toujours avec réseaux R2R et logique CMOS.
Cette fois, je suis parti sur une rampe double pour la tension collecteur pour avoir un traé des courbes beaucoup plus clean.
Grosse modification aussi sur les steps courant de base avec utilisation d'un compteur synchrone et d'un comparateur à pré-positionnement.
Il me reste à gérer un petit problème d'offset ainsi que les petits décrochés au démarrage de chaque courbe, mais là , je sèche un peu.
Je me demande si ce n'est pas dû au simulateur lui-même.
Voilà , la suite à la résolutions de ces petits défauts.
-
Juste comme ça, suspecte le comportement de tes transistors de sortie et des diodes sur les sorties des amplis ops. Sont-ils toujours en conduction?
-
Bonjour,
Bertrand, peux-tu infirmer ou confirmer mon analyse?
Regardez cette jolie courbe sans défauts :)
J'ai modifié la directive .tran "ANALYSE TEMPORELLE ou Transient analysis en english" et décoché "startup".
Définition de startup http://ltwiki.org/index.php5?title=Simulation_Command (http://ltwiki.org/index.php5?title=Simulation_Command):
startup: Solve the initial operating point with independent voltage and current sources turned off (but using any constraints specified by a .ic directive). Then start the transient analysis and linearly ramp on these sources during the first 20 us of the simulation.
Ce paramètre startup impose que toutes les sources indépendantes tension et courant ( (mais en utilisant les contraintes spécifiées par une directive .ic) évoluent toutes de 0 à leur valeur nominale, uniformément durant les vingt premières microsecondes de la simulation temporelle et startup s’affiche.
J'avoue, je n'ai pas vraiment compris la subtilité mais je suis encore novice avec LTspice , mais en décochant, je n'ai plus cet offset et ce décalage en début de courbe.
Donc, à priori, ça ne vient pas du circuit lui même :)
-
Vous ne cherchez pas à analyser le moment où votre montage est mis sous tension. Vous voulez analyser le comportement en régime permanent, lorsque toutes les alimentations sont stabilisées. D'où l'enlèvement du crochet. :)