mercredi 25 juillet 2012

Fabrication d'un interphone


La fabrication de cet interphone s'est révélée d'une étonnante simplicité.  Je me suis basé sur le schéma de circuit fourni dans la documentation du kit "CK204- Two Station Intercom". Ayant déjà tout le matériel nécessaire à ma disposition, je n'ai pas eu à me procurer le kit.  En fait, seuls les deux microphones et les deux amplificateurs LM386 sont neufs, tout le reste (haut-parleurs, interrupteurs, condensateurs et résistances) a été récupéré dans de vieux appareils.  Les deux terminaux de l'intercom sont reliées par un câble téléphonique (de 4 mètres pour l'instant, mais il pourrait évidemment être plus long).

La personne qui désire parler doit mettre l'interrupteur de sa station dans la position appropriée pendant qu'elle parle dans le micro, puis remettre l'interrupteur dans sa position initiale afin d'écouter la réponse de son interlocuteur (qui doit, à son tour, modifier la position de l'interrupteur pendant qu'il parle dans le micro).


Ce n'est pour l'instant qu'un prototype sur breadboard.  Avant d'en faire une version plus définitive, il faudra que je trouve deux interrupteurs SPDT  (single pole double throw) à poussoir, car avec les interrupteurs à bascule que j'utilise en ce moment, on a tendance à oublier l'interrupteur en position "parler" lorsqu'on désire écouter la réponse (tous les boutons poussoirs dont je dispose en ce moment sont SPST: single pole single throw).

Un contrôle de volume serait également un ajout intéressant, et peut-être aussi une LED indiquant que l'appareil est sous tension.

Yves Pelletier (Twitter: @ElectroAmateur)

vendredi 20 juillet 2012

Remplacement de la pile d'un rasoir électrique

Après avoir porté la barbe pendant plus de 10 ans, j'ai décidé de redevenir glabre.  Après plusieurs minutes de recherche, je suis parvenu à retrouver le vieux rasoir Philips Philishave 840 que j'avais reçu en cadeau il y a une trentaine d'années...pour constater qu'il ne fonctionnait plus du tout!  Il fonctionnait pourtant très bien lors de sa dernière utilisation (en 2001)...

Un rasoir électrique rechargeable n'est pas spécialement compliqué: les lames rotatives sont actionnées par un petit moteur électrique, qui est alimenté par une ou plusieurs piles rechargeables dont le circuit de recharge est intégré à l'intérieur du boîtier.

Quelques mesures au moyen du multimètre m'ont permis de constater que la pile agissait comme un court-circuit, et que le rasoir fonctionnait très bien si je remplaçait cette pile par une autre source de tension continue.  Rien de bien surprenant:  les piles rechargeables au nickel-cadmium ont tendance à devenir inutilisable suite à une longue période d'inactivité.

Ce qui est un peu surprenant, c'est que les fabricants de ce genre de rasoir ne souhaitent pas que les piles soient changées par l'utilisateur:  elles sont soudées à la carte de circuit imprimé!  Pour faciliter la soudure, il faut donc se procurer une pile de remplacement munie de languettes spécialement conçues pour être soudées.

Et bien entendu, mon vieux rasoir fonctionne à nouveau.

Yves Pelletier (Twitter: @ElectroAmateur)

vendredi 13 juillet 2012

Fabrication d'un instrument pour identifier les transistors bipolaires

Le but de ce petit circuit consiste à déterminer si un transistor inconnu est de type "NPN" ou "PNP", si sa broche centrale est la base ou le collecteur, et s'il semble fonctionner (c'est surtout utile si vous récupérez des transistors dans de vieux appareils).

Je me suis très fortement inspiré de cet "instructable".

 Il s'agit en fait de 4 circuits montés sur une même carte; pour bien faire les choses, il y aurait certainement moyen de concevoir un seul circuit muni de deux commutateurs (un qui bascule entre PNP et NPN, l'autre qui bascule entre CBE et BCE), sans que l'utilisateur soit obligé de déplacer le transistor, mais je ne me suis pas donné cette peine pour ce premier prototype.


L'appareil est muni de 4 groupes de 3 connecteurs:  un groupe de connecteurs pour les transistors de type "NPN" dont les broches sont dans l'ordre "CBE", un deuxième groupe de 3 connecteurs pour les transistors de type "NPN" dont les broches sont dans l'ordre "BCE", puis deux groupes de connecteurs pour les transistors de type "PNP" (un pour l'odre "CBE, l'autre pour l'ordre "BCE").

On place d'abord le transistor inconnu dans les connecteurs réservés aux transistors "NPN" dont les broches sont dans l'ordre "CBE".  S'il s'agit effectivement de ce type de transistor, la LED associée à ces connecteurs s'allumera uniquement pendant qu'on appuie sur le bouton.

Si la LED s'allume même pendant que le bouton n'est pas enfoncé, il s'agit probablement d'un transistor de type "NPN", mais dont les broches sont dans l'ordre "BCE" (on branche alors le transistor dans les connecteurs réservés à ce type:  si notre hypothèse est valable, la LED s'allumera uniquement pendant qu'on appuie sur le bouton).

Si la LED ne s'allume pas et demeure éteinte même pendant que le bouton n'est pas enfoncé, il s'agit probablement d'un transistor de type "PNP", hypothèse qu'on pourra vérifier en branchant le transistor à un groupe de connecteurs réservés à ce type.

Si, après avoir placé le transistor aux 4 positions possibles, la condition "LED s'allumant uniquement pendant que le bouton est enfoncé" n'a jamais été respectée, on est en droit de supposer que le transistor est défectueux.

Notez que ce circuit ne permet absolument pas de différencier le collecteur de l'émetteur:  si l'émetteur et le collecteur sont permutés, le transistor fonctionnera normalement (bien qu'avec un gain plus faible, ce qui sera imperceptible dans ce circuit).



Yves Pelletier (Twitter: @ElectroAmateur)

jeudi 12 juillet 2012

Energia: pour programmer le Launchpad comme un Arduino!

Ceux qui ont lu mes articles précédents concernant le Launchpad de Texas Instruments ont peut-être remarqué mes sérieuses réserves concernant la difficulté de programmer les microcontrôleurs de la famille MSP430 au moyen de l'environnement de programmation Code Composer Studio:  le logiciel, qui exige 1 Mo de mémoire vive, est loin d'être simple à utiliser.  De plus, la programmation du MSP430 en langage C repose sur une syntaxe beaucoup plus aride que celle d'un Arduino.

Tout ça n'est peut-être qu'un mauvais souvenir, maintenant que Robert Wessels et son équipe ont mis au point "Energia": une version modifiée de l'IDE Arduino permettant de programmer le Launchpad exactement comme on programme l'Arduino!

Comme vous pouvez le constater sur l'image ci-haut, l'interface utilisateur d'Energia est identique à celle d'Arduino:  mêmes boutons dans le haut de la fenêtre pour uploader le sketch dans le microcontrôleur, ou pour accéder au "Serial Monitor", mêmes menus permettant d'ouvrir des exemples, de sélectionner le port série sur lequel est branché le Launchpad:  on se sent vraiment en terrain connu!   Seule différence visible:  là ou Arduino prévilégie la couleur bleue, Energia utilise le rouge (ce qui est logique:  le Launchpad est rouge, l'Arduino est bleu!).

Et le langage?  Le même que pour programmer un Arduino!  Nul besoin d'inclure une nébuleuse ligne de
code pour désactiver le chien de garde, inutile de se creuser la tête pour gérer les registres des entrées/sorties numériques au moyen de nombres hexadécimaux:  on pilote le Lauchpad avec de simples 
digitalRead, digitalWrite, etc.  Le bonheur total!  

De plus, le Launchpad exécute le sketch automatiquement suite au upload du sketch (alors que dans CCS, il faut initier une session de débogage et cliquer sur un bouton qui démarre l'exécution du sketch).

Comme premier test, j'ai choisi de refaire le code que j'ai fait il y a quelques jours dans Code
Composer Studio, pour lire la valeur analogique d'un potentiomètre (résultat ci-dessous). Le comportement du circuit est identique (les LEDs s'allument à mesure qu'on tourne le potentiomètre) mais le code me semble beaucoup plus facile à comprendre (et à rédiger!).




/*********************************************************
 Sketch pour le Launchpad avec Energia.
 5 LEDs (à P1.1, P1.2, P1.3, P1.4, p1.5) s'allument 
 en fonction de l'intensité du signal analogique transmis 
 par un potentiomètre (à P1.0) 
 *********************************************************/

int valeur; // état du potentiomètre

void setup() { 
  // Pins P1.1 à P1.5 sont en output (chacune pilote une LED)  
  pinMode(P1_1, OUTPUT);     
  pinMode(P1_2, OUTPUT);
  pinMode(P1_3, OUTPUT);
  pinMode(P1_4, OUTPUT);
  pinMode(P1_5, OUTPUT);
}

void loop() {

  valeur = analogRead(A0);

  if (valeur < (0.15*1023))
  {
    digitalWrite(P1_1, LOW);
  }
  else
  {
    digitalWrite(P1_1, HIGH);
  }


  if (valeur < (0.30*1023))
  {
    digitalWrite(P1_2, LOW);
  }
  else
  {
    digitalWrite(P1_2, HIGH);
  }

  if (valeur < (0.45*1023))
  {
    digitalWrite(P1_3, LOW);
  }
  else
  {
    digitalWrite(P1_3, HIGH);
  }

  if (valeur < (0.6*1023))
  {
    digitalWrite(P1_4, LOW);
  }
  else
  {
    digitalWrite(P1_4, HIGH);
  }

  if (valeur < (0.75*1023))
  {
    digitalWrite(P1_5, LOW);
  }
  else
  {
    digitalWrite(P1_5, HIGH);
  }
}

On peut remarquer la numérotation des pins du Launchpad, qui est différente de celle de l'Arduino.  Ici, j'ai utilisé les mêmes numéros que sur la carte (P1_1 pour P1.1, etc.).  J'aurais pu aussi utiliser une simple valeur numérique, comme par exemple "digitalWrite(3,LOW)"...mais l'inconvénient de cette méthode, c'est que les pins ne portent plus le même numéro!  P1.0 porte le numéro 2, P1.1 porte le numéro 3, etc.  (Pour plus de détails, voir cette page).  À moins d'ajouter des autocollants sur le Launchpad pour modifier la numérotation des pins, ça me semble un peu mêlant...

Pour la fonction "analogRead", il faut utiliser une numérotation différente:  "A0" pour la pin 1.0, "A1" pour la pin 1.1, etc.  

Mais attention:  Energia est encore en développement.  Certaines fonctions ne sont pas encore au point.   Les fonction "tone" et "random" n'existent pas encore, et la fonction analogWrite (PWM) donne des résultats  quelque peu déconcertants (plus de détails ici).  Bien entendu, si votre sketch Arduino utilise une obscure librairie inconnue du commun des mortels, il ne fonctionnera pas sur le Launchpad.

Malgré tout, Energia devient aujourd'hui même mon outil de développement numéro 1 pour le Launchpad!  C'est le moment de sortir le champagne:  il est maintenant possible de programmer de façon simple et amusante un Launchpad à $4.30!

Pour télécharger Energia:  http://energia.github.com/Energia/download/

Yves Pelletier (Twitter: @ElectroAmateur)

mercredi 11 juillet 2012

Scheme-it: un outil gratuit pour tracer des schémas de circuit

Scheme-it est une application offerte gratuitement par le vendeur de composant Digi-Key, qui vous permet de construire facilement des schémas de circuits électroniques à l'allure professionnelle.  Nul besoin de télécharger un logiciel complexe:  vous construisez votre schéma directement à l'intérieur de votre fureteur web en vous rendant à l'adresse http://www.digikey.com/schemeit .

 Pour construire un circuit au moyen de Scheme-it, il s'agit de glisser les composants à partir du menu situé à la gauche de la fenêtre (le choix est vaste:  résistances, condensateurs, diodes, transistors, etc.).  Pour faire tourner un composant qui n'est pas dans l'orientation désirée, vous appuyez sur la touche "R" du clavier pendant que le symbole du composant est sélectionné.  Un double-clic sur le composant permet d'ajouter du texte (pour indiquer la valeur d'une résistance, par exemple).  Les branchements sont effectués simplement, au moyen de la souris.

Si vous vous inscrivez sur le site de Digikey, vous pouvez sauvegarder tous vos schémas sur leur serveur.  Une fois terminé, chaque schéma peut être téléchargé en format PNG ou PDF.

Ci-dessous, un schéma réalisé en 5 minutes pendant que j'apprenais à utiliser Scheme-it.


Dans un style différent, il y a aussi Fritzing, dont j'ai déjà parlé ici.

Yves Pelletier (Twitter: @ElectroAmateur)

mardi 10 juillet 2012

Mesure d'un signal analogique avec le MSP430 Launchpad

Cette fois, j'ai appris à traiter un signal d'entrée analogique au moyen de l'ADC10, un convertisseur analogique-numérique à 10 bits.  Encore une fois, je me suis basé sur un des fichiers d'exemple fournis par Texas Instruments, sauf qu'au lieu d'allumer une seule LED lorsque le signal analogique atteint 50% de la valeur maximale de 3,3 V, j'en allume progressivement 5 à mesure que le signal analogique augmente en intensité.

Le circuit consiste en un potentiomètre dont la broche de gauche est branchée à GND, la broche du centre est branchée à l'entrée P1.0, et la broche de droite est reliée à VCC.  En tournant le potentiomètre, le voltage à l'entrée P1.0 variera donc de façon continue entre 0 et 3,3 V environ.  Bien entendu, ce potentiomètre pourrait être remplacé par n'importe quel autre signal analogique:  photorésistance ou thermistance placée en série avec une résistance fixe, etc.

Ensuite, chaque sortie P1.1, P1.2, P1.3, P1.4 et P1.5 est branché à sa LED, qui est elle-même reliée en série avec une résistance de protection, puis raccordée à GND.

Voici le code;  comme toujours, c'est plus compliqué qu'avec un Arduino, mais il s'agira de faire du copier-coller pour réutiliser le code dans d'autres projets (en acheminant la valeur analogique mesurée à un afficheur LCD, on peut créer tout un tas d'appareil de mesures sophistiqués).  J'ai essayé de commenter le plus possible, en espérant que ça pourra être utile à quelqu'un.



//***************************************************************************
//   Traitement d'un signal analogique
//     
//  La broche centrale d'un potentiomètre est reliée à l'entrée P1.0
//  du Launchpad. 5 LEDs branchées aux sorties P1.1, P1.2, P1.3, P1.4 et
//  P1.5 s'allument quand on tourne le potentiomètre.  La LED branchée à
//  P1.1 s'allume lorsque le signal issu du potentiomètre atteint 15% de 
//  3.3 V,, P1.2 s'allume à 30%, etc.
//  Basé sur l'exemple "msp430g2x33_adc10_01.c" fourni par Texas Instruments.
//***************************************************************************

#include "msp430g2553.h"

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;    // Désactivation du chien de garde
  
  ADC10CTL0 = ADC10SHT_2 + ADC10ON + ADC10IE; // Démarrage du convertisseur
                                     // analogique- numérique (ADC10ON), 
                                     // interrupt enabled (ADC10IE),  
                                     // Timer Sample and Hold = /16
  ADC10CTL1 = INCH_0;    // input channel A0 (il y en a 8,numérotés de 0 à 7)
  ADC10AE0 |= 0x01;  //  La pin 1.0 est définie comme entrée analogique
  
  P1DIR |= BIT1+BIT2+BIT3+BIT4+BIT5;   // P1.1, 1.2,1.3, 1.4 et 1.5 définis 
             // en output (LEDs)
                                       // Même chose que:
                                       // P1DIR |= 0x02+0x04+0x08+0x10+0x20;
  for (;;)  // on entre dans la boucle infinie
  {
    ADC10CTL0 |= ENC + ADC10SC;      // Début de l'échantillonnage et de la 
                                     // conversion
                                     // ENC:  enable conversion
                                     // SC:  start conversion
    __bis_SR_register(CPUOFF + GIE);    // Low power mode, en attendant le 
                                        //résultat
   
   
    if (ADC10MEM < 0x099)     // ADC10MEM contient la valeur analogique
                              // mesurée (entre 0 et 1023)
                              // 0x099 = 153 (15% du maximum)
      P1OUT &= ~BIT1;                       // Éteint la LED branchée à P1.1
    else
      P1OUT |= BIT1;                        // Allume la LED branchée à P1.1
 
  
      if (ADC10MEM < 0x133)     // ADC10MEM contient la valeur analogique
                              // mesurée (entre 0 et 1023)
                              // 0x133 = 307 (30% du maximum)
      P1OUT &= ~BIT2;                       // Éteint la LED branchée à P1.2
    else
      P1OUT |= BIT2;                        // Allume la LED branchée à P1.2
      
      
      if (ADC10MEM < 0x1CC)     // ADC10MEM contient la valeur analogique
                              // mesurée (entre 0 et 1023)
                              // 0x1CC = 460 (45% du maximum)
      P1OUT &= ~BIT3;          // Éteint la LED branchée à P1.3
    else
      P1OUT |= BIT3;          // Allume la LED branchée à P1.3
 
       if (ADC10MEM < 0x266)     // ADC10MEM contient la valeur analogique
                              // mesurée (entre 0 et 1023)
                              // 0x266 = 614 (60% du maximum)
      P1OUT &= ~BIT4;    // Éteint la LED branchée à P1.4
    else
      P1OUT |= BIT4;     // Allume la LED branchée à P1.4
      
      
     if (ADC10MEM < 0x2FF)     // ADC10MEM contient la valeur analogique
                              // mesurée (entre 0 et 1023)
                              // 0x2FF = 767 (75% du maximum)
      P1OUT &= ~BIT5;    // Éteint la LED branchée à P1.5
    else
      P1OUT |= BIT5;     // Allume la LED branchée à P1.5
      
  }
  
}

// ADC10 interrupt service routine
#pragma vector=ADC10_VECTOR
__interrupt void ADC10_ISR(void)
{
  __bic_SR_register_on_exit(CPUOFF);  // Clear CPUOFF bit from 0(SR)
}


Yves Pelletier (Twitter: @ElectroAmateur)

mercredi 4 juillet 2012

Afficheur à cristaux liquide (LCD) contrôlé par un MSP430 Launchpad

Pour ce cinquième article sur le Launchpad MSP430 de Texas Instruments, je m'intéresse au contrôle d'un afficheur à cristaux liquides (LCD).

[Voir mes articles précédents concernant le Launchpad]

J'ai trouvé sur le site Co-Random Thoughts un programme qui atteint très bien cet objectif, je n'ai modifié que le message affiché sur le LCD.

Ma version légèrement modifiée du programme.

Si vous disposez d'un module LCD fonctionnant à 3,3 V, les branchements à effectuer sont les suivants:


Pin 1  du LCD:  GND du Launchpad
Pin 2 du LCD:   VCC du Launchpad
Pin 3 du LCD:  "Wiper" du potentiomètre servant à ajuster le contraste (les deux autres broches du potentiomètre étant branchés respectivement à VCC et à GND.
Pin 4 (RS) du LCD:   P1.0 du Launchpad
Pin 5 (RW) du LCD:  GND du Launchpad
Pin 6 (EN) du LCD:   P1.1 du Launchpad
Pin 11 (DB4) du LCD : P1.4 du Launchpad
Pin 12 (DB5) du LCD: P1.5 du Launchpad
Pin 13 (DB6) du LCD:  P1.6 du Launchpad
Pin 14 (DB7) du LCD: P1.7 du Launchpad
Pin 15 du LCD: Vcc du Launchpad
Pin 16 du LCD : GND du Launchpad

De mon côté, mon seul LCD disponible exigeait des signaux logiques de 5 V;  j'ai essayé un branchement direct, sans succès (ça marche parfois, paraît-il).  J'ai donc dû ajouter un étage d'amplification afin de transformer les signaux de 3,3 V à la sortie du Launchpad en signaux de 5 V à l'entrée du LCD.


La sortie VCC du Launchpad est donc remplacée par une source de tension continue de 5 V qui, en plus d'alimenter le LCD (par les broches 1 et 15), alimente six comparateurs  (trois LM393, pour être précis, puisque c'est ce que j'avais sous la main).  Ne pas oublier de relier le GND du Launchpad avec le GND de la source de 5 volts....

Un diviseur de tension achemine un voltage de référence de 1,8 V à l'entrée inverseuse du comparateur.  Lorsque le signal logique provenant du Launchpad est bas, la sortie du comparateur est à 0 V, mais lorsque le signal provenant du Launchpad est haut (3,3 V), la sortie du comparateur prend une valeur de 5 V.  Le circuit est tiré d'un document publié par Microchip.




Chacune des sorties P1.0, P1.1, P1.4, P1.5, P1.6 et P1.7 du Launchpad est donc reliée à l'entrée non inverseuse d'un comparateur, et c'est le signal de sortie du compateur qui est envoyé au LCD.

Ça fonctionne très bien...mais bien sûr le plus simple est de se procurer un module LCD conçu pour fonctionner à 3,3 V (j'en ai vu à partir de $5 sur eBay).

Mise à jour (13 août 2012):  Cet article suppose l'utilisation de Code Composer Studio pour programmer le Launchpad.  Maintenant que le logiciel Energia supporte la librairie "Liquid Cristal", Energia me semble une option beaucoup plus simple.

Yves Pelletier (Twitter: @ElectroAmateur)

dimanche 1 juillet 2012

Launchpad, LED et bouton poussoir

Cette quatrième rubrique concernant le MSP 430 Launchpad de Texas Instruments consiste à allumer et éteindre une LED au moyen d'un bouton poussoir (rubriques précédentes concernant le Launchpad).

Le circuit est illustré ci-contre: une LED en série avec une résistance de protection est branchée entre la broche "P1.0" et la mise à la terre, et un bouton poussoir relié à une résistance "pull-up" contrôle le voltage de l'entrée "P1.4".  En fait, la LED n'est pas strictement nécessaire puisque la carte comporte déjà une LED rouge associée à "P1.0".

Faisons d'abord en sorte que la LED s'allume pendant que le bouton est enfoncé, et qu'elle s'éteint quand le bouton est relâché.  Texas Instruments fournit un exemple de sketch qui accomplit cette tâche:  vous le trouverez sous le nom de "msp430g2xx3_P1_01.c", et comme d'habitude la description du fichier est assez nébuleuse:  "Software Poll P1.4, Set P1.0 if P1.4 = 1".



/************************************************************************
Code d'origine fourni par TI pour allumer une LED (branchée à P1.0)
au moyen d'un bouton (branché à P1.4)
*************************************************************************/
#include  

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;              // Désactivation du chien de garde
  P1DIR |= 0x01;                         // P1.0 réglé à output

  while (1)                              // Boucle infinie
  {
    if ((0x10 & P1IN)) P1OUT |= 0x01;    // Si P1.4 est 1, on met P1.0 à 1
    else P1OUT &= ~0x01;                 // Sinon, on met P1.0 à 0
  }
}



J'ai modifié le sketch original en utilisant une syntaxe moins compacte de façon à obtenir un résultat qui est, en ce qui me concerne, un peu plus lisible:



/************************************************************************
Code pour allumer une LED (branchée à P1.0) au moyen d'un bouton 
(branché à P1.4).  La LED s'éteint dès qu'on relâche le bouton.
*************************************************************************/

#include  

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;              // Désactivation du chien de garde
  P1DIR = P1DIR | BIT0;                 // P1.0 réglé à output

  while (1)                              // Boucle infinie
  {
    if ((BIT4 & P1IN)) {
     P1OUT =  (P1OUT | BIT0);   // Si P1.4 est 1, on met P1.0 à 1
     }  
    else{ 
     P1OUT = P1OUT & ~BIT0;  // Sinon, on met P1.0 à 0
     }               
  }
}





Dans un premier temps, le code désactive le chien de garde, un dispositif qui permet de redémarrer le programme si ce dernier est gelé, mais qui ne nous intéresse pas pour l'instant.  "WDTCTL" signifie "watchdog timer control"; "WDTPW" signifie "watchdog timer password" et "WDTHOLD" signifie "watchdog timer hold".


Par défaut, toutes les broches sont réglées en "input" au démarrage.  Pour alimenter la LED, P1.0 doit être configuré en "output", et c'est ce que nous accomplissons dans la ligne suivante.  P1DIR est un nombre binaire à 8 bits qui indique l'état (entrée ou sortie) des broches P1.0 à P1.7.  "BIT0" et "0x01" sont deux façons différentes d'exprimer le nombre binaire "00000001".  Grâce à l'opérateur logique "|" ("OU"), le bit associé à P1.0 est réglé à "1" est les autres bits demeurent inchangés.

Related Posts Plugin for WordPress, Blogger...