Reception IR en c avec un atmega328p

[inviteeea328c7]

Bonjour,

Je suis actuellement en stage et je dois créer un capteur infrarouge.

Pour la gestion de mon infra rouge j'utilise le PORTB d'un atmega328p.

La broche PB3 est en sortie et avec une interruption du timer2 je pilote 3 LEDs infrarouge (940nm) pour les faire osciller a 38kHz.

Sur les broches PB0 a PB2 j'ai 3 recepteurs infrarouge qui me donnent un état haut lorsque je n'ai pas de réception et un état bas lorsque de l'IR (940nm) à 38kHz est reçu.

Ces 4 broches sont protégées par une résistance externe de 1Kohm.

Le problème est le suivant :

Une fois l'état des broches de reception lu je dois afficher une page web avec l'état des boites a lettre (les capteurs, 1 LED + 1 Recepteur vont dans 3 boites).

J'utilise pour cela une fonction "readstate" que j'ai créé.

Une fois l'état lu j'utilise dans une autre fonction l'état de mes trois variables u8stateB0/1/2 (modifié par "readstate") pour déterminer si la page web doit afficher la boite vide ou pleine.

Cette page m'indique a chaque fois une boite vide, c'est a dire que mes trois variables sont tout le temps a 0 (c'est le test de mon autre fonction).

J'ai vérifié lorsque je ne mets pas de résistances de pullup sur mes entrées mes états haut et bas sont respectivement de 440 et 80mV (suite à la réception ou non d'IR).

Et lorsque les résistances sont activées les états haut et bas sont respectivement de 640 et 200mV (aussi suite à la réception ou non d'IR).

Si joint mon premier programme de test pour mon émission/réception infrarouge et ma fonction readstate (qui n'est pas utilisée dans ce programme), toutes ces fonctions sont reprisent dans mon programme final, il ajoute énormément de code uniquement pour toute la gestion du web c'est pour ça que je ne vous l'ai pas ajouté.

Je pense que le problème vient de ma fonction "readstate" mais je ne vois pas comment lire mes broches d'entrée autrement.


Dans l'attente d'idées nouvelles,

Code :

 Cliquez pour afficher

#include <avr/io.h>
#include <inttypes.h>
#define F_CPU 6250000UL // 6.25 MHz
#include <util/delay.h>
#include <avr/interrupt.h>

unsigned char ucDelay;
unsigned char ucIr;
unsigned char u8stateB0;
unsigned char u8stateB1;
unsigned char u8stateB2;

unsigned char i;

/* port en entrée : DDRx&=~(1<<PORTxN);
pull-up : PORTx|=(1<<PORTxN);
dis pull-up : PORTx&=~(1<<PORTxN);
etat broche : uint8_t etat=(PINx&(1<<PINxN));*/

ISR(TIMER2_OVF_vect)
{
TCNT2=ucDelay;
if(ucIr)
{
PORTC |=(1<<PORTC3); //OFF
ucIr=0;
}
else
{
PORTC &=~(1<<PORTC3); //ON
ucIr = 1;
}
}

void setupISR(void)
{
/* value of reload for the timer 2 */
ucDelay = 0x80;
/* enables interrupts of timer 2 */
TIMSK2 = 0b00000001;
/* default value of timer */
TCNT2 = ucDelay;
/* no prescaler */
TCCR2B = 0b00000001;
/* booleen to 1 */
ucIr=1;
/* set global interrupt enable */
sei();
}

void setupIR(void)
{
/* *** Emission *** */
/* enable PC3 as output */
DDRC |=(1<<DDC3);
/* switch ON the IR LEDs */
PORTC &=~(1<<PORTC3);

/* *** Reception *** */
/* enable 3 receptors as input */
DDRC &=~(1<<PORTC2);
DDRC &=~(1<<PORTC1);
DDRC &=~(1<<PORTC0);

/* disable pull-up resistors */
PORTC&=~(1<<PORTC2);
PORTC&=~(1<<PORTC1);
PORTC&=~(1<<PORTC0);

/* enable pull-up resistors */
//PORTC|=(1<<PORTC2);
//PORTC|=(1<<PORTC1);
//PORTC|=(1<<PORTC0);
}
void readstate(void)
{
u8stateB0=(PINC&(1<<PINC0));
u8stateB1=(PINC&(1<<PINC1));
u8stateB2=(PINC&(1<<PINC2));

if(u8stateB0>0.5)
u8stateB0=1;
else
u8stateB0=0;

if(u8stateB1>0.5)
u8stateB1=1;
else
u8stateB1=0;

if(u8stateB2>0.5)
u8stateB2=1;
else
u8stateB2=0;
}
int main(void)
{
/* set the clock prescaler */
CLKPR=(1<<CLKPCE);
CLKPR=0; // 8 MHZ
//CLKPR=(1<<CLKPS0); // 4MHz
//CLKPR=((1<<CLKPS0)|(1<<CLKPS1) ); // 1MHz
//CLKPR=((1<<CLKPS0)|(1<<CLKPS2) ); // 0.25MHz

/* enable PB1 as output */
DDRB|= (1<<DDB1);

setupIR();

setupISR();

/* Ugly loop to see the main program doing something */
while (1)
{
/* led on, pin=0 */
PORTB &= ~(1<<PORTB1);
_delay_ms(250);
_delay_ms(250);
/* set output to 5V, LED off */
PORTB|= (1<<PORTB1);
_delay_ms(250);
_delay_ms(250);
}
return(0);
}

-----

[inviteeea328c7]

J'ai retesté avec diverses valeurs pour les tests dans la fonction "readstate", le résultat est le même avec tous, les broches d'entrées après la fonction sont toutes passée à 0.

Le problème doit donc vraiment venir de la lecture de mes broches, mais je découvre les micro-controleurs atmega et je ne sais ne sais pas comment comment les lire autrement, je vais à la recherche d'information et je vous tient au courant.

[inviteeea328c7]

Aller je me rerépond mais j'ai de nouveaux éléments.

Donc j'ai modifié mon code de façon a afficher sur ma page web l'état de "PINB" qui est le registre d'état des broches, qui sert aussi à la lecture d'état d'une broche.

Cette fonction éclate le registre dans 8 variables, une pour chaque bit :

 Cliquez pour afficher

void readstate(void)
{
u8statePINC=PINC;
u8stateC0=(u8statePINC & 0b00000001);
u8stateC1=(u8statePINC & 0b00000010);
u8stateC2=(u8statePINC & 0b00000100);
u8stateC3=(u8statePINC & 0b00001000);
u8stateC4=(u8statePINC & 0b00010000);
u8stateC5=(u8statePINC & 0b00100000);
u8stateC6=(u8statePINC & 0b01000000);
u8stateC7=(u8statePINC & 0b10000000);
}

J'ai aussi modifié ma fonction d'affichage de page web (je n'ai pas d'écran ni de possibilité de simulation donc j'utilise tout mon progamme) pour quelle affiche l'état de ces 8 bits :

 Cliquez pour afficher

uint16_t print_webpage(uint8_t *buf)
{
uint16_t plen;
plen=fill_tcp_data_p(buf,0,PST R("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\nPragma: no-cache\r\n\r\n"));
plen=fill_tcp_data_p(buf,plen, PSTR("<center><p>PINC7 is: "));
if (u8stateC7)
{
plen=fill_tcp_data_p(buf,plen, PSTR("<font color=\"#00FF00\"> 1</font>"));
}
else
{
plen=fill_tcp_data_p(buf,plen, PSTR("0"));
}
plen=fill_tcp_data_p(buf,plen, PSTR("<center><p>PINC6 is: "));
if (u8stateC6)
{
plen=fill_tcp_data_p(buf,plen, PSTR("<font color=\"#00FF00\"> 1</font>"));
}
else
{
plen=fill_tcp_data_p(buf,plen, PSTR("0"));
}
plen=fill_tcp_data_p(buf,plen, PSTR("<center><p>PINC5 is: "));
if (u8stateC5)
{
plen=fill_tcp_data_p(buf,plen, PSTR("<font color=\"#00FF00\"> 1</font>"));
}
else
{
plen=fill_tcp_data_p(buf,plen, PSTR("0"));
}
plen=fill_tcp_data_p(buf,plen, PSTR("<center><p>PINC4 is: "));
if (u8stateC4)
{
plen=fill_tcp_data_p(buf,plen, PSTR("<font color=\"#00FF00\"> 1</font>"));
}
else
{
plen=fill_tcp_data_p(buf,plen, PSTR("0"));
}
plen=fill_tcp_data_p(buf,plen, PSTR("<center><p>PINC3 is: "));
if (u8stateC3)
{
plen=fill_tcp_data_p(buf,plen, PSTR("<font color=\"#00FF00\"> 1</font>"));
}
else
{
plen=fill_tcp_data_p(buf,plen, PSTR("0"));
}
plen=fill_tcp_data_p(buf,plen, PSTR("<center><p>PINC2 is: "));
if (u8stateC2)
{
plen=fill_tcp_data_p(buf,plen, PSTR("<font color=\"#00FF00\"> 1</font>"));
}
else
{
plen=fill_tcp_data_p(buf,plen, PSTR("0"));
}
plen=fill_tcp_data_p(buf,plen, PSTR("<center><p>PINC1 is: "));
if (u8stateC1)
{
plen=fill_tcp_data_p(buf,plen, PSTR("<font color=\"#00FF00\"> 1</font>"));
}
else
{
plen=fill_tcp_data_p(buf,plen, PSTR("0"));
}
plen=fill_tcp_data_p(buf,plen, PSTR("<center><p>PINC0 is: "));
if (u8stateC0)
{
plen=fill_tcp_data_p(buf,plen, PSTR("<font color=\"#00FF00\"> 1</font>"));
}
else
{
plen=fill_tcp_data_p(buf,plen, PSTR("0"));
}
plen=fill_tcp_data_p(buf,plen, PSTR("</p>"));
plen=fill_tcp_data_p(buf,plen, PSTR("</center><hr><br>version 2.17, tuxgraphics.org\n"));
return(plen);
}

J'ai ajouter un screen de la page web qui s'affiche avec l'état des PINCx et un screen de la partie de la datasheet qui donne le format du registre PINC.

J'ai aussi remarqué autre chose qui devrait plus vous motiver en temps qu’électroniciens :

Sur ma protoboard (je travail actuellement sur ma maquette "finale")
J'avais mis une LED rouge entre la sortie de mon recepteur (passant si pas d'IR et a la masse si IR) infrarouge et ma masse (avec une résistance pour la protéger). Pour voir a l'oeil nu les variations sur mon recepteur.

Et je n'ai pas mis cette LED sur ma dernière maquette.
J'ai retesté sur ma protoboard, mon courant est beaucoup plus élevé avec cette dernière donc en fait je pense que mon problème est matériel (sans la LED la sortie de mon récepteur n'est pas assez haute, en voltage, pour être détectée par mon microcontroleur lorsque le récepteur est passant).

Cela me trouble, je ne comprend pas comment une LED peut relever un voltage.

[inviteeea328c7]

Hum je comprend, enfin je crois.

U=R*I

Ayant un faible ampérage dans mon circuit, la tension que je récupère avec juste des résistances est faible. Donc l'ajout d'une LED qui a une très faible résistance me permet de mesurer a ses bornes une tension plus élevé, détectable par mon microcontroleur tout en ayant la même intensité de courant dans mon circuit.

J'ai bon ?

[A voir en vidéo sur Futura]

[inviteeea328c7]

Bien, je me remercie le problème venait bien de là.
Je vous remercie aussi de m'avoir pousser a l'auto-interrogation, c'est toujours plus gratifiant de finir 3 mois de projet seul.

Je vous donne plus de détails.

Mon projet consiste a créer un capteur embarqué pour des boites à lettres.
A l'aide d'un serveur web embarqué et d'émetteur/récepteur infrarouge je devait détecter si il a du courrier ou non dans la boite a lettre et maintenir en permanence sur une page web (hébergée par mon petit serveur) l'état des boites pleines, ou vides.

Cette discussion peut être supprimée.

Cordialement.

[invite29971eb1]

Si tous les forumeurs se comportaient comme toi, ce serait la fête

J'avais regardé ton sujet hier soir mais j'avoue que je m'étais perdu dans les masques, etc.

Tant mieux si ça marche mais ton explication est....bizarre.

Si tu nous montrais un schéma de ton montage....

[inviteeea328c7]

Bien mon problème était matériel et pas logiciel comme je le pensais au début.

Je n'ai pas encore le schéma du circuit que j'ai créé mais il faut que je le fasse pour mon rapport, d'ailleurs si vous connaissez un logiciel simple pour faire des schémas électroniques....

Après mon récepteur mon voltage de sortie sur un supposé état haut n'était pas assez haut pour être détecté par mon micro contrôleur car j'avais juste une résistance.

branchement : récepteur _ résistance _ masse

je l'ai modifié : récepteur _ LED _ résistance _ masse

Et j'ai récupéré mes états haut ou bas entre mon récepteur et ma résistance (branchement de mon micro contrôleur quoi) au lieu de le prendre entre mon récepteur et ma résistance.Je ne comprend pas vraiment pourquoi mais avec ma LED le voltage est plus élevé et donc mon état haut est détecté comme haut et non pas comme un état bas tout le temps.