Exemplo modo sleep para pic em C

linikersoares · 21 de julho de 2012

Boa noite,

queria um exemplo que podesse me ajudar no meu projeto

como criar uma logica para fazer com que meu programa hiberne armazenando as horas

assim que eu apertar um botao, e voltar a funcionar normalmente

quando resetar pelo master clear.

jorgeletronico · 24 de julho de 2012

salva na memoria ,depois você recupera ela .

Jefersoncw · 24 de julho de 2012

o pic internamente possui uma eprom onde você pode armazenar as informaçoes... dependendo do modelo do pic tem mais memoria ou menos. então voce guarda na memoria as informaçoes.. e depois quando voce resetar o pic voce faz uma rotina que le a eprom voltando assim o valor das horas...

caso queira mais explicado... post alguma coisa para eu ver... trecho de codigo.. ou a ideia como um todo, que eu te ajudo...

Abraço

linikersoares · 24 de julho de 2012

intao, estou desenvolvendo o propeller clock,

ja esta funcionando as horas e data, porém quando desligo o circuito as horas sao desatualizadas com este modo poderia colocar uma pequena bateria e o pic sempre atualizaria para mim (tipo essas de computador) queria fazer isto

assim que tiro a fonte do circuito a pilha entre e o pic hiberne e esteja contando as horas, e quando liga-lo novamente as horas ja estão atualizadas em tempo real.

mister nintendo · 24 de julho de 2012

use o CI ds1307 é um contador de horas de tempo real usa pouquissima energia e usa comunicação i2c

então voce poderia hibernar seu pic desligalo etc que quando ligasse ele de novo ele logo se comunicaria com o CI e atualizaria a hora pois o CI sempre esta contando a hora, ele trabalha independente do pic precisa apenas de um cristal e as baterias do tipo botão

linikersoares · 24 de julho de 2012

Obrigado amigo mas minha PCI ja esta pronta,ate tive muitas dicas de usar este CI como tem este comando do pic pensei em usa-lo, se souber como devo fazer poste ai.

obrigado

Jefersoncw · 25 de julho de 2012

Creio que só com o PIC nao tem como fazer... uma vez que quando você entra em sleep... seu programa fica congelado... e então nao tem como ficar contando o tempo em sleep.

A unica maneira é voce colocar uma bateria boa, que quando você desliga a alimentaçao a bateria segura fonte. mas n pode por em sleep.

mister nintendo · 25 de julho de 2012

mas se é para um propeller clock como você vai colocar para rodar a bateria que alimentara o pic?? poste uma foto desse seu projeto para vermos melhor!!!

linikersoares · 25 de julho de 2012

segue o video que entenderam o meu problema amigos!

caso haja alguma solucao estarei aqui

se houver nessecidade de email ou msn para me facilitar ok?

abraços!

Pessoal andei pensando e pesquisando o dia inteiro e tive uma idea,

preciso fazer o seguinte.

assim que a fonte do circuito e desconectada

entra uma bateria

dai tem que programa para o pic funciona em baixa tensão

habilito uma interrupcao externa pin_bo

se ela acontencer;

chama a instrucao sleep;

que continuara a contar uma variavel do timer1 que esta incrementando as horas e realizar a funcao de relogio (if segundo >59 );segundo=0; minuto++;(if minuto >59)minuto =0;hora++ .....

tipo isso como fazer em ccs?

se alguem souber escreva o trecho ai pra mim

Obrigado!

A eu de novo!!

tentei criar um codigo aqui ne outro exemplo que fiz deu certo mas neste nao esta funcionando to tentando utilizar a interrupcao externa pelo portb0 mas nao esta dando se alguem ver um erro me diz por favor!

#fuses intrc_io, nowdt, noprotect, put, nobrownout, mclr, nolvp, nocpd
#use delay(clock=4000000)
#use fast_io(

#define BOTAO1 PIN_a0 //Boto de escolha de ajuste das funcoss.
#define BOTAO_INCREMENTO PIN_a1 //Boto incremento de variveis.
#define livre PIN_a2
#define sensor PIN_a3
#byte porta = 0x05
#byte portb = 0x06
short sleep_mode;

//Boto de decremento das variveis.
//int apagado = 0; //apagado
int a;
int n;
int h=19;
int m=1;
int s=0;
int dezena, unidade, digito;
int16 q=0,j=0;
int contador=0;
int dia=18; //Variável dos dias do mês. 0 a 31.
int mes=7;
int ano=12;
int16 tempo;
//Tabela com os digitos
const unsigned char table[27][5] = {
0b01111110,0b01000010,0b01000010,0b01000010,0b01111110,// 0
0b00000010,0b00100010,0b01111110,0b00000010,0b00000010,//1
0b01011110,0b01010010,0b01010010,0b01010010,0b01110010,//2
0b01010010,0b01010010,0b01010010,0b01010010,0b01111110,//3
0b01110000,0b00010000,0b00010000,0b00010000,0b01111110,//4
0b01110010,0b01010010,0b01010010,0b01010010,0b01011110,//5
0b01111110,0b01010010,0b01010010,0b01010010,0b01011110,//6
0b01100000,0b01000000,0b01000000,0b01000000,0b01111110,//7
0b01111110,0b01001010,0b01001010,0b01001010,0b01111110,//8
0b01110010,0b01010010,0b01010010,0b01010010,0b01111110,//9
0x00, 0x36, 0x36, 0x00, 0x00, // : 10
0b00000000,0b01111110,0b01010010,0b01010010,0b00101100,//B B 11
//0b00000000,0b00111100,0b01000010,0b01000010,0b01000010,//C 12
0b01111110,0b01000010,0b01000010,0b00100100,0b00011000,//D 13 D 12
0b01111100,0b01010100,0b01010100,0b01010100,0b01000100,//E 14 E 13
//0b00111110,0b01010000,0b01010000,0b01010000,0b01000000,//F 15
//0b00111100,0b01000010,0b01000010,0b01001010,0b01001110,//G 16
//0b01111110,0b00010000,0b00010000,0b00010000,0b01111110,//H 17
0b00000000,0b01000010,0b01111110,0b01000010,0b00000000,//I 18 i 14
//0b00001100,0b00000010,0b01000010,0b01111100,0b01000000,//J 19
//0b01111110,0b00010000,0b00011000,0b01100100,0b00000010,//K 20
//0b01111110,0b00000010,0b00000010,0b00000010,0b00000010,//L 21
//0b01111110,0b00100000,0b00011000,0b00100000,0b01111110,//M 22
0b01111110,0b00110000,0b00011000,0b00001100,0b01111110,//N 23 n 15
0b00000000 , 0b00111100 , 0b01000010 , 0b00111100 , 0b00000000,// O 16
//0b01111110,0b01010000,0b01010000,0b00100000,0b00000000,//P 25
//0b00111100,0b01000010,0b01001010,0b01000010,0b00111010,//Q 26
0b01111110,0b01010000,0b01001100,0b00100100,0b00000010,//R 27 R 17
//0b00110110,0b01001110,0b01001010,0b01001010,0b01000100,//S 28
0b01000000,0b01000000,0b01111110,0b01000000,0b01000000,//T 29 T 18
//0b01111100,0b00000010,0b00000010,0b00000010,0b01111100,//U 30
//0b01111000,0b00000100,0b00000010,0b00000100,0b01111000,//V 31
0b00111110,0b00000000,0b01001000,0b00000000,0b00111110,// A 19
0b11000111,0b11000011,0b11100001,0b11000011,0b11000110,//coraao(33) 20
// 0b11000111,0b10000010,0b10000111,0b10000000,0b11000111,//led(34)
0b11111111,0b11111111,0b11111111,0b11111111,0b11111110,//apaga 35 21
0b11000001,0b10000000,0b10000000,0b10001000,0b11011100,//pac man 36 22
0b11111111,0b11100111,0b11100111,0b11111111,0b11111111,//ponto 38 23
0b11111110,0b11111011,0b11101110,0b11111110,0b10111110,// barra 24

0b00000000,0b00000010,0b00000010,0b00000000,0b00000000,//ponto 25
0b11000000,0b10000001,0b10000000,0b10000001,0b11000000};//bichinho 26
#INT_EXT
void ext_isr() {
static short button_pressed=FALSE;

if(!button_pressed) // if button action and was not pressed
{
button_pressed=TRUE; // the button is now down
sleep_mode=TRUE; // activate sleep
q++;
s=q/2; //A variável Q incrementa a 2Hz, então os segundos
//devem ser a metade.
if (s==60) //Se for igual a 60, reset em Q e S. M incrementa.
{
q=0;
s=0;
m++;

}

if (m>59)
{
m=0;
h++;
}

if (h>23) //Se H(horas) for maior q 23, reset. DIA DA SEMANA
{ //e DIA DO MÊS incrementam.

h=0;
dia++;
}
if (dia>31)
{
mes++;
}
if (mes>12)
{
ano++;
}
ext_int_edge(L_TO_H); // change so interrupts on release
}
else // if button action and was pressed
{
button_pressed=FALSE; // the button is now up
sleep_mode=FALSE; // reset sleep flag
ext_int_edge(H_TO_L); // change so interrupts on press
}
if(!input(PIN_B0)) // keep button action sychronized wth button flag
button_pressed=TRUE;
delay_ms(100); // debounce button
}
#int_TIMER1
void temp1s(void){
tempo++;
q++;

if (tempo>=2);//passou 1 segundo
{
j++; //incrementa variavel de controle
if (j>56){
j=0;
}
tempo=0;
}

set_timer1 (3036+(get_timer1())); //recarrega Timer1
}

void caracter(digito) {
//output_high(pin_b0);
output_high(pin_b7); //chr contem 2 digitos (hh,mm o ss)
dezena = (digito/10); // dezenas
unidade = (digito-(dezena*10)); //e as unidades

for (n=0;n<5;n++) {
//output_high(pin_b0);
output_high(pin_b7); //preparar a tabela para primeiro digito
output_b(table[dezena][n]);
output_high(pin_b0);
output_high(pin_b7);
delay_us(700) ;//160useg cada pixel horizontal

}

delay_us(1500); //pausa entre digitost
output_b(0x81);
delay_us(1500); //pausa entre digitos*/

for (n=0;n<5;n++) {
//output_high(pin_b0);
output_high(pin_b7);
output_b(table[unidade][n]);
//output_high(pin_b0);
output_high(pin_b7);
delay_us(700);
}
delay_us(700); //pausa entre digitos
output_b(0x81);
delay_us(700); //pausa entre digitos
}

void doispontos()
{
//output_high(pin_b0);
output_high(pin_b7);
for (n=0;n<5;n++) { //preparar tabela para primeiro digito
output_b(table[10][n]);
//output_high(pin_b0);
output_high(pin_b7);
delay_us(400); //160useg cada pixel horizontal
}
delay_us(900); //pausa entre digitost
output_b(0x81);
delay_us(900); //pausa entre digitos*/

}

void barra()
{
//output_high(pin_b0);
output_high(pin_b7);
for (n=0;n<5;n++) { //preparar tabela para primeiro digito
output_b(table[25][n]);
//output_high(pin_b0);
output_high(pin_b7);
delay_us(400); //160useg cada pixel horizontal
}
delay_us(700); //pausa entre digitost
output_b(0x81);
delay_us(700); //pausa entre digitos

;

}

void hora()
{
//output_high(pin_b0);
output_high(pin_b7);
caracter(h);
doispontos();
caracter(m);
doispontos();
caracter(s);
}

void data()
{
//output_high(pin_b0);
output_high(pin_b7);
caracter(dia);
barra();
caracter(mes);
barra();
caracter(ano);
}

/*void mensagem_desenho()
{
for (n=0;n<5;n++) { //vamos preparar tabela primeiro digito
output_b(table[33][n]);
delay_us(700); //160useg cada pixel horizontal
}
delay_us(700); //pausa entre digitost
output_b(0x00);
delay_us(700); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[36][n]); //com as mesmas unidades
delay_us(800);
}
delay_us(700); //pausa entre digitos
output_b(0x00);
delay_us(700); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[37][n]); //com as mesmas unidades
delay_us(700);
}
delay_us(700); //pausa entre digitos
output_b(0x00);
delay_us(700); //pausa entre digitos

for (n=0;n<5;n++) { //vamos preparar tabela primeiro digito
output_b(table[37][n]);
delay_us(700); //160useg cada pixel horizontal
}
delay_us(700); //pausa entre digitost
output_b(0x00);
delay_us(700); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[34][n]); //mesma unidad
delay_us(700);
}
delay_us(700); //pausa entre digitos
output_b(0x00);
delay_us(700); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[37][n]); //mesma unidades
delay_us(700);
}
delay_us(700); //pausa entre digitos
output_b(0x00);
delay_us(700); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[37][n]); //mesma unidades
delay_us(700);
}
delay_us(700); //pausa entre digitos
output_b(0x00);
delay_us(700); //pausa entre digitos
}*/

void mensagem_tarde()
{
delay_us(900); //pausa entre digitost
output_b(0x81);
delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) { //preparando pra mim digito
output_b(table[15][n]);
delay_us(900); //160useg cada pixel horizontal
}
delay_us(900); //pausa entre digitost
output_b(0x81);
delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[16][n]); //mesmo uni
delay_us(900);
}
delay_us(900); //pausa entre digitos
output_b(0x81);
delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[14][n]); //
delay_us(900);
}
delay_us(900); //pausa entre digitos
output_b(0x81);
delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[12][n]); //
delay_us(1000);
}
delay_us(900); //pausa entre digitos
output_b(0x81);
delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[13][n]); //
delay_us(1000);
}
delay_us(900); //pausa entre digitos
output_b(0x81);
delay_us(900); //pausa entre digitos
}

/*void mensagem_bom()
{

delay_us(6000); //pausa entre digitost
output_b(0xff);
delay_us(6000); //pausa entre digitos
for (n=0;n<5;n++) { //
output_b(table[13][n]);
delay_us(1500); //160useg cada pixel horizontal
}
delay_us(1500); //pausa entre digitost
output_b(0xff);
delay_us(1500); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[15][n]); //
}
delay_us(1500); //pausa entre digitos
output_b(0xff);
delay_us(1500); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[23][n]); //
delay_us(1500);
}
delay_us(1500); //pausa entre digitos
output_b(0xff);
delay_us(1500); //pausa entre digitos
}
/*void mensagem_dia(){

delay_us(6000); //pausa entre digitost
output_b(0xff);
delay_us(6000); //pausa entre digitos
for (n=0;n<5;n++) {
output_b(table[34][n]); //
delay_us(1500);
}
delay_us(1500); //pausa entre digitos
output_b(0xff);
delay_us(1500); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[14][n]); //
delay_us(1500);
}
delay_us(1500); //pausa entre digitos
output_b(0xff);
delay_us(1500); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[12][n]); //
delay_us(1500);
}
delay_us(1500); //pausa entre digitos
output_b(0xff);
delay_us(1500); //pausa entre digitos

}*/
void mensagem_boa ()
{
delay_us(900); //pausa entre digitost
output_b(0x81);

delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) { //
output_b(table[11][n]);
delay_us(900); //160useg cada pixel horizontal
}

delay_us(900); //pausa entre digitost
output_b(0x81);

delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[1][n]); //
delay_us(900);
}

delay_us(900); //pausa entre digitos
output_b(0x81);

delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[19][n]); //lo mismo con las unidades
delay_us(900);
}
delay_us(900); //pausa entre digitos
output_b(0x81);

delay_us(900); //pausa entre digitos

}

void mensagem_noite(){

output_low(pin_b7);
delay_us(900); //pausa entre digitost
output_b(0x81);
delay_us(900); //pausa entre digitos
for (n=0;n<5;n++) {
output_b(table[15][n]); //
delay_us(900);
}
delay_us(1000); //pausa entre digitos
output_b(0x81);
delay_us(1000); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[0][n]); //
delay_us(900);
}

delay_us(1000); //pausa entre digitos
output_b(0x81);
delay_us(1000); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[14][n]); //
delay_us(900);
}

delay_us(900); //pausa entre digitos
output_b(0x81);
delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[18][n]); //
delay_us(900);
}
delay_us(900); //pausa entre digitos
output_b(0x81);

delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[13][n]); //
delay_us(900);
}
delay_us(900); //pausa entre digitos
output_b(0x81);

delay_us(900); //pausa entre digitos
}

/*void pacman()
{
for (n=0;n<5;n++) { //
output_b(table[20][n]);
delay_us(1000); //160useg cada pixel horizontal
}
delay_us(1000); //pausa entre digitost
output_b(0x00);
delay_us(1000); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[20][n]); //
delay_us(1000);
}
delay_us(1500); //pausa entre digitos
output_b(0x00);
delay_us(1500); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[20][n]); //
delay_us(900);
}
delay_us(900); //pausa entre digitos
output_b(0x00);
delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) { //
output_b(table[20][n]);
delay_us(1500); //160useg cada pixel horizontal
}
delay_us(900); //pausa entre digitost
output_b(0x00);
delay_us(900); //pausa entre digitos

for (n=0;n<5;n++) {
output_b(table[20][n]); //
delay_us(900);
}
delay_us(900); //pausa entre digitos
output_b(0x00);
delay_us(900); //pausa entre digitos

}
*/

/*void Modo_sleep ()
{
if (input(dormir))
{
delay_ms(7000);
sleep();
s=q/2; //A variável Q incrementa a 2Hz, então os segundos
//devem ser a metade.
if (s==60) //Se for igual a 60, reset em Q e S. M incrementa.
{
q=0;
s=0;
m++;

}

if (m>59)
{
m=0;
h++;
}

if (h>23) //Se H(horas) for maior q 23, reset. DIA DA SEMANA
{ //e DIA DO MÊS incrementam.

h=0;
dia++;
}
if (dia>31)
{
mes++;
}
if (mes>12)
{
ano++;
}
}
}*/
void conta()
{
s=q/2; //A variável Q incrementa a 2Hz, então os segundos
//devem ser a metade.
if (s==60) //Se for igual a 60, reset em Q e S. M incrementa.
{
q=0;
s=0;
m++;

}

if (m>59)
{
m=0;
h++;
}

if (h>23) //Se H(horas) for maior q 23, reset. DIA DA SEMANA
{ //e DIA DO MÊS incrementam.

h=0;
dia++;
}
if (dia>31)
{
mes++;
}
if (mes>12)
{
ano++;
}
}
void main() { //bucle principal
sleep_mode=FALSE; // init sleep flag
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
setup_timer_1 (T1_INTERNAL | T1_DIV_BY_8); //Configurao do Timer1 para clock interno = 1E6 dividido por 8
set_timer1 (3036);
enable_interrupts(INT_TIMER1); //Habilita interrupo timer1
ext_int_edge(H_TO_L); // init interrupt triggering for button press
enable_interrupts(INT_EXT);
enable_interrupts(global);
//habilita interrupco global
set_tris_b(0);

a=0;

while (1) {

if(sleep_mode) // if sleep flag set
{
sleep(); // make processor sleep
}

// output_high(pin_b0);
//output_high(pin_b7);

if (!input(BOTAO1)) //Teste do boton.
{
delay_ms (300); //Para evitar retorno.
if (contador>2) //Se maior q 11, zera o contador.
{
contador=0;
}

contador++; //Incremento da varivel contador.
}

switch (contador) //Depois de incrementada, a varivel CONTADOR
{

//assume um dos casos a seguir:

case 1: //Menu de ajuste da HORA.
{
output_high(pin_b7);
//output_low(pin_b0);
if (!input (BOTAO_INCREMENTO)) //Incrementa a varivel H(hora).
{
delay_ms (500);
h++;

if (h>23) //Se a hora for maior que 23, reset.
{
h=0;
}
}

/* if (!input (BOTAO_DECREMENTO)) //Decrementa a varivel H(hora).
{
delay_ms (300);
h--;

if (h==255) //H uma varivel inteira de 8 bits.
{ //Quando decrementada para um valor
h=23; //menor que zero, se torna 255. Ou seja,
} //deve voltar para 23.
}*/

q=0; //Quando se est em algum menu, Q resetada. //Mantenha na tela.
tempo=0;
break;
}

case 2: //Menu de ajuste do MINUTO. Idem ao anterior.
{
// output_high(pin_b0);
output_low(pin_b7);

if (!input (BOTAO_INCREMENTO))
{
delay_ms (500);
m++;

if (m>59) //Diferente aqui.
{
m=0;
}
}

/* if (!input (BOTAO_DECREMENTO))
{
delay_ms (300);
m--;

if (m==255) //Igual aqui.
{
m=59;
}
}*/

q=0;
tempo=0;
//output_low(pin_b0);
output_low(pin_b7);
break;
}

default: //Menu principal. Mostra todas as informações.
{
conta();

while(input(sensor)) { //so dispara os leds se pinoa3 =1
//output_high(pin_b0);
output_high(pin_b7);

if((j >= 0 )&&( j <=40)){
//output_high(pin_b0);
output_high(pin_b7);

hora();
}
if ((j>=41) &&( j<=55)) {
//output_high(pin_b0);
output_high(pin_b7);

data();
}
/*if ((j>=56) && (j<=65))
{
mensagem_noite();
}*/
}
}
}
}
}
#include <16f627A.h>