ATNEL tech-forum

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-13T21:27:47+01:00

Niestety nie działa Twój sposób.
Ponieważ to jest w zasadzie osobny temat dlatego pozwoliłem sobie założyć nowy temat, a ten będzie o Timerach.

Statystyki: Napisane przez iwi — 13 lis 2013, o 21:27

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-13T11:14:26+01:00

ja bym to zrobił tak

[syntax=c]#include
uint16_t EEMEM kWh;
/* PROGRAM GŁÓWNY*/

int main( void )
{
//Deklaracja zmiennej kWh_stan w kilowatogodzinach, a zmienna Moc jest w Watosekundach
uint16_t kWh_stan;
kWh_stan = eeprom_read_byte(&kWh);
if (Moc >= 3600000) { //1 [kWh] = 3600000 [Ws]
// kWh_stan = kWh_stan++ ; //dodaj jedną kilowatogodzinę do RAM
eeprom_write_byte (&kWh, kWh_stan++); // zapis do eeprom
Moc = 0 ; //wyzeruj licznik Watosekund[/syntax]

Statystyki: Napisane przez Mipsa — 13 lis 2013, o 11:14

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-13T10:27:16+01:00

Chyba znalazłem błąd - muszę jeszcze potestować
deklaracja zmiennej uiAddress powinna być z gwiazdką

uint16_t * uiAddress = 0x000;
oraz trzeba zmienić w pliku eeprom.h przy tych 2 funkcjach uint8_t na uint16_t

ale pytanie - czym różni się funkcja
eeprom_write_byte
od
eeprom_update_byte

Statystyki: Napisane przez iwi — 13 lis 2013, o 10:27

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-13T01:10:57+01:00

Nie da się - nic nie działa.

Ale są wbudowane funkcje i nie trzeba ich pisać
eeprom_write_byte (lub eeprom_write_float)
eeprom_read_byte (lub eeprom_read_float)

Jeśli gdzieś zadeklaruję
[syntax=c]//EEPROM
float uiAddress = 0; //próbowałem to 0 zamienić na coś innego ale bez rezultatu
uint16_t kWh_stan;
float EEMEM kWh_stan_ee;[/syntax]
to potem kompilator pozwala odczytać zmienną kWh_stan_ee
[syntax=c]//Wczytanie z pamieci EEPROM do zmiennej kWh_stan
kWh_stan = eeprom_read_float (&kWh_stan_ee);[/syntax]
i to wszystko jest przed pętlą główną i się kompiluje.

A w pętli jest zapis do EEPROMA[syntax=c]kWh_stan = kWh_stan + Moc/3600000 ;
kWh_stan_ee = kWh_stan;
eeprom_write_float (uiAddress, kWh_stan_ee); // zapis do eeprom
Moc = 0 ; //wyzeruj licznik Watosekund[/syntax]

a komunikat pojawia się taki: error: incompatible type for argument 1 of '__eewr_float_m8'
.... note: expected 'float *' but argument is of type 'float'

próbowałem dać uint8_t ale to nie ma znaczenia - tak czy siak nie działa

a nawet zamieniając funkcje na read_byte zamiast read_float to w ogóle nie kompiluje się ani zapis ani odczyt, a na flot przynajmniej odczyt działa.

Oczywiście nie jest mi potrzebna zmienna float - uint16_t wystarczy bo to jest 65000kWh

Statystyki: Napisane przez iwi — 13 lis 2013, o 01:10

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-12T14:06:24+01:00

o próbowałeś tak
[syntax=c]EEPROM_read(uiAddress,&kWh_stan);[/syntax]

Zapisujesz coś pod kWh_stan, odzytujesz &kWh_stan

Statystyki: Napisane przez Mipsa — 12 lis 2013, o 14:06

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-12T13:52:27+01:00

Przy przepisywanie popełniłem więcej błędów, ale już źródłowy kod jest poprawiony.
Tam oczywiście miałem uint16_t - kompilator by nie przeszedł.

to może zapis działa prawidłowo tylko odczyt nie do końca.

Odczyt zrobiłem tak.

kWh_stan1 = EEPROM_read(uiAddress);
i potem sprawdzam sobie na RS232 czy wyświetla prawidłowo - i niestety nie.

i potem przez RS232 wyświetlam co jest pod wartością zmiennej kWh_stan1 - i jest 0.

i mam jeszcze pytanie o uiAddress.
Pamięć wEEPROM Atmedze8 jest 512 bajtów. W każdym bajcie jest 8 bitów. Czyli mam razem do zapisania 4096 bitów.
Jeżeli zmienna jest 16 bitowa to zapisana jest w 2 bajtach pamięci.
Jak się odwołujemy do konkretnego bajta w przypadku zmiennych 8 bitowych a jak do 16 bitowych i większych.
Ten przykład z datasheetu określa uiAddress na EEAR - a jaki jeszcze może być?

Statystyki: Napisane przez iwi — 12 lis 2013, o 13:52

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-12T13:08:43+01:00

Tak na szybko to co widać w kodzie.
masz:
[syntax=c]//Deklaracja zmiennej kWh w kilowatogodzinach, a zmienna Moc jest w Watosekundach
uint16t kWh_stan;[/syntax]

a powinno być :
[syntax=c]//Deklaracja zmiennej kWh w kilowatogodzinach, a zmienna Moc jest w Watosekundach
uint16_t kWh_stan;[/syntax]

ja zapisuje i odczytuje tak np:

[syntax=c]uint16_t EEMEM kWh;

//=================================================PROGRAM GŁÓWNY=====================================================

int main(void)
{
uint16_t kWh_stan;
kWh_stan = eeprom_read_byte(&kWh);[/syntax]

Może to nie jest najlepszy sposób.
Ale ja również dopiero się uczę.

Statystyki: Napisane przez Mipsa — 12 lis 2013, o 13:08

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-12T13:54:06+01:00

Witajcie.
Zliczanie działa już ładnie. Ale występują 2 problemy.
Po dołączeniu tego kodu do zliczania Watosekund do całego programu pojawił się problem, że jak tutaj miałem już wyskalowane w sekundach (zostawiłem kwarc 10MHz na razie) to w nowym programie operacje wykonują się co 3sekundy.
ZNalazłem jeden delay_ms ustawiony na 1s i go usunałem i potem jeszcze raz wyskalowałem układ.
Pytanie teraz - jeśli będę dopisywał jakieś linijki kody to od nowa będę musiał skalować układ?

I drugie pytanie - jak przenieść zmienne do nieulotnej pamięci. zeby po resecie nie traciło się wyniku.
takie coś spłodziłem, ale coś nie działa. W RAMie działa prawidłowo, ale w EEPROmie nie bardzo.

[syntax=c]#include
void EEPROM_write( uiAddress, kWh_stan);
void EEPROM_read(uiAddress);
uint16_t uiAddress ;
...
//Deklaracja zmiennej kWh_stan w kilowatogodzinach, a zmienna Moc jest w Watosekundach
uint16_t kWh_stan;
if (Moc >= 3600000) { //1 [kWh] = 3600000 [Ws]
// kWh_stan = kWh_stan++ ; //dodaj jedną kilowatogodzinę do RAM
EEPROM_write (uiAddress, kWh_stan++); // zapis do eeprom
Moc = 0 ; //wyzeruj licznik Watosekund
}
....
//Funkcje Zapisu do EEPROM
void EEPROM_write( uiAddress, kWh_stan)
{
/* Wait for completion of previous write */
while(EECR & (1<;
/* Set up address and data registers */
EEAR = uiAddress;
EEDR = ucData;
/* Write logical one to EEMWE */
EECR |= (1</* Start eeprom write by setting EEWE */
EECR |= (1<}
// Odczyt z EEPROM
void EEPROM_read(uiAddress)
{
/* Wait for completion of previous write */
while(EECR & (1<;
/* Set up address register */
EEAR = uiAddress;
/* Start eeprom read by writing EERE */
EECR |= (1</* Return data from data register */
return EEDR;
}[/syntax]

Statystyki: Napisane przez iwi — 12 lis 2013, o 10:57

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-11T08:52:06+01:00

To są zmienne programowe. Nazywają się tylko Timer1 i Timer2. Równie dobrze mogą się nazwać APSIK1 i HAU2
Te nazwy (timer1 i 2 ) łatwiej zapamiętać i łatwiej posługiwać się nimi w kodzie, bo od razu wiadomo czym są.

Statystyki: Napisane przez acid3 — 11 lis 2013, o 08:52

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-10T23:08:34+01:00

Ale jeszcze dla wyjaśnienia Timera. Te zmienne odpowiadają timerowi 1 i 2 z kontrolera czy to są zupełnie inne zmienne i możemy ich tworzyć do woli ale pamiętając że działają z jednakową częstotliwością i prescalerem.
Czyli możemy ustawić Timer1=50 Timer2=100 (jak w naszym przypadku), Timer3 = 1000 itd. i ewentualnie powołać pierwszy timer sprzetowy 16bitowy z tak samo dowolną ilością zmiennych.

Statystyki: Napisane przez iwi — 10 lis 2013, o 23:08

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-10T19:50:05+01:00

iwi napisał(a):

Ale zastanawiam sie po co zmienna Timer1 bo nigdzie nie jest użyta.

Zawsze jak piszę sobie program z użyciem Timera to tworze sobie od razu 2 Timery gdybym później w kodzie go potrzebował... Ale spokojnie możesz sobie usunąć z pierwszej lini: Timer1, i na końcu jeszcze jest taki fragment:
[syntax=c]n = Timer1;
if (n) Timer1 = --n; /* 100Hz Timer1 */[/syntax]

on też jest nie potrzebny jeśli nie używasz Timera1

Quote:

Ale nie bardzo go zrozumialem dlatego zamiast !Timer2

To jest bardzo proste
w języku C można stworzyć taki warunek:
[syntax=c]if(zmienna){
//instrukcje
}[/syntax]
w tym przypadku instrukcje wykonają się jeśli zmienna będzie większa od 0

Natomiast w tym przypadku jest odwrotnie:
[syntax=c]if(!zmienna){
//instrukcje
}[/syntax]
instrukcje wykonają się gdy zmienna ma wartość 0

Rozumiesz????

Statystyki: Napisane przez programek — 10 lis 2013, o 19:50

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-10T17:31:56+01:00

Widzialem podobny kod co Mirek napisał. Ale nie bardzo go zrozumialem dlatego zamiast !Timer2 dalem warunek kiedy Timer równy 0. Ale zastanawiam sie po co zmienna Timer1 bo nigdzie nie jest użyta. Teraz widzę że to jest równoważny zapis

Statystyki: Napisane przez iwi — 10 lis 2013, o 17:31

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-10T08:42:07+01:00

[syntax=c]/*
* main.c
*
* Created on: 10-11-2013
* Author: programek
*/

#include
#include
#include

volatile uint8_t Timer1, Timer2; /* timery programowe 100Hz */

// Definicje inne
#define LED1 (1<
float Moc=0; // Moc w Watach
float napiecie=20; //napiecie w V
float natezenie=5; //natezenie w A

int main(void) {

/* Timer2 – inicjalizacja przerwania co 10ms */
TCCR2 |= (1<TCCR2 |= (1<OCR2 = F_CPU/1024UL/100UL; // przerwanie porównania co 10ms (100Hz)
TIMSK |= (1<
sei();/* włączamy globalne przerwania */

/* pętla nieskończona */
while(1) {

if (Moc > 1000){
DDRB |= LED1; //załączamy diodę LED jesli Moc przekroczy 1kWh
}

if( !Timer2 ) { /*Timer2 co 1000ms*/
Timer2 = 100;
Moc = Moc + (napiecie * natezenie);

}

} //koniec while

} //koniec main(void)

ISR( TIMER2_COMP_vect ) {
uint8_t n;

n = Timer1;
if (n) Timer1 = --n; /* 100Hz Timer1 */
n = Timer2;
if (n) Timer2 = --n; /* 100Hz Timer2 */
}[/syntax]

Powinno działać

Widzę że kolega mnie już wyprzedził

PS. Przeoczyłem że masz tu błąd:
[syntax=c]if (Timer2 = 0){[/syntax]
i napisałem kod od początku...

Statystyki: Napisane przez programek — 10 lis 2013, o 08:42

Re: Zliczanie zmiennej co określony czas Timer2

2013-11-10T08:31:01+01:00

iwi napisał(a):

if (Timer2 = 0){

tu masz zamiast warunku przypisanie wartości do Timer2

powinno być :

[syntax=c]if (Timer2 == 0){[/syntax]

------------------------ [ Dodano po: 11 minutach ]

A jeśli chodzi o kwarc i Timer2 i za jego pomocą chcesz "bardzo dokładnie" (znacz teoretycznie dokładniej niż 0,16%) to musisz zastosować jakiś kwarc "przyjazny" dla UART np. 11059200 , 14 745 600 , 18 432 000, it. i wtedy z obliczeń wyjdzie Ci "dokładnie" 1 sek.

PS. Cz któryś z kolegów posiadających częstotliwościomierz mógłby zrobić taki mały test kwarców jak Mirek zrobił przy DS3231 ...
Bardzo chętnie sam bym się dowiedział jak bardzo można liczyć na pomiar czasu za pomocą tych urządzeń.

Statystyki: Napisane przez acid3 — 10 lis 2013, o 08:31

Zliczanie zmiennej co określony czas Timer2

2013-11-10T02:30:46+01:00

Witajcie.
Nie mogę się uporać z problemem napisania programu, który co okreslony czas zliczałby mi Moc.
Napisałem coś takiego[syntax=c]/*
/* Atmega8A 8MHz
*/

#include
#include
#include

// timery programowe
volatile uint16_t Timer2;

// Definicje inne
#define LED1 (1<
float Moc=0; // Moc w Watach
float napiecie=20; //napiecie w V
float natezenie=5; //natezenie w A

int main(void) {

/* Timer2 – konfigurcajca Timera 8bit w trybie NORMAL */
TCCR2 |= (1< OCR2 = 78; // przerwanie porównania co 10ms (100Hz) troche niedokladnie bo powinno byc 78,125 ale przy tym zegarze nic sie nie da zrobic
TIMSK = (1<
sei();
while(1){
if (Moc > 1000){
DDRB |= LED1; //załączamy diodę LED jesli Moc przekroczy 1kWh
}
if (Timer2 = 0){
Moc = Moc + (napiecie * natezenie);
Timer2 = 100; //ustawiamy odliczanie
}
}
}
//*** przerwanie Timer2 CompareMatch
ISR(TIMER2_COMP_vect) {
uint16_t n;
n = Timer2;
if (n) Timer2 = --n;
}[/syntax]

Program co 1 sekundę powinien zwiększać zmienną Moc o 100W. A tutaj raz, że nie działa to jeszcze nie wiem jak poradzić sobie z tym ustawieniem 1 sekundy. Na pewno będę musiał dobrać kwarc bo widzę, że na tym prescalerze i f procesora niewiele da się ustawić, ale może są jakieś inne pomysły.
Ponieważ to jest tylkoczęść programu dlatego nie skorzystanie z Timera i zastosowanie delaya np na 100ms i odliczanie zmiennej Timer2 od 10 do 0 nie wchodzi w rachubę.

Statystyki: Napisane przez iwi — 10 lis 2013, o 02:30