Quoi de neuf 2014

From Eric

Revision as of 11:57, 12 July 2014

Juillet 2014

• 12/07/2014
  • J'ai plus ou moins terminé mon "analyseur de spectre" basse fréquence. Il s'agit d'un assemblage plus ou moins réussi de (1) un générateur en dents de scie à 555, transistor et ampli-op, (2) un VCO triangulaire à amplis-ops (voir le billet du 29/06), (3) un convertisseur triangle=>sinus à transistors, (4) un mixer à NE602, (5) un filtre de Chebychev du second ordre, (6) un détecteur à diodes idéales. Bon, le résultat n'est pas phénoménal mais ça marchotte : un signal périodique en entrée se traduit bien par un pic sur l'oscilloscope. Il n'y a pas une once d'électronique numérique.
  • Pour mémoire, j'ai réalisé quelques vidéos (dont l'intérêt est très limité...) :
    • le générateur en dents de scie dont la sortie pilote un VCO à CD4046 (le générateur en dents de scie provient d'une vidéo de l'excellent "W2AEW") ;
    • le convertisseur de signal rectangulaire en signal triangulaire ;
    • le convertisseur de signal triangulaire en signal sinusoïdal ;
    • le mélangeur à NE602 ;
  • Le résultat n'est pas très spectaculaire. Sur cette vidéo on voit le signal en dent de scie qui pilote le VCO et, sur le deuxième canal, le signal issu du mélangeur. On distingue (plus ou moins) bien un pic qui correspond au signal sinusoïdal de 400mv PP en entrée. Tout cela est décrit dans un document encore très brouillon...
    

    
  • Le montage lui-même est réalisé sur 3 "breadboards", ce qui fait un beau fouillis de fils...

Juin 2014

• 29/06/2014
  • J'ai réalisé deux générateurs sinusoidaux en fréquence audio : l'un à partir d'une PLL 4046 (le signal triangulaire est obtenu en "raboutant" les deux rampes produites par la PLL), l'autre à partir de 3 boucles d'asservissement à ampli-ops. L'objectif est de produire un signal triangulaire à partir d'un signal carré puis de transformer ce signal triangulaire en sinusoide. Si cela semble facile, ça soulève tout un tas de questions et met en oeuvre pas mal de principes simples et intéressants... Le signal obtenu est pas trop mal. J'en ai fait une brêve vidéo pour mémoire.
  • On trouvera la trace de ces aventures dans un document qui contient (pour l'instant) tout un tas de choses... A terme, je ferai un document par sujet. J'abandonne un peu Wikimedia pour Word qui est beaucoup plus pratique lorsqu'il s'agit de faire des diagrammes ou d'insérer des formules mathématiques. (A noter que Word traite désormais fort bien les formules mathématiques. Il dispose d'une pléthore de "raccourcis" qui évite les cliquouillages incessants. Voir le document intitulé "Unicode Nearly Plain-Text Encoding of Mathematics".)

Mai 2014

• 30/05/2014
  • J'ai fait quelques expérimentations sur les filtres "state variables" (comme s'appellent-ils en français?). Voir l'article sur les filtres.
  • Je vais tenter de me bricoler un petit outil pour caractériser les filtres. L'idée est de faire une forme d'analyseur de spectre : un VCO génère un signal sinusoïdal de fréquence F ; le signal à analyser est mixé avec le signal d'entrée et est filtré avec un filtre passe bande très étroit ; on "affiche" la puissance du signal de sortie. Voir l'article intitulé Analyseur de spectre rudimentaire. Si on met un bruit blanc en entrée du filtre, on arrive ainsi à tracer la courbe de réponse de celui-ci. Voir l'article sur les Générateurs de bruit blanc.
• 29/05/2014
  • Création d'un article sur les filtres. Je m'intéresse plus particulièrement aux "state variable filters".
• 26/05/2014
  • Je me suis penché à nouveau sur le filtre actif du second ordre que j'ai mis en place sur mon "détecteur de chauves-souris".
  • J'en ai fait un modèle avec LTSpice histoire d'essayer cet outil. Le schéma est le suivant :
    

    
    .
  • J'ai utilisé le modèle de LM358 téléchargé sur le site de ON Semi. Il est très facile de l'intégrer à LTSpice : il suffit de placer le composant LTSpice correspondant au modèle générique d'ampli-op (ampliop2), de préciser le nom du fichier texte contenant le modèle SPICE et d'ajouter la clause d'inclusion (outil .OP de LTSpice) :
    

    
  • L'analyse temporelle s'effectue en sélectionnant une source de tension en entrée de type .AC et de configurer l'analyse fréquentielle. On obtient la courbe de réponse suivante :
    

    
  • Le filtre que j'utilise est un filtre de type Rauch (il existe d'autres structures de filtres bien connues, comme Sallen-Key).
  • La fonction de transfert est la suivante :
    File:Filter-rauch-transfer.jpg

    400px
  • On peut aussi appliquer traiter le filtre avec les outils de l'analyse des systèmes. Pour ce faire, j'ai utilisé Matlab qui dispose de nombreux outils très puissant pour réaliser ce type d'analyse (il permet notamment de synthétiser les filtres classiques (Butterworth, Bessel, etc.).
  • Le script est donné ci-dessous :

 close all
 clear all
 
 % ------------------------------------------------------------
 % Les caractéristiques des composants du filtre 
 % ------------------------------------------------------------
 r1 = 23.2e3;
 r2 = 5.23e3;
 r3 = 36.5e3;
 
 c1=6.8e-9;
 c2=12e-9;
 
 % ------------------------------------------------------------
 % La fonction de transfert
 % ------------------------------------------------------------
 n = [c2/r1 0];
 d = [c1*c2 (c1+c2)/r3 (r1+r2)/(r1*r2*r3)];
 h=tf(n,d);
 
 % Les pôles
 roots(d)
 
 % ------------------------------------------------------------
 % Affichages
 % ------------------------------------------------------------

 % Affichage du diagramme de Bode
 figure(1)
 bode(h)
 
 % Affichage de la fonction de transfert dans le plan complexe
 x=[-1.3e4:0.02e4:0];
 y=[-4.0e4:0.02e4:4.0e4];
 p=(x'*ones(size(y)))'+j*(y'*ones(size(x)));
 
 mod = abs(polyval(n,p)./polyval(d,p));
 arg = angle(polyval(n,p)./polyval(d,p));
 
 figure2 = figure('PaperSize',[20.98 29.68]);
 axes2 = axes('Parent',figure2,'YScale','log');
 view([-37.5 30]);
 grid('on');
 hold('all');
 surf(x,y,20*log10(mod), 'Parent', axes2);
 light('Parent',axes2,'Position',[0.2748 -0.9615 0.0012]);
 
 figure3 = figure('PaperSize',[20.98 29.68]);
 axes3 = axes('Parent',figure3,'YScale','log','YMinorTick','on','YMinorGrid','on');
 view([-37.5 30]);
 grid('on');
 hold('all');
 mesh(x,y,arg, 'Parent', axes3)
  
 figure4 = figure('PaperSize',[20.98 29.68]);
 view([-37.5 30]);
 mesh(x,y,20*log10(mod));
 

• • La fonction de transfert est la suivante :

                 5.172e-013 s
 -----------------------------------------
 8.16e-017 s^2 + 5.151e-013 s + 6.419e-009

• • Le diagramme de Bode est calculé par Matlab :
    

    
  • On peut aussi tracer la fonction de transfert dans le domaine complexe. On distingue bien les deux pôles et le zéro. En regardant au "bon endroit" et en choisissant une échelle logarithmique, on retrouve la courbe de gain du diagramme de Bode.
    

    
    

    
  • On peut voir aussi le zéro et les deux pôles :
    

    
  • Je me suis aussi amusé à simuler le filtre avec Simulink. J'ai placé mon filtre en sortie d'un générateur de bruit blanc et j'en affiche le spectre.
  • Voici le modèle :
    

    
  • Voici le spectre du bruit blanc (attention : il s'agit d'un instantané calculé sur 128 échantillons et non du "vrai" spectre) :
    

    
    • Et voilà le spectre du signal filtré
      

      
  • J'ai poursuivi l'exercice en plaçant plusieurs filtres en série  :
    

    
    

    
  • A noter que la fonction de transfert doit être discrétisée, ce que l'on obtient facilement avec la fonction "c2d - continuous to discrete" combiné la fonction tf de définition de la fonction de transfert. :
    

    
• 16/05/2014
  • J'ai commencé à dessiner le bras robot en OpenGL (d'abord en Ocaml puis en Haskell). Voilà ce que ça donne pour un axe (version ocaml) : [1]
  • J'ai ajouté un filtre passe-bande actif (2e ordre, Butterworth, centré sur 1500Hz) à mon détecteur de chauves-souris...
    • Les valeurs des composants ont été calculées avec l'outil FilterLab de Microchip. Il existe d'autres outils, comme FilterPro desktop de TI ou FilterCAd de Linear Technology. (FilterPro m'a donné des valeurs de composants assez "bizarres").
    • Voila le filtre avec les copies d'écran issues de FilterLab :
      

      
    • Je me suis amusé à le tester avec mon générateur BF (histoire de constater "de visu" les effets du filtre). Voici la courbe de réponse que j'ai obtenue expérimentalement :
      

      
    • Voici aussi une copie d'écran de mon oscillo obtenue en faisant varier la fréquence d'entrée du filtre entre 100 et 2500Hz. On voit très nettement l'effet du filtre (avec le pic à 1500Hz) :
      

      
• 11/05/2014
  • Premiers tests du "bras robot" avec Frédéric. Il ne reste "plus" qu'à faire un peu de cinématique inverse pour rendre l'exercice intéressant...
• 10/05/2014
  • J'ai réalisé un détecteur de chauves-souris. J'ai repris le montage décrit ici qui utilise un NE612. J'ai remplacé l'oscillateur par un générateur de fréquence à base de DDS AD9850 que j'avais construit jadis. Voici une photo du montage sur la plaque d'expérimentation :
    

    
  • J'ai testé le détecteur avec mon télémètre à ultrasons . Voici une petite vidéo du premier essai. Les "bips" que l'on entend proviennent du télémètre à ultrasons.
• 04/05/2014
  • J'ai repris plusieurs petits montages réalisés sur plaquette d'essais afin de les rendre un peu plus propres et réduire le nombre de plaquette utilisées. Rien de bien passionnant.
  • J'ai aussi utilisé une autre méthode pour réaliser la localisation d'une source sonore : la recherche du décalage DT qui minimise \sum{i=1}^{nb samples} (sample(i) - sample(i+DT))^2. ce qui est ma foi plutôt naturel. Bizarrement, je n'obtiens rien de bien probant... A voir.

Avril 2014

• 21/04/2014
  • J'ai poursuivi mes investigations concernant la localisation d'une source sonore. J'ai d'abord exploité la bibliothèque FFT de Microchip qui utilise des nombres en virgule fixe sur 16 bits (ou "fractionals"). Bon, je ne parviens à rien de bon du fait du manque de précision. Je suis alors passé par une forme plus classique utilisant des flottants, celle décrite dans les "Numerical Recipies for C, chapitre 12"). La fonction donnée dans cet ouvrage calcule la FFT sur des valeurs complexes ce qui n'est pas "terrible" puisque mes valeurs sont réelles... Or il existe une façon plus efficace de calculer une FFT sur des données réelles, une technique qui permet de calculer la FFT de 2N valeurs réelles en retournant N valeurs complexes. J'ai donc joyeusement récupéré le bout de code ici.
  • Ben... ça fonctionne pas mal, surtout si le signal sonore a une longueur d'onde proche de l'écartement des micros (pour moi : 9cm, soit une période de 9.10-2/343 = 1/3811Hz). On trouvera ici une vidéo d'essai. Le code est donnée dans l'article Localisation sonore par GCC.
  • La figure ci-dessous montre le résultat de la FFT inverse après calcul de la corrélation
    

    
• 13/04/2014
  • Je suis en train de tenter de localiser une source sonore en utilisant la technique de Generalized Cross Correlation (GCC, voir l'article de Wikipedia). J'utilise un DSPic 30F4011 pour lequel Microchip fournit une bibliothèque FFT.
  • Pour l'instant, je parviens à calculer la FFT des signaux en provenance de deux microphones. Le DSPic utilise une représentation particulière ("fractional") qui code une valeur à virgule fixe comprise en -1 et 1. Les valeurs étant codées sur 16 bits (dont un bit de signe), la dynamique est faible. Pour dire le vrai, je ne suis pas parvenu à calculer une FFT inverse "correcte".
  • Pour augmenter la dynamique, j'ai récupéré la fonction de calcul de FFT donnée dans les "Numerical Recipies" (une version numérique est accessible ici. Elle utilise des "float" (voire des "doubles". Comme je n'ai pas d'exigence de temps de calcul, je peux éventuellement utiliser des doubles...
  • J'ai fait quelques essais en utilisant un signal calculé. Les résultats ne sont corrects (c'est-à-dire que le déphasage calculé est proche du déphasage introduit) que pour une fréquence d'échantillonnage égale à K fois la fréquence du signal, K étant le nombre d'échantillons. Voilà quelques courbes :
    

    
    

    
    

    
  • On trouvera plus de détail dans l'article Localisation sonore par GCC.

Mars 2014

• 28/03/2014
  • Je me suis amusé avec un capteur de mouvement à effet Doppler : le HB100 (que trouve pour quelques dollars sur ebay).
  • Voici à quoi ressemble le capteur :
    

    
  • La note d'application d'AgilSense propose un montage très simple à ampli-op pour l'exploiter. Il s'agit d'une série de 2 filtres amplificateurs qui permettent de passer des quelques uVolts produits en sortie du mélangeur à quelque chose d'exploitable. Voici le schéma :
    

    
  • Voici le montage sur sa plaquette
    

    
  • Attention : vu l'importante amplification, les fils doivent être très courts sinon les amplis se mettent à osciller joyeusement...
  • J'ai simplement ajouté un comparateur au schéma initial. Le résultat est tout à fait probant : le détecteur est très sensible (au moins à l'échelle d'un pièce, je n'ai pas expérimenté la chose en extérieur). Voici une vidéo.
  • En parallèle, je suis en train de faire quelques investigations sur la location d'une source sonore. Le principe est de corréler les signaux issus de deux microphones. En passant pas une transformée de Fourier, l'opération est élémentaire. A suivre

Février 2014

• 28/2/2014
  • Me voici de retour après une longue période de léthargie...
  • J'ai repris une idée de montage que j'avais eue l'année dernière : une horloge non linéaire. Il s'agit simplement de modifier une horloge électronique banale afin que son mouvement ne soit plus régulier mais reste "asymptotiquement" correct. Concrètement, l'horloge avance tout d'abord très vite puis s'arrête un instant et recommence ce cycle ad infinitum. "L'électronique de commande" (un bien grand mot) utilise un Attiny13A, un module RTC à base de DS1307 (acheté sur e-bay pour trois fois rien) et un pont en H (pour la commande du moteur pas-à-pas de l'horloge).
    

    
    

    
    

    
    

    
    On trouvera aussi une vidéo ici.
  • Par ailleurs, voici un petit montage de contrôle par PID (en fait, un PI pour l'instant) d'un moteur à courant continu (à base d'amplis ops). Le schéma suivra.
    

    
    

    
    

    
  • Enfin, j'ai commencé à réalier une petite carte à Z80. Ca me rappelle le bon vieux temps (aux alentours de 1983) : l'époque du ZX81 (hello Christophe!). Pour trouver un petit intérêt supplémentaire à l'exercice, j'ai décidé de mettre le peu de logique nécessaire à la génération des signaux de contrôle RAM, ROm et PIO dans un GAL (un 16V8D). Bon, ça n'est plus très à la mode mais pour de ptites choses... On trouvera quelques informations pratiques sur la programmation de ces choses dans la rubrique GALs. Voici une photo (sans intérêt) du montage actuel).
    

    
  • J'en ai profité pour acheter un petit programmateur universel : le "Genius" G540. Pour l'instant, il fonctionne plutôt bien.
    

    

Janvier 2014

Néant.

Décembre 2013

Ensemble vide.

Novembre 2013

Nada.

Octobre 2013

Rien, rien de rien...

Septembre 2013

Aucune activité en électronique, faute de temps : achat d'une maison, déménagement, travaux...

Je vais tenter de suivre un MOOC. il s'agit de l' "Introduction to logic" sur coursera. A suivre.

Août 2013

Le quadcopter a maintenant 4 moteurs. J'ai repris le logiciel de contrôle (un truc tout simple en C++) qui communique avec l'Arduino embarqué au moyen d'une de ces fabuleuses puces de souris sans fil... Il reste désormais à attendre la réception d'un support d'hélice pour commencer les essais sérieux.

Au passage, déménagement en cours... Le dernier avant quelque temps, j'espère.

Trucs intéressants :

• Odroid, des cartes à la sauce Raspberry, mais plus performantes (et plus chères, aussi). On pourra s'intéresser aussi à OLinuXino.
• "La partie et le tout", d'Heisenberg.

Juillet 2013

Quelques travaux sur le quadcopter. Pas grand chose.

Juin 2013

• 4/6/2013
  • Je suis enfin parvenu à obtenir une stabilisation du "balancier" sur mon "banc Quadcopter". L'asservissement n'est pas très rapide (ni très stable, ce qui est un comble), mais on va dire que ça fonctionne grosso modo. Je suis parvenu à quelque chose d'à peu près satisfaisant en ajoutant un I à mon PID. En effet, l'ESC réagit "par palier", ce qui induit soit une grosse erreur statique (si P est petit), soit d'horribles oscillations (si P est grand).
  • Je me suis fait une petite application Java pour pouvoir afficher la valeur des différents paramètres.
  • Bon, ça n'est pas génial mais ça me permet de passer à la phase 2 : utilisation de 4 moteurs et 4 hélices.
  • On trouvera quelques vidéos ici, là, là et encore là.
  • Voila quelques photos. La première montre le banc en fonctionnement ; la deuxième montre le moniteur. La courbe très bruitée montre le signal d'angle retourné par l'accéléromètre ; le créneau montre la consigne d'angle. On constate que l'angle "suit" peu ou prou la consigne.
    

    
    

    

Mai 2013

• 15/5/2013
  • J'ai fait quelques premiers tests de la Kinect d'Xbox 360 dont j'ai fait l'acquisition sur ebay (50€ + 10€ pour l'alimentation externe 12V).
  • J'utilise pour l'instant le SDK sous Windows (avec Visual Studio Express 2012). C'est assez spectaculaire! Le SDK fournit permet non seulement d'accéder aux données brutes des capteurs (une caméra couleur, une caméra infrarouge), aux données de profondeur, mais aussi à des données plus élaborées relatifs à la position du corps (bras, jambes, tête, bouche,...).
  • Il existe aussi un driver et un ensemble de SDK utilisables sous Linux. Le driver est libfreenect ; l'API de base est OpenNI réalisée par la société qui a conçu le capteur ; l'API de plus haut niveau est NITE. Il existe de nombreux bindings : SimpleOpenNI pour Processing, Java, C#, etc. et même pour Common Lisp! Je n'ai encore rien utilisé de tout celà.
• 9/5/2013
  • J'ai fait une première expérimentation de la bibliothèque de traitement d'image OpenCV. Je l'ai installée et recompilée sur un vieux Celeron. On trouvera quelques informations sur ce sujet dans la rubrique OpenCV. A partir de cette bibliothèque, on parvient par exemple très facilement à suivre un objet de couleur avec quelques lignes de code.
  • J'ai repris mes expérimentations sur les FPGA. A titre d'exemple, j'ai réalisé le pilotage d'un écran VGA (quelques lignes de VHDL). J'ai dans l'idée de faire un "pong" ou un "casse briques". Bref, quelque chose de très simple. (Les photos sont ici (zone privée).
  • A noter que je m'étais déjà frotté au VGA il y a deux ans, avec un DsPIC. J'étais alors parvenu à afficher quelque chose de très grossier (voir le journal à la date du 27/12/2011).
  • J'ai refait un petit récepteur infrarouge RC5.
• 4/5/2013
  • Victor s'est cassé la clavicule...
• 3/5/2013
  • J'ai réparé mon clone de "bus pirate" qui ne fonctionnait pas. La réparation est fort laide mais l'outil fonctionne désormais :
    

    
• Date incertaine
  • J'ai dans l'idée de bricoler quelque chose avec une horloge à aiguilles. J'ai remplacé l'électronique de commande originelle par une simple électronique de commande du moteur pas-à-pas qui fait mouvoir les aiguilles (un pont en H à base de 2222 et 2907) :
    

    
  • Je pense faire une espèce d'horloge un peu déréglée dont l'aiguille des secondes avancerait à un rythme irrégulier tout en assurant une indication des minutes et des heures "exactes".
• Date incertaine
  • Frédéric et moi avons commencé à construire notre "quadcopter". Le controle-commande sera réalisé par un Arduino.
  • Pour commencer, nous avons construit un petit balancier en aluminium afin de mettre au point l'asservissement de position horizontale. L'idée est de se faire la maine avec un seul moteur et un capteur d'accélération avant de faire quelque chose de plus gros (2 moteurs puis 4 moteurs). En voila une photo :
    

    
  • Les résultats ne sont pas trop mauvais. Nous avons réalisé un petit asservissement en PD. Les coefficients ont été fixés de façon empirique mais ça ne marche pas trop mal. La video que nous avons faite montre la réponse du système à une perturbation. Dans cette version, l'état d'équilibre est atteint assez lentement car (i) nous n'avons pas affiné les réglages et (ii) nous avons mis une batterie pour alourdir le système.
  • L'alimentation électrique est fournie par une alimentation à découpage de rack capable de délivrer 2x12A sous 12V (et 60A sous 5V !).
  • Cette première manipulation nous a permis de nous familiariser avec les ESC, et notamment avec les fonctions de programmations qu'ils offrent, ce que nous ignorions complètement jusqu'ici.
  • On trouvera plus d'information sur la page concernant le Quadcopter V1.
• Date incertaine
  • A la demande de Frédéric, j'ai réalisé un petit boitier de commande de relais à partir d'une ligne série : l'utilisateur envoie des commandes du type "O1" pour ouvrir le relais 1, "C2" pour fernmer le relais 2, etc. Rien que de très évident... En voila cependant une photo :
    

    

Avril 2013

Je crois bien que je n'ai rien fait...

Mars 2013

• 9/3/2013
  • Assez peu d'électronique. Pas mal de Gap et un peu d'Haskell.

Février 2013

• 4/2/2013
  • A force de lire des bouquins sur les asservissements, je me suis dit qu'il ne serait pas idiot d'en "fabriquer" un. Je me suis donc lancé dans la réalisation d'un régulateur de vitesse de moteur à courant continu. C'est l'exercice de base pour tout automaticien car (i) le matériel pour le réaliser est facile à obtenir, (ii) le modèle mathématique (fonction de transfert) est relativement simple.
  • Pour l'instant, je me suis contenté d'une approche empirique ; je traiterai "proprement" le problème plus tard...
  • Le système comporte un moteur à courant continu à balais (moteur de lecteur de CD) sur l'axe duquel j'ai collé un minuscule aimant au néodyme. La vitesse du moteur est obtenue au moyen d'un capteur à effet hall : lorsque l'aimant passe devant le capteur, un condensateur est déchargé ; il se recharge pendant que le rotor fait un tour. Vue la vitesse de rotation, l'exponentielle de chargement du condensateur est "très proche"" d'un segment de droite. Le signal en dent de scie est "recopié" au moyen d'un ampli-op monté en suiveur puis filtré à l'aide d'un filtre passe-bas discret. J'obtiens ainsi un signal dont la valeur reflète la vitesse de rotation (proche de VCC pour les petites vitesses lente car le condensateur est chargé pratiquement tout le temps et tendant vers 0 lorsque la vitesse augmente).
  • Le signal d'erreur (différence entre la vitesse de rotation et la consigne de vitesse) est calculé par un ampli-op monté en soustracteur.
  • Le signal d'erreur est amplifié (ampli-op monté en ampli inverseur); on y rajoute alors une tension d'offset (voir plus loin...) et on inverse le tout pour obtenir le signal de commande.
  • Le signal de commande est passé en entrée d'un montage darlington comprenant un transistor petits signaux et un transistor de puissance.
  • Voila ce à quoi ressemble le montage (;-)) :

• • On trouvera plus de détails dans la rubrique "Asservissement d'un moteur en vitesse".

Janvier 2013

• 13/1/2013
  • Reprise de la "barrière infrarouge" à NE567 expérimentée l'année dernière :
    

    
    Je vais rajouter un multiplexeur analogique pour pouvoir traiter plusieurs capteurs (utilisant un CD4051) et peut-être un PIC pour en faire un dispositif de détection autonome.
• 4/1/2013
  • Je me suis amusé à installer un interpréteur basic sur ma carte à NXP1768 (arm). L'interpréteur s'appelle Jumentum. Cet interpréteur est accessible via Ethernet ou via une ligne série. Sur Ethernet, il est possible d'utiliser telnet ou un browser web. Jumentum propose un éditeur intégré assez puissant (plein écran). On trouvera quelques détails sur cette manip dans la rubrique intitulée "Interpréteurs sur microcontroleurs".
  • J'ai réalisé une toute petite expérimentation du chip MAX2606. Ce chip intègre dans un tout petit boitier SOT23-6 un oscillateur avec sa varicap. Il permet (notamment) de réaliser un adaptateur sortie audio -> FM. C'est ce que j'ai fait. On trouvera le détail dans la rubrique "Emetteurs radio". En attendant, voila une petite photo du montage comportant l'émetteur à MAX2606 et le récepteur à TDA7000 :
    

    

Les années précédentes :

• 2012
• 2011