je suis en train de faire un programme pour mes PPE (je suis en terminal S SI) qui doit controler un système créé par nous mêmes, un distributeur de grain pour les animaux.
La plus grosse partie est faite, et la dernière chose que je voudrais implenter, c'est un mode veille sur notre ATmega16.
Pour le moment j'ai un timer qui fonctionne avec interruption pour faire une RTC sommaire afin de compter les heures, au bout de 12 heures, le µC déclenche une focntion PWM pour faire tourner un moteur, pendant ces 12 hr, je voudrais mettre l'µC en veille pour économiser la batterie.
-je voudrais savoir s'il est possible de le mettre en veille, sachant que dans ma routine d'interruption du Timer2 j'ai quelque chose qui compte les interruptions et qui au bout d'un certain nombre, fait une seconde, puis compte les sec pour les min etc....avec des if();??
si c'est possible, une fois qu'il est en mode veille, je voudrais qu'il se réveille au bout de 12hr pour le PWM, ou alors grace à la liaison série par le biais de l'hyperterminal, et une Interruption Rx.
dans codevision j'ai lancé un nouveau projet pour seulement configurer une interruption Rx et ca me donne ça:
- Code: Tout sélectionner
#include <mega16.h>
#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7
#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)
// USART Receiver buffer
#define RX_BUFFER_SIZE 8
char rx_buffer[RX_BUFFER_SIZE];
#if RX_BUFFER_SIZE<256
unsigned char rx_wr_index,rx_rd_index,rx_counter;
#else
unsigned int rx_wr_index,rx_rd_index,rx_counter;
#endif
// This flag is set on USART Receiver buffer overflow
bit rx_buffer_overflow;
// USART Receiver interrupt service routine
interrupt [USART_RXC] void usart_rx_isr(void)
{
char status,data;
status=UCSRA;
data=UDR;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
{
rx_buffer[rx_wr_index]=data;
if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;
if (++rx_counter == RX_BUFFER_SIZE)
{
rx_counter=0;
rx_buffer_overflow=1;
};
};
}
#ifndef _DEBUG_TERMINAL_IO_
// Get a character from the USART Receiver buffer
#define _ALTERNATE_GETCHAR_
#pragma used+
char getchar(void)
{
char data;
while (rx_counter==0);
data=rx_buffer[rx_rd_index];
if (++rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;
#asm("cli")
--rx_counter;
#asm("sei")
return data;
}
#pragma used-
#endif
// Standard Input/Output functions
#include <stdio.h>
[...]
// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 9600
UCSRA=0x00;
UCSRB=0x98;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x33;
// Global enable interrupts
#asm("sei")
[...]
mais à vrai dire, autant l'interruption d'un compteur lorsque la comparaison est bonne est plutot simple a manipuler avec du code a mettre dans la routine, ici je ne vois pas du tout comment cela focntionne exactement.
Qu'est qui crée l'interruption? Qu'est-ce qu'il se passe s'il y a interruption? Comment réveillé le µC avec ça?
D'habitude, quand je ne sais pas comment ca marche, j'essai directement sur le µC, mais il est au lycée, et j'aimerais bien avancé un peu chez moi.
merci d'avance.