Comment lire une entrée numérique sur ATmega16?

Que dois-je faire pour lire une entrée numérique (bouton-poussoir) sur ATmega16 ? Dois-je activer les résistances de pullup ou puis-je en utiliser une de 10 kohms? Que serait un simple code? Juste un simple 'Allumez la LED lorsque vous appuyez dessus'.

Existe-t-il un tutoriel pour débutant? J'ai essayé de googler et d' AVR Freaks , mais tout évolue simplement vers un combat là-bas et je n'ai pas ma réponse. Je n'ai vraiment trouvé aucun tutoriel sur ce genre de choses. Des tonnes de choses spécifiques mais rien de simple à propos de mon microcontrôleur AVR ...

Salutations brésiliennes!

Merci tout d'abord Joby pour votre exemple. Deuxièmement, son exemple ne comporte qu'une erreur mineure. Le nombre 0x20 n'est pas correct. Il doit s'agir de 0x04. De plus, à titre de suggestion, je n'utiliserais pas de nombres hexadécimaux comme 0xFB, 0x20 ou 0x04 dans le code. Je suggérerais d'utiliser les définitions de port PIN trouvées dans l'io.h et d'autres référencées par le fichier d'en-tête. J'ai réécrit l'exemple de Joby ci-dessous, avec quelques commentaires pour les débutants.

# include <avr/io.h>

int main (void)
{
    // set all pins on PORTB for output
    DDRB = 0xFF;

    // set port pin PORTD2 as input and leave the others pins 
    // in their originally state (inputs or outputs, it doesn't matter)
    DDRD &= ~(1 << PD2);        // see comment #1

    while (1) 
    {
        if (PIND & (1<<PD2))    // see comment #2
            PORTB |= (1<<PB2);  // see comment #3
        else
            PORTB &= ~(1<<PB2); // see comment #4
    }
    return 0;
}

/ *

commentaires pour les débutants

commentaire # 1: (1 << PD2) génère le binaire 00000100. L'opération "~" inverse tous les chiffres, c'est-à-dire que le binaire est maintenant 11111011. Enfin le & = applique la logique "ET" entre DDRD et 11111011 et le résultat est à nouveau placé dans la mémoire DDRD. Remarque: ce que l'opérateur "ET" fait pour chaque bit de la mémoire DDRD, il le compare au nombre binaire ci-dessus. Si le bit dans DDRD est 0 et le bit dans le binaire à la même position de morsure est 1, alors le bit résultant est 0, si le DDRD est 1 et le bit dans le binaire est 1, le bit résultant est 1, et si le bit dans le DDRD est 1 ou 0 et le bit dans le binaire est 0 alors le bit résultant est toujours 0. En résumé, la commande DDRD & = ~ (1 << PD2) modifie uniquement le bit PD2 à zéro et laisse les autres (zéros ou uns) intacts. Cela semble un peu compliqué, mais après vous y être habitué, c'est le meilleur moyen de changer un peu en une bouchée sans changer les autres bits.

commentaire # 2 : (1 << PD2) génère le binaire 00000100. En utilisant la même logique "ET" décrite dans le commentaire # 1, la commande "PIND & 0000100" vérifie uniquement si le PIND2 (notre broche d'entrée où le bouton-poussoir est connecté) to) est réglé sur élevé ou non. Toutes les autres broches seront FAUX puisque les bits binaires sont mis à 0, et puisque le bit binaire # 2 est mis à 1, l'instruction IF ne sera VRAIE que si l'entrée PD2 est réglée à haut ou FAUX si l'entrée PD2 est réglé sur faible.

commentaire # 3 : En suivant la logique expliquée dans le commentaire # 1, cette commande définit la broche de sortie PINB2 dans le port PORTB sur haute tension. Si votre LED est correctement connectée à ce port de broche avec une résistance de ~ 300 ohms et que cette résistance est connectée à la masse, la LED doit s'allumer.

commentaire # 4 : La LED devrait s'éteindre pour les mêmes raisons expliquées dans les commentaires précédents.

Considérations finales:

a) Pour éviter l'oscillation de tension dans la broche d'entrée PD2 lorsque le bouton-poussoir n'est pas enfoncé (circuit ouvert), je recommande fortement de placer une résistance de rappel (1 kOhm ou plus), afin que la LED ne s'allume pas accidentellement en raison à cette oscillation de tension aléatoire.

b) Une note de non-responsabilité: Les idées décrites ici doivent être utilisées uniquement à des fins éducatives et elles ne doivent PAS être utilisées dans un système réel avant de consulter un expert en électronique.

* /

https://www.mainframe.cx/~ckuethe/avr-c-tutorial/

https://www.mainframe.cx/~ckuethe/avr-c-tutorial/#digital-in

#include <avr/io.h>

/*
 * Assumptions:
 *  - LED connected to PORTB.2
 *  - Switch connected to PORTD.2
 */

int main (void)
{
    /* set PORTB for output*/
    DDRB = 0xFF;
    /* set PORTD for input*/
    DDRD &= 0xFB;
    PORTD |= 0x04;

    while (1) {
        if (PIND & 0x04)
            PORTB &= ~0x20;
        else
            PORTB |= 0x20;
    }
    return 0;
}

Hackaday avait une excellente écriture pour la programmation AVR, il a beaucoup d'excellentes informations qui pourraient vous aider

http://hackaday.com/2010/11/19/avr-programming-04-writing-code-etc/

http://hackaday.com/2010/11/05/avr-programming-03-reading-and-compiling-code/

http://hackaday.com/2010/10/25/avr-programming-02-the-hardware/

http://hackaday.com/2010/10/23/avr-programming-introduction/

Eh bien, c'est pour l'AT90Usb1287, un ATMega, mais le bouton de base devrait être plus ou moins le même. Modifiez simplement les noms d'E / S.

• http://www.avrfreaks.net/wiki/index.php/Documentation:Tutorials_gcc_AT90UsbKey#Push_the_Button

Une autre chose à considérer lors du traitement d'une entrée numérique à partir d'un interrupteur mécanique est le rebond des contacts - changer ce qui devrait être une simple pression de bouton en ce qui ressemble à plusieurs pressions.

Pour quelque chose comme allumer une LED lorsque le bouton est maintenu enfoncé, vous n'avez probablement pas à vous soucier du rebond. Pour quelque chose d'un peu plus compliqué (comme basculer la LED sur la touche), le anti-rebond est un must.

Jack Ganssle a un bon guide pour anti-rebond