ATNEL tech-forum

Re: Atmega328P Power Down - wybudzanie

2016-12-10T19:25:06+01:00

W aucie te 4mA to raczej nie problem nawet ze słabym akumulatorem, ale w przyszłości zapamiętam, zakupię i użyję Trochę niski prąd wyjściowy, ale jak do tego typu zastosowań powinien wystarczyć.

Statystyki: Napisane przez hopek — 10 gru 2016, o 19:25

Re: Atmega328P Power Down - wybudzanie

2016-12-10T19:17:03+01:00

hopek napisał(a):

podczas uśpienia 4mA z czego 2mA pobiera sam stabilizator 7805

Dlatego do takich zastosowań lepiej używać stabilizatorów z "Low Quiescent Current", np. LM2936-5.0. Podejrzewam, że taki układ przy obciążeniu (prądzie wyjściowym) np. 2mA nie zużyje więcej niż ok. 100uA.

Statystyki: Napisane przez andrews — 10 gru 2016, o 19:17

Re: Atmega328P Power Down - wybudzanie

2016-12-10T18:42:58+01:00

Witam i dziękuję za obszerne opisanie problemu, nie każdemu się chce w tych czasach to robić. Ja chyba muszę się nauczyć czytać ze zrozumieniem, albo do okulisty iść

Flaga PCINT8_flag jest używana do odczytu danych z RTC. Kod mam z poradników Mirka, tyle że Mirek używał tam przerwania INT0, ja ten pin miałem już zajęty więc skonfigurowałem i zamieniłem tylko przerwanie z INT0 na PCINT8 i zmieniłem dla czytelności nazwę flagi.

Usypianie teraz działa tak jak chciałem, więc i Pomógł się należy Pobór prądu w czasie pracy urządzenia to około 25mA a podczas uśpienia 4mA z czego 2mA pobiera sam stabilizator 7805, reszta to wyświetlacz OLED, pull-upy i dzielniki na PCB.

Statystyki: Napisane przez hopek — 10 gru 2016, o 18:42

Re: Atmega328P Power Down - wybudzanie

2016-12-10T15:33:34+01:00

Napisałem, że trudno precyzyjnie ocenić nie widząc całego kodu, ponieważ w przypadku przedstawienia tylko fragmentów:

nie wiadomo, z jakiego miejsca programu dany fragment pochodzi, a to może mieć kluczowe znaczenie
nie wiadomo, czy w pozostałej części kodu nie ma czegoś, co może spowodować nieprawidłowe działanie pokazanego fragmentu
jaka jest ogólna struktura/organizacja programu, ponieważ to też może mieć wpływ na prawidłowość działania przedstawionych fragmentów.

Nadal nie wszystko jest jasne. Przykładowo masz taką linijkę PCINT8_flag=1;, a nigdzie nie widzę deklaracji, co to jest PCINT8_flag i do czego tej zmiennej używasz...

...ale już to zostawmy, bo nie o to chodzi, żeby tutaj przedstawiać wszystkie moduły programu Teraz już lepiej widać, jak to wszystko jest zorganizowane.

Niestety nie dysponuję wystarczającą ilością czasu, aby szczegółowo przeanalizować cały kod, więc odniosę się tylko do usypiania, które jest tematem tego wątku.

Nadal zerowanie flagi przerwania PCINT8 (PCIF1) masz w nieodpowiednim miejscu. Tak jak wcześniej napisałem, powinno być przed włączeniem zezwolenia na przerwanie, czyli przed PCICR |= (1< , a nie przed wyłączeniem. Właściwie wygląda na to, że w Twoim przypadku nie trzeba tego robić, więc możesz spróbować to zerowanie flagi w ogóle pominąć. W każdym razie zerowanie w tym miejscu, w jakim jest w tej chwili, i tak nie spełni swojej roli.

Ustawienie bitu SE we funkcji sm_power_down() jest zbędne, a nawet niewskazane (ustawienie bitu SE jest realizowane przez makro sleep_mode() ). W pliku masz gotowe makro wygodniejsze w użyciu, które robi to, co Twoja funkcja, więc w miejscu wywołania funkcji sm_power_down() zrobiłbym tak:[syntax=c]//
// zamiast wywołania funkcji
// sm_power_down();
set_sleep_mode(SLEEP_MODE_PWR_DOWN);[/syntax]

To, o czym napisałem, to nie jakieś błędy, które mogą powodować nieprawidłowe działanie. To tylko takie moje uwagi. Ogólnie myślę, że w tej formie usypianie i wybudzanie powinno działać prawidłowo. Reszty szczegółowo nie analizowałem, więc się nie wypowiadam, choć być może też znalazłoby się kilka uwag. Myślę, że powinieneś po prostu solidnie przetestować i w razie problemów zawsze można spróbować poprawić lub pytać na forum.
Statystyki: Napisane przez andrews — 10 gru 2016, o 15:33

Re: Atmega328P Power Down - wybudzanie

2016-12-09T22:59:50+01:00
Zamieszczam pełny kod i uprzedzam że "miszczem" nie jestem co chyba widać
To na razie faza początkowa, jeszcze dużo jest do zrobienia...
main.c
[syntax=c]/*

*
* Created on: 2016-12-07
* Autor: hopek
*/
#include
#include
#include
#include
#include
#include

#include "FUNC/func.h"
#include "ENCODER/mkencoder.h"
#include "1Wire/ds18x20.h"
#include "LCD/lcd44780.h"
#include "RTC/rtc.h"

#define INT_RTC_DOWN !(PINC & INT_RTC)
#define ACC_ON!(PINB & ACC_PIN)
#define ACC_OFF(PINB & ACC_PIN)

#define VSS_PIN (1<#define INT_RTC (1<#define ACC_PIN(1<
volatile uint8_t power_var;
uint8_t enable_enc=1;
uint8_t i_var, i2_var;
uint8_t test;//zmienna do testów
uint8_t show_clock;
volatile uint8_t sec_cnt;
volatile uint8_t halfsec_var;
volatile uint8_t timer_off_var;

uint16_t ADC1_meas;
uint16_t ADC7_meas;
uint32_t napiecie;
uint32_t srednia_u;
uint8_t dt2=1;
char cz_d [3];
char cz_u [3];

uint16_t stala_drogi=509;
volatile uint32_t trip;
volatile uint16_t cnt;
uint8_t spd;

uint16_t startups;

int8_t screen;
int8_t screen_tmp;
uint8_t menu;

uint16_t setki_m;
uint16_t kilo_m;

volatile uint8_t lcd_flag;
volatile uint16_t Timer1, timer2;

volatile uint8_t czujniki_cnt;/* ilość czujników na magistrali */
volatile uint8_t s1_flag;/* flaga tyknięcia timera co 1 sekundę */

uint8_t subzero, cel, cel_fract_bits;
uint16_t pomiar (uint8_t kanal);

void enkoderek (void);

int main(void)
{
//podciągnięcie portu do vcc
DDRD &= ~VSS_PIN;
PORTD |= VSS_PIN;

DDRC &= ~INT_RTC;
PORTC |= INT_RTC;

DDRB &= ~ACC_PIN;

_delay_ms(100);
lcd_init();
_delay_ms(100);

lcd_write_cmd(OLED_PWR_ON);//domyślne włączenie zasilania wyświetlacza

TIMER1_init();//inicjalizacja timera1 - przetwanie co 1503ms
PCINT_init();//inicjalizacja przerwań PCINT
INT0_F_init();//inicjalizacja przerwania zewnętrznego INT0 na zbocze opadające
rtc_init();//inicjalizacja zegara czasu rzeczywistego
mk_encoder_init();
ADC_init();
sm_power_down();

//definicje znaków
uint8_t l[] = {12,4,6,4,12,4,14,32};
lcd_defchar(0x80, l);

lcd_locate(0,2);
lcd_str_P(PSTR("ROVER"));
lcd_locate(1,3);
lcd_str_P(PSTR("214"));

_delay_ms(1000);
lcd_cls();

lcd_locate(0,2);
lcd_str_P(PSTR("TRIP"));
lcd_locate(1,2);
lcd_str_P(PSTR("COMP"));
_delay_ms(1000);
lcd_cls();

register_rtc_event_callback(display_datetime);
register_enc_event_callback( enkoderek );

czujniki_cnt = search_sensors();

/* wysyłamy rozkaz wykonania pomiaru temperatury
* do wszystkich czujników na magistrali 1Wire
* zakładając, że zasilane są w trybie NORMAL,
* gdyby był to tryb Parasite, należałoby użyć
* jako pierwszego prarametru DS18X20_POWER_PARASITE */
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );

//set_rtc_datetime( &datetime, 2016, 12, 7, 0,58,0);

//if(ACC_OFF)
//{
//cld();
//i_var=0;
//lcd_write_cmd(OLED_PWR_OFF);//wyłączamy zasilanie przetwornicy OLED
//sleep_mode();
//sleep_cpu();
//}

sei();

while(1)
{

RTC_EVENT();//zdarzenie RTC
ENCODER_EVENT();//zdarzenie enkodera

//obliczenia przebytej drogi
setki_m=(trip/stala_drogi)%10;
kilo_m=(trip/stala_drogi)/10;

//pomiary ADC
ADC1_meas=pomiar(1);
ADC7_meas=pomiar(7);

//uśrednianie pomiaru napięcia zasilania
srednia_u = srednia_u * dt2;
srednia_u = srednia_u + ADC1_meas;
srednia_u = srednia_u / (dt2+1);

napiecie = (srednia_u * 3050UL) /1023UL;
div_t divmod = div (napiecie, 100);
itoa (divmod.quot, cz_d, 10);
itoa ((divmod.rem /10), cz_u, 10);
if (divmod.rem < 10)
{
cz_u[0]='0';
}

//zakresy ekranów
if(screen>4) screen=0;
if(screen==-1) screen=4;

if(screen==0) show_clock=1;//gdy ekran = 0 pokazuj datę i czas
else show_clock=0;

//gdy zapłon włączony
if(ACC_ON)
{
i2_var=0;//zmienna potrzebna do jednorazowego wykonania instrukcji w warunkach
if(!i_var)
{
screen=0;//przeskocz do pierwszego ekranu
lcd_flag=1;
enable_enc=1;//włącz obsługę enkodera
PCICR |= (1<lcd_write_cmd(OLED_PWR_ON);//włącz przetwornicę wyświetlacza
i_var++;
}
}

//gdy zapłon wyłączony
if(ACC_OFF)
{
if(!i2_var)
{
timer_off_var=10;//ustaw jednorazowo timer wyłączenia na 10 sekund
i2_var++;
}

switch(timer_off_var)
{

//jeśli timer jest równy 0 to uśpij urządzenie
case 0:
cld();//czyść wyświetlacz
i_var=0;//zeruj zmienną
lcd_write_cmd(OLED_PWR_OFF);//wyłączamy zasilanie przetwornicy OLED
PCIFR = (1<PCICR &= ~(1<
sleep_mode();//wchodzi w tryb power down
break;

case 2:
//wiadomość o trybie ekonomicznym
if(lcd_flag)
{
lcd_locate(0,0);
lcd_str_P(PSTR(" TRYB "));
lcd_locate(1,0);
lcd_str_P(PSTR(" EKONOM "));
lcd_flag=0;
}
break;

case 3:
enable_enc=0;//wyłącz enkoder
if(lcd_flag)
{
cld();//czyść ekran
screen=-2;//przeskocz na pusty ekran
lcd_flag=0;//zeruj flagę wyświetlania na LCD
}
break;
}
}

lcd_char_set(screen);//automatyczna podmiana własnych znaków na LCD
if(!menu)
{
switch(screen)
{

case -2://pusty ekran
break;

case -1://pusty ekran - granica zakresu poruszania się po ekranach
break;

case 0://data i czas
if(lcd_flag)
{
lcd_locate(0,5);
if(halfsec_var) lcd_str_P(PSTR(":"));
else lcd_str_P(PSTR(" "));
show_clock=1;
lcd_flag=0;
}
break;

case 1://paliwo
if(lcd_flag)
{
lcd_locate(0,0);
lcd_str_P(PSTR("\x80" "\x81" "\x82" "\x83"));
lcd_locate(1,0);
lcd_str_P(PSTR("\x84" "\x85" "\x86" "\x87"));
//lcd_locate(0,0);
//lcd_int(timer_off_var);

lcd_flag=0;
}

break;

case 2://temperatury
if(lcd_flag)
{
lcd_locate(0,0);
lcd_str_P(PSTR("\x80" "\x81" "\x82"));
lcd_str(" 24");
lcd_locate(0,6);
lcd_str_P(PSTR("\x83"));
lcd_str_P(PSTR("c"));

lcd_locate(1,0);
lcd_str_P(PSTR("\x84" "\x85" "\x86"));
lcd_str(" -1");
lcd_locate(1,6);
lcd_str_P(PSTR("\x83"));
lcd_str_P(PSTR("c"));
lcd_flag=0;
}

break;

case 3://zasilanie
if(lcd_flag)
{
lcd_locate(1,0);
lcd_str_P(PSTR("\x80" "\x81"));

lcd_locate(1,3);
lcd_str(cz_d);
lcd_char('.');
lcd_str(cz_u);
lcd_str_P(PSTR("V "));

lcd_flag=0;
}
break;

case 4://trip
if(lcd_flag)
{
//zmienna pomocnicza do justowania wyniku
static uint8_t spd_y_var;
static uint8_t km_y_var;

//definicje znaków
uint8_t km[] = {20,20,24,20,32,27,21,17};
lcd_defchar(0x80, km);

uint8_t h[] = {2,4,8,16,4,7,5,5};
lcd_defchar(0x81, h);

//justowanie prędkości do prawej
if(spd <= 9) spd_y_var=4;
else if((spd > 9) && (spd <= 99)) spd_y_var=3;
else if(spd > 99) spd_y_var=2;

//justowanie przebiegu TRIP do prawej
if(kilo_m <= 9) km_y_var=2;
else if((kilo_m > 9) && (kilo_m <= 99)) km_y_var=1;
else if(kilo_m > 99) km_y_var=0;

//wyświetlanie wartości prędkości i TRIP
lcd_locate(0,spd_y_var);
lcd_int(spd);
lcd_str_P(PSTR(" "));
lcd_locate(0,5);
lcd_str_P(PSTR(" \x80" "\x81"));

lcd_locate(1,km_y_var);
lcd_int(kilo_m);
lcd_str_P(PSTR("."));
lcd_int(setki_m);
lcd_str_P(PSTR(" km"));

//kasowanie cyfr przed wynikiem prędkości
lcd_locate(0,spd_y_var-1);
lcd_str_P(PSTR(" "));

lcd_locate(1,km_y_var-1);
lcd_str_P(PSTR(" "));

lcd_flag=0;
}
break;

}
}
}
}

void display_datetime (TDATETIME * dt)
{

if(show_clock)
{

//ikona zegara
lcd_locate(0,2);
lcd_str_P(PSTR("\x80"));

//czas
lcd_locate(0,3);
if(dt->hh <10) lcd_str("0");
lcd_int(dt->hh);

lcd_locate(0,6);
if(dt->mm <10) lcd_str("0");
lcd_int(dt->mm);

//lcd_str_P(PSTR(":"));
//
//lcd_locate(0,10);
//if(dt->ss <10) lcd_str("0");
//lcd_int(dt->ss);

//lcd_locate(1,1);
//lcd_str_P( &dni [dt->weekday * 4]);

//data
lcd_locate(1,0);
if(dt->DD <10) lcd_str("0");
lcd_int(dt->DD);

lcd_str_P(PSTR("/"));

lcd_locate(1,3);
if(dt->MM <10) lcd_str("0");
lcd_int(dt->MM);

lcd_str_P(PSTR("/"));

lcd_locate(1,6);
lcd_int(datetime.YY);

}
}

uint16_t pomiar (uint8_t kanal)
{

ADMUX = (ADMUX & 0xc0) | kanal;//włączenie pomiarów na kanale 7 i 1
ADCSRA |= (1<while ( ADCSRA & (1<return ADCW;

}

void enkoderek (void)
{
if(enable_enc)//gdy zmienna =1 pozwól na pracę enkodera
{
if(enco_dir == ENC_RIGHT )//gdy kierunek = prawo
{
screen++;//zmień ekran na następny
timer_off_var=30;//nabij licznik autowyłącznika
//(potrzebne gdy wyłączymy już stacyjkę a jeszcze przydało by się coś sprawdzić)
}
else timer_off_var=30, screen--;
cld();//czyść ekran przy każdym obrocie enkodera
PCINT8_flag=1;
lcd_flag=1;
}

}

//przerwanie INT0 na zbocze opadające
ISR(INT0_vect)
{
trip++;
cnt++;
}

ISR(TIMER1_COMPB_vect)
{
uint16_t n=0, n1=0;
static uint8_t licznik;

n = Timer1;
if (n) Timer1 = --n;

n1 = timer2;
if (n1) timer2 = --n1;

if(++licznik<4)
{
spd=cnt/2;
cnt=0;
licznik=0;
}
}

//przerwanie co pół sekundy z RTC
ISR(PCINT1_vect)
{
static uint8_t i,n;

//licznik sekund
if(sec_cnt>59) sec_cnt=0;

halfsec_var=++i%2;//zmienna pomocnicza do migania separatorem zegara

//wykrywamy stan niski na pinie PC0 (PCINT8)
if(INT_RTC_DOWN)
{
s1_flag=1;//ustaw flagę
sec_cnt++;//zwiększ wartość (czasomierz ogólny + pomiar DS18B20)
PCINT8_flag = 1;//ustaw flagę (RTC)

//odliczanie timera do zera
n = timer_off_var;
if(n) timer_off_var --;
}

//zmienna globalna pozwalająca na uaktualnienie danych na wyświetlaczu
lcd_flag=1;

}

//puste przerwanie ;)
ISR(PCINT0_vect)
{
//może coś tu wstawię

}[/syntax]

func.c
[syntax=c]/*
* func.c
*
* Created on: &{date}
* Author: Michał Koptas
*/

#include
#include
#include
#include

#include "../I2C_TWI/i2c_twi.h"
#include "../FUNC/func.h"
#include "../LCD/lcd44780.h"
#include "../RTC/rtc.h"

// inicjalizacja ustawień fabrycznych w pamięci Flash
const TCFG pgm_cfg PROGMEM =
{

};

TCFG eem_cfg EEMEM;// dane w pamięci EEPROM
TCFG ram_cfg;// dane w pamięci RAM

void TIMER1_init(void)
{
//ustawienia timer1 - przerwanie co 1503ms
TCCR1B |= (1<TCCR1B |= (1<ICR1 =16220;//rejestr porównaniaa
TIMSK1 |=(1<}
void INT0_F_init(void)
{

EICRA |= (ISC01)|(1<EIMSK |= (1<}

void PCINT_init(void)
{
PCICR |= (1<PCMSK1 |= (1<PCMSK0 |= (1<}

void display_temp(uint8_t x)
{
lcd_locate(0,x);
if(subzero) lcd_str("-");/* jeśli subzero==1 wyświetla znak minus (temp. ujemna) */
else lcd_str(" ");/* jeśli subzero==0 wyświetl spację zamiast znaku minus (temp. dodatnia) */
lcd_int(cel);/* wyświetl dziesiętne części temperatury */
lcd_str("c"); /* wyświetl znak jednostek (C - stopnie Celsiusza) */
}

void sm_power_down (void)
{
SMCR |= (1<SMCR |= (1<}

void ADC_init (void)
{
ADMUX |= (1<ADCSRA |= (1<}

void copy_eem_to_ram( void )
{
eeprom_read_block( &ram_cfg, &eem_cfg, sizeof(ram_cfg) );
}

void copy_ram_to_eem( void )
{
eeprom_write_block( &ram_cfg, &eem_cfg, sizeof(ram_cfg) );
}

void copy_pgm_to_ram( void )
{
memcpy_P( &ram_cfg, &pgm_cfg, sizeof(ram_cfg) );
}

void check_and_load_defaults( void )
{
uint8_t i, len = sizeof( ram_cfg );
uint8_t * ram_wsk = (uint8_t*)&ram_cfg;

copy_eem_to_ram();
for(i=0; i{
if( 0xff == *ram_wsk++ ) continue;
break;
}

if( i == len ) {
load_defaults();
}

}

void load_defaults( void )
{
copy_pgm_to_ram();
copy_ram_to_eem();
}

void cld (void)//czyszczenie wyświetlacza
{
lcd_locate(0,0);
lcd_str_P(PSTR(" "));
lcd_locate(1,0);
lcd_str_P(PSTR(" "));
}

//funkcja podmieniająca znaki na wyświetlaczu
void lcd_char_set (int8_t var)
{
switch(var)
{
case 0:
if (lcd_flag)
{
uint8_t Zegar[] = {32,32,14,21,29,17,14,32};
lcd_defchar(0x80, Zegar);
}
break;

case 1:
if(lcd_flag)
{
uint8_t A[] = {32,32,32,32,32,15,15,15};
lcd_defchar(0x80, A);
uint8_t RB[] = {32,32,32,16,24,28,30,31};
lcd_defchar(0x81, RB);
uint8_t RC[] = {32,15,8,8,8,8,15,15};
lcd_defchar(0x82, RC);
uint8_t RD[] = {32,24,12,12,12,10,25,29};
lcd_defchar(0x83, RD);
uint8_t RE[] = {15,15,15,32,32,32,32,32};
lcd_defchar(0x84, RE);
uint8_t RF[] = {31,30,28,24,16,32,32,32};
lcd_defchar(0x85, RF);
uint8_t RG[] = {15,15,15,15,15,15,15,32};
lcd_defchar(0x86, RG);
uint8_t RH[] = {29,29,29,26,24,24,24,32};
lcd_defchar(0x87, RH);
}
break;

case 2:
if(lcd_flag)
{

//IKONKA CHMURKI
uint8_t TA[] = {32,32,1,2,4,8,16,15};
lcd_defchar(0x80, TA);
uint8_t TB[] = {32,12,18,1,2,4,32,31};
lcd_defchar(0x81, TB);
uint8_t TC[] = {32,32,32,16,12,2,1,30};
lcd_defchar(0x82, TC);

//ZNAK STOPNI
uint8_t TD[] = {2,5,2,32,32,32,32,32};
lcd_defchar(0x83, TD);

//IKONKA AUTA
uint8_t TE[] = {32,32,32,32,15,16,16,9};
lcd_defchar(0x84, TE);
uint8_t TF[] = {32,7,8,16,32,32,32,31};
lcd_defchar(0x85, TF);
uint8_t TG[] = {32,24,4,2,1,1,1,18};
lcd_defchar(0x86, TG);
}
break;

case 3:
if (lcd_flag)
{
uint8_t ZA[] = {12,31,16,20,30,20,16,31};
lcd_defchar(0x80, ZA);

uint8_t ZB[] = {6,31,1,1,15,1,1,31};
lcd_defchar(0x81, ZB);
}
break;
}
}[/syntax]

func.h
[syntax=c]/*
* func.h
*
* Created on: 29 lis 2016
* Author: hopek
*/

#ifndef FUNC_FUNC_H_
#define FUNC_FUNC_H_

#include
#include

void TIMER1_init(void);
void INT0_F_init(void);
void PCINT_init(void);
void sm_power_down (void);
void ADC_init (void);

extern volatile uint8_t lcd_flag;

extern volatile uint8_t czujniki_cnt;/* ilość czujników na magistrali */
extern volatile uint8_t s1_flag;/* flaga tyknięcia timera co 1 sekundę */
extern volatile uint8_t sekundy;/* licznik sekund 0-59 */
extern uint8_t subzero, cel, cel_fract_bits;

typedef struct {

uint16_t vss_div;//dzielnik ilości impulsów
uint16_t oil_change;//licznik wymiany oleju
uint16_t startups;//licznik uruchomien silnika
int8_t screen;//ostatni ekran

} TCFG;

extern const TCFG pgm_cfg PROGMEM;// dane w pamięci FLASH
extern TCFG eem_cfg EEMEM;// dane w pamięci EEPROM
extern TCFG ram_cfg;//dane w pamięci RAM

void display_temp(uint8_t x);

void check_and_load_defaults( void );// sprawdza i ładuje ustawienia domyślne
void copy_eem_to_ram( void );// kopiuje ustawienia
void copy_ram_to_eem( void );// kopiuje ustawienia
void copy_pgm_to_ram( void );// kopiuje ustawienia
void load_defaults( void );// ładuje ustawienia domyślne
void cld (void);

void lcd_char_set (int8_t var);

#endif /* FUNC_FUNC_H_ */[/syntax]
Statystyki: Napisane przez hopek — 9 gru 2016, o 22:59

Re: Atmega328P Power Down - wybudzanie

2016-12-09T22:04:00+01:00
Trudno precyzyjnie ocenić nie widząc całego kodu.

Wydaje mi się, że akurat w Twoim przypadku to zerowanie flagi przerwania PCINT2 nie jest bardzo konieczne, ale skoro już jest, to powinno być raczej zaraz przed włączeniem zezwolenia na przerwanie, a nie zaraz po wyłączeniu zezwolenia.

Zamiast makra sleep_cpu() użyłbym raczej sleep_mode(), ponieważ to drugie włącza zezwolenie na uśpienie bezpośrednio przed uśpieniem i wyłącza zaraz po wybudzeniu. Nie jest to może konieczne, ale jest zalecane, tak "dobra praktyka".

Tyle mogę powiedzieć na podstawie kodu który przedstawiłeś. Musisz teraz po prostu dobrze całość przetestować i w przypadku zauważenia błędów wprowadzić ewentualne korekty.
Statystyki: Napisane przez andrews — 9 gru 2016, o 22:04

Re: Atmega328P Power Down - wybudzanie

2016-12-09T21:18:52+01:00
Więc tak, to jest taki dodatkowy gadżet zamiast fabrycznego zegarka w samochodzie rover 214. Upakowałem w oryginalnej obudowie wyświetlacz 2x8 znaków i jedną płytkę z atmegą. Będzie jeszcze druga mniejsza do reszty zaplanowanych rzeczy.
Na tą chwilę zmodyfikowałem kod i wygląda następująco:

[syntax=c]//gdy zapłon włączony
if(ACC_ON)
{
i2_var=0;
if(!i_var)
{
screen=0; //przeskocz do pierwszego ekranu
lcd_flag=1; //wstaw 1 do flagi wyświetlacza (aktualizacja)
enable_enc=1;//włącz obsługę enkodera
PCICR |= (1<lcd_write_cmd(OLED_PWR_ON);//włącz przetwornicę wyświetlacza
i_var++;
}
}

if(ACC_OFF)
{
if(!i2_var)
{
timer_off_var=10; //ustaw jednorazowo timer wyłączenia na 10 sekund
i2_var++;
}

switch(timer_off_var)
{

//jeśli timer jest równy 0 to uśpij urządzenie
case 0:
cld();//czyść wyświetlacz
i_var=0;//zeruj zmienną
lcd_write_cmd(OLED_PWR_OFF);//wyłączamy zasilanie przetwornicy OLED
PCICR &= ~(1< PCIFR = (1<sleep_cpu();//wchodzi w tryb power down
break;

case 2:
//wiadomość o trybie ekonomicznym
if(lcd_flag)
{
lcd_locate(0,0);
lcd_str_P(PSTR(" TRYB "));
lcd_locate(1,0);
lcd_str_P(PSTR(" EKONOM "));
lcd_flag=0;
}
break;

case 3:
enable_enc=0;//wyłącz enkoder
if(lcd_flag)
{
cld();//czyść ekran
screen=-2;//przeskocz na pusty ekran
lcd_flag=0;//zeruj flagę wyświetlania na LCD
}
break;
}
}[/syntax]

inicjalizacja przerwań PCINT:
[syntax=c]void PCINT_init(void)
{
PCICR |= (1<PCMSK1 |= (1<PCMSK0 |= (1<}[/syntax]

inicjalizacja trybu usypiania:
[syntax=c]void sm_power_down (void)
{
SMCR |= (1<SMCR |= (1<}[/syntax]

Procedurę przerwania PCINT2 zostawiłem pustą.
Nie wiem czy wszystko jest ok, ale wygląda na to że działa. Proszę o weryfikacje
Statystyki: Napisane przez hopek — 9 gru 2016, o 21:18

Re: Atmega328P Power Down - wybudzanie

2016-12-09T18:32:14+01:00
Po pierwsze, jak już wcześniej napisałem, nie można usypiać mikrokontrolera wewnątrz procedury obsługi przerwania, ponieważ jest wtedy wyłączona flaga globalnego zezwolenia na przerwania, więc nie uda się wybudzić mikrokontrolera. Z drugiej strony włączenie wewnątrz procedury globalnego zezwolenia na przerwania ( sei(); ) to w takiej sytuacji zdecydowanie zły pomysł.

Po drugie nie rób tak:[syntax=c]//
if(ACC_OFF) //sprawdzanie stanu na pinie PB2
{
sleep_mode();
sleep_cpu();
}[/syntax]
Rozwinięcie makra sleep_mode() to:[syntax=c]//
sleep_enable();
sleep_cpu();
sleep_disable();[/syntax]
W efekcie otrzymujesz więc:[syntax=c]//
if(ACC_OFF) //sprawdzanie stanu na pinie PB2
{
sleep_enable();
sleep_cpu();
// tutaj oczekiwanie w trybie uśpienia na wybudzenie
sleep_disable();
// tutaj ponownie próbujesz uśpić mikrokontroler
// wprawdzie makro sleep_disable() wyłączyło wcześniej
// zezwolenie na uśpienie (bit SE w rejestrze SMCR), więc
// operacja uśpienia się nie powiedzie, niemniej sleep_cpu()
// w tym miejscu nie ma sensu
sleep_cpu();
}[/syntax]

hopek napisał(a):

wybudzanie następowało samoczynnie zaraz po uśpieniu i podejrzewam że przez przerwanie od RTC na pinie PCINT8 co skutkowało wyświetleniem na ułamek sekundy treści na wyświetlaczu OLED.
Możesz przed uśpieniem mikrokontrolera wyłączyć zezwolenie na przerwanie od PCINT8, a po wybudzeniu włączyć ponownie. Przerwanie PCINT8 przypisane jest do wektora PCINT1_vect, więc:[syntax=c]//
// wyłączenie zezwolenia na przerwanie PCINT8
PCICR &= ~(1<
// zapewne co najmniej jedno przerwanie w czasie uśpienia wystąpi
// co spowoduje ustawienie flagi PCIF1 w rejestrze PCIFR
// aby nie pozwolić na niepotrzebne wejście w procedurę obsługi
// tego oczekującego przerwania, można najpierw wyzerować jego flagę
PCIFR = (1< // włączenie zezwolenia na przerwanie PCINT8
PCICR |= (1<
No a w procedurze obsługi przerwania od PCINT2 ( ISR(PCINT0_vect) ) modyfikuj tylko wartość jakiejś zadeklarowanej globalnie zmiennej (z atrybutem volatile), a dopiero w pętli głównej na podstawie wartości tej zmiennej usypiaj lub wybudzaj mikrokontroler.
Statystyki: Napisane przez andrews — 9 gru 2016, o 18:32

Re: Atmega328P Power Down - wybudzanie

2016-12-09T15:52:13+01:00

andrews napisał(a):

Nie bardzo to rozumiem. Jak sprawdzasz stan pinu w trybie uśpienia?

No jasne przecież to nie możliwe... Mój błąd, przepraszam.

To wybudzanie procesora poprzez sprawdzenie stanu pinu to jednak zakomentowałem tą część kodu żeby nie robić bałaganu bo to i tak nie działało ale do testu w osobnym przerwaniu PCINT2 umieściłem coś takiego:
[syntax=c]ISR (PCINT0_vect)
{
if(ACC_OFF) //sprawdzanie stanu na pinie PB2
{
sleep_mode();
sleep_cpu();
}

if(ACC_ON)
{
sleep_disable();
}
}[/syntax]

Ogólnie próbuję zaprogramować mikrokontroler tak, żeby był usypiany i wybudzany jednym pinem PCINT2 (PB2). Do tej pory robiłem to tak że sprawdzałem stan pinu PCINT2 i jeśli był stan niski to uruchamiałem timer który po 10 sekundach usypiał mi mikrokontroler, ale wybudzanie następowało samoczynnie zaraz po uśpieniu i podejrzewam że przez przerwanie od RTC na pinie PCINT8 co skutkowało wyświetleniem na ułamek sekundy treści na wyświetlaczu OLED. Kod zamieszczę później bo nie mam teraz przy sobie projektu.
Statystyki: Napisane przez hopek — 9 gru 2016, o 15:52

Re: Atmega328P Power Down - wybudzanie

2016-12-09T14:17:12+01:00

hopek napisał(a):

Więc tak odpaliłem sobie na PCINT2 osobne przerwanie i w środku sprawdzam sobie stan na pinie czy niski czy wysoki za pomocą makra i instrukcji sleep_mode(); i sleep_cpu(); gdy pin w stanie niskim usypiam procesor.

Jeśli usypiasz mikrokontroler wewnątrz procedury obsługi przerwania, to obawiam się, że już go nie wybudzisz, ponieważ flaga I w SREG jest wtedy wyłączona. Globalne zezwolenie na przerwania musi być włączone, aby wybudzić mikrokontroler z uśpienia.

hopek napisał(a):

wybudza procesor ale nie poprzez przerwanie tylko przez sprawdzenie stanu na pinie...

Nie bardzo to rozumiem. Jak sprawdzasz stan pinu w trybie uśpienia?

hopek napisał(a):

I chyba mam problem bo każde "zdarzenie" RTC wybudza na ułamek sekundy procesor.

Sprecyzuj jakiej funkcjonalności oczekujesz.

No i dobrze by było, gdybyś pokazał kod, jeśli to nie tajemnica.
Statystyki: Napisane przez andrews — 9 gru 2016, o 14:17

Re: Atmega328P Power Down - wybudzanie

2016-12-09T12:03:38+01:00
To chyba coś robię źle bo uśpić mogę ale wybudzić się już nie chce. Więc tak odpaliłem sobie na PCINT2 osobne przerwanie i w środku sprawdzam sobie stan na pinie czy niski czy wysoki za pomocą makra i instrukcji sleep_mode(); i sleep_cpu(); gdy pin w stanie niskim usypiam procesor. Chcąc wybudzić sprawdzam czy stan pinu wysoki i odpalam instrukcje sleep_disable();
Co w tym przypadku robię źle?
Statystyki: Napisane przez hopek — 9 gru 2016, o 12:03

Re: Atmega328P Power Down - wybudzanie

2016-12-09T11:02:20+01:00

hopek napisał(a):

Mam pytanie, czy jest możliwość wybudzenia procesora ze śpiączki za pomocą konkretnego przerwania PCINTX?

a dlaczego miałoby nie być jak jest ... nie rozumiem wręcz pytania - bo w nocie jest mowa o tym że można więc w czym problem ?
Statystyki: Napisane przez mirekk36 — 9 gru 2016, o 11:02

Re: Atmega328P Power Down - wybudzanie

2016-12-09T10:01:52+01:00
Cześć przejrzyj to może pomoże
https://sites.google.com/site/qeewiki/b ... -atmega328
Statystyki: Napisane przez gufim — 9 gru 2016, o 10:01

Atmega328P Power Down - wybudzanie

2016-12-09T09:40:30+01:00
Witam. Mam pytanie, czy jest możliwość wybudzenia procesora ze śpiączki za pomocą konkretnego przerwania PCINTX?
Na PCB mam podłączony RTC PCF8583. Odczytuję go przez I2C i przerwanie PCINT8. Z kolei pod PCINT2 mam podłączony transoptor który po podaniu sygnału na wejście wybudza procesor ale nie poprzez przerwanie tylko przez sprawdzenie stanu na pinie... I chyba mam problem bo każde "zdarzenie" RTC wybudza na ułamek sekundy procesor.
Czy jest na to jakieś rozwiązanie?
Statystyki: Napisane przez hopek — 9 gru 2016, o 09:40