ATNEL tech-forum 2013-11-14T17:34:35+01:00 https://forum.atnel.pl/feed.php?f=4&t=4782&mode 2013-11-14T17:34:35+01:00 2013-11-14T17:34:35+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56840#p56840 <![CDATA[Re: Zapis i odczyt z EEPROM]]>

Statystyki: Napisane przez Mipsa — 14 lis 2013, o 17:34

]]> 2013-11-14T16:53:20+01:00 2013-11-14T16:53:20+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56826#p56826 <![CDATA[Re: Zapis i odczyt z EEPROM]]> tzn po uruchomieniu pokazuje 65535kWh po 1kWh pokazuje 0 a dopiero po drugiej 1.

Ale &kurnachatka też ma rację. Po zaznaczeniu tej opcji "mój" program też działa z tym , że dałem jeszcze małego ifa
tzn
[syntax=c]if (!kWh_stan) {kWh_stan=0; }[/syntax]
Wiedziałem, że sprawa jest prosta, ale nie wiedziałem że aż tak.

Dzięki koledzy i koleżanki.

Statystyki: Napisane przez iwi — 14 lis 2013, o 16:53

]]> 2013-11-14T15:27:29+01:00 2013-11-14T15:27:29+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56805#p56805 <![CDATA[Re: Zapis i odczyt z EEPROM]]> zawsze możesz wgrać Eclipsikiem :)

Statystyki: Napisane przez Mipsa — 14 lis 2013, o 15:27

]]> 2013-11-14T15:03:21+01:00 2013-11-14T15:03:21+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56803#p56803 <![CDATA[Re: Zapis i odczyt z EEPROM]]> kurnachatka napisał(a):

Jak wgrywasz za pomocą Eclipsa to musi być włączona opcja "from build" przy eepromie w propertis w zakładce Flash/EEPROM.

może to będzie to - zaznaczona opcja była "do not upload eeprom image" i zmieniłem jak na rysunku.
Obrazek

Mipsa napisał(a):

W twoim programie nic nie zmieniałem oprócz zapisu i odczytu eeprom.

OK - myślałem, że to jest hex z tego pierwszego Twojego linka.

Statystyki: Napisane przez iwi — 14 lis 2013, o 15:03

]]> 2013-11-14T14:55:51+01:00 2013-11-14T14:55:51+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56800#p56800 <![CDATA[Re: Zapis i odczyt z EEPROM]]> Diody zostały tak jak masz. zaprogramowałem teraz i przykładowo PD7 sobie mruga ładnie co 1 sek. Na terminalu widać wszystko co wysyła uC.
Oczywiście taktowanie na 8Mhz

Statystyki: Napisane przez Mipsa — 14 lis 2013, o 14:55

]]> 2013-11-14T14:46:49+01:00 2013-11-14T14:46:49+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56799#p56799 <![CDATA[Re: Zapis i odczyt z EEPROM]]> Statystyki: Napisane przez kurnachatka — 14 lis 2013, o 14:46

]]> 2013-11-14T14:23:36+01:00 2013-11-14T14:23:36+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56797#p56797 <![CDATA[Re: Zapis i odczyt z EEPROM]]> W MKAVRCalculatorze zaznaczam flash - wybieram plik Twój
Zaznaczam EEPROM i tez wybieram plik.

Potem zakładka ZAPISZ z lewej strony i na dole ZAPISZ do uC.
i potem cisza. Nic się nie dzieje i nic nie wyświetla.

A wrzuć którąś diodę na PD7, PB0, PB1 lub PB2

i jeszcze czy częstotliwość masz ustawioną na 8MHz czy 1MHz.

Statystyki: Napisane przez iwi — 14 lis 2013, o 14:23

]]> 2013-11-14T01:32:07+01:00 2013-11-14T01:32:07+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56765#p56765 <![CDATA[Re: Zapis i odczyt z EEPROM]]> A u mnie na terminal wszystko ładnie leciało.

Statystyki: Napisane przez Mipsa — 14 lis 2013, o 01:32

]]> 2013-11-14T01:29:35+01:00 2013-11-14T01:29:35+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56764#p56764 <![CDATA[Re: Zapis i odczyt z EEPROM]]> Czy EEMEM ma stać za kWh_stan_ee czy za kWh_stan.
Bo zmienna to ta druga, a ta pierwsza to adres.
Wydawało się to proste, ale poświęciłem już na tego EEPROMa z 20godzin i nie działa jak potrzeba.

Idę dalej z programem nauki, a jego zostawię na koniec - może coś się dowiem ciekawego w międzyczasie.

i powyrzucam te moje litanie do osobnych funkcji bo pętla while już jest praktycznie niewidoczna.

Podeślij kod źródłowy a nie hexy

Statystyki: Napisane przez iwi — 14 lis 2013, o 01:29

]]> 2013-11-14T01:28:00+01:00 2013-11-14T01:28:00+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56763#p56763 <![CDATA[Re: Zapis i odczyt z EEPROM]]> Statystyki: Napisane przez Mipsa — 14 lis 2013, o 01:28

]]> 2013-11-14T01:26:15+01:00 2013-11-14T01:26:15+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56762#p56762 <![CDATA[Re: Zapis i odczyt z EEPROM]]>
ALe jeszcze jedna uwaga. NIe wiem co oznacza to resetowanie przez mkAVRCalculator, ale niestety działa po zliczeniu pierwszej kWh. czyli muszę odczekać parę godzin, żeby zresetować.

Statystyki: Napisane przez iwi — 14 lis 2013, o 01:26

]]> 2013-11-14T01:22:48+01:00 2013-11-14T01:22:48+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56761#p56761 <![CDATA[Re: Zapis i odczyt z EEPROM]]>
Dodałem odpowiednie biblioteki;)

Statystyki: Napisane przez Mipsa — 14 lis 2013, o 01:22

]]> 2013-11-14T01:12:42+01:00 2013-11-14T01:12:42+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56760#p56760 <![CDATA[Re: Zapis i odczyt z EEPROM]]>
zaprogramowałem układ Twoim wsadem, ale nic się nie dzieje. Nie mam wyświetlacza żeby móc odczytać - tylko terminal. A w tym hexie nie ma biblioteki więc sam wsad niewiele daje

Statystyki: Napisane przez iwi — 14 lis 2013, o 01:12

]]> 2013-11-14T01:08:41+01:00 2013-11-14T01:08:41+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56759#p56759 <![CDATA[Re: Zapis i odczyt z EEPROM]]> Ja wykonałem zapis i odczyt . Tak jak wcześniej Ci to opisywałem w drugim temacie.

Statystyki: Napisane przez Mipsa — 14 lis 2013, o 01:08

]]> 2013-11-14T01:11:01+01:00 2013-11-14T00:01:10+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56758#p56758 <![CDATA[Re: Zapis i odczyt z EEPROM]]>
NIe wiem co prawda dlaczego, ale jakoś działa - już tłumacze.

Po zaprogramowaniu uC robiłem reset przez odłączenie zasilania i za każdym razem program startował od 255 w górę zliczając kWh. Tak to testowałem i dlatego nigdy nie działało.

A zadziałało jak nie odłączając uC uruchomiłem mkAVR Calculator i dałem odczyt danych.
Po odczycie resetował się układ i zlicza już poprawnie od zera a nie od 255. Jak się teraz odłączy zasilanie to będzie kontynuował zliczanie ale od wartości mniejszej o 1 - tak jakby ostatni zapis odbywał się tylko na ekranie, bo teraz każdorazowy reset nie powoduje cofnięcia się licznika, ale po ponownym zaprogramowaniu znowu trzeba odpalić mkAVRCalculator i odczytać układ.

O co w tym chodzi? Nic nie programuje w tym programie tylko robię odczyt.

Statystyki: Napisane przez iwi — 14 lis 2013, o 00:01

]]> 2013-11-13T21:33:26+01:00 2013-11-13T21:33:26+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56744#p56744 <![CDATA[Re: Zapis i odczyt z EEPROM]]>
http://mirekk36.blogspot.com/2012/11/av ... iazek.html

Statystyki: Napisane przez mirekk36 — 13 lis 2013, o 21:33

]]> 2013-11-13T21:18:57+01:00 2013-11-13T21:18:57+01:00 https://forum.atnel.pl/viewtopic.php?t=4782&p=56740#p56740 <![CDATA[Zapis i odczyt z EEPROM]]> Mimo czystego przykładu wciąż nie mogę nic zapisać do EEPROM.
Przykłady są łatwe i czytelnie opisane - ale mimo to jedne działają a inne nie - czyli to nie taka prosta rzecz. Np. http://hobby.abxyz.bplaced.net/index.php?pid=8&tid=54
jest napisane, że z EEPROMA korzystamy w ten sposób
[syntax=c]uint8_t eadres;
uint8_t edata;
eeprom_write_byte((uint8_t*)eadres,edata);
edata=eeprom_read_byte((uint8_t*)eadres);[/syntax]

lub ten sposób
[syntax=c]uint8_t *eadres;
uint8_t edata;
eeprom_write_byte(eadres,edata);
edata=eeprom_read_byte(eadres);[/syntax]
ten pierwszy przypadek mi się nie kompiluje, ale drugi jak najbardziej:
i mam zrobione w taki sposób:
[syntax=c]//EEPROM
uint16_t kWh_stan = 0;
uint16_t *uiAddress;

//Wczytanie z pamieci EEPROM
kWh_stan = eeprom_read_byte (uiAddress);

kWh_stan = kWh_stan+1 ;
cli();
eeprom_write_byte (uiAddress, kWh_stan); // zapis do eeprom
sei();[/syntax]

i co ciekawe pod zmienną kWh_stan jest dziesiętnie liczba 255.

Za pierwszym razem zadeklarowałem zmienną
[syntax=c]uint16_t kWh_stan EEMEM = 0x00;[/syntax], żeby zmienić jej wartość z FF na 00. Ale po takiej operacji zamiast 0 odczytuje z EEPROM dziesiętnie 128.

a jeszcze na takiej stronie http://www.if.pw.edu.pl/~agatka/psm/wyklad_02.pdf
jest zapisywanie i odczytywanie tak zrobione:

[syntax=c]uint8_t zmienna EEMEM = 128;
uint8_t wartosc = eeprom_read_byte(&zmienna);
eeprom_write_byte(&zmienna, wartosc);[/syntax]
i też nie działa.

A może działa tylko jest błąd w kodzie?

cały projekt wygląda tak:
[syntax=c]/*
* main.c
* Atmega 8A 8MHz
*/
// Podpinamy biblioteki

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <stdlib.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>

// Podpinamy własne biblioteki
#include "MYUART/myuart.h"
#include "MK_TERMINAL/mk_term.h"

//Włączamy przetowrnik ADC na wszystkich kanałach
inline void set_chanel( uint8_t kanal ) {
ADMUX = (ADMUX & 0b11111000) | kanal;
}

// timery programowe
volatile uint16_t Timer1, Timer2;

//Ustalenie ilosci pomiarow do usrednienia. Czym wiecej tym wolniejsze zmiany liczby tylko 1,2,4,8,16
#define SR1 16
#define SR2 16
#define SR3 16
#define SR4 16
#define SR5 16
#define SR6 16


//Definiujemy strukturę
typedef struct {
uint8_t idx;
uint16_t adc_mid;
uint16_t ref_adc;
uint16_t ref_v;
char v1[3];
char v2[3];
} TVOL;

TVOL nap1, nap2, nap3, nap4, nap5, nap6; // nasze główne zmienne

double Moc;
uint8_t bieg=1;
uint8_t Nap=0;

uint16_t asr1[SR1];
uint16_t asr2[SR2];
uint16_t asr3[SR3];
uint16_t asr4[SR4];
uint16_t asr5[SR5];
uint16_t asr6[SR6];

volatile uint16_t wynik;

//EEPROM
uint16_t kWh_stan EEMEM = 0x00;
uint16_t *uiAddress;


uint16_t vtab[6]; //Ustalenie ilosci zmiennych

uint16_t pomiar( uint8_t kanal );
void get_vol1( uint16_t adc, TVOL * voltage, uint16_t * sr_1 );
void get_vol2( uint16_t adc, TVOL * voltage, uint16_t * sr_2 );
void get_vol3( uint16_t adc, TVOL * voltage, uint16_t * sr_3 );
void get_vol4( uint16_t adc, TVOL * voltage, uint16_t * sr_4 );
void get_vol5( uint16_t adc, TVOL * voltage, uint16_t * sr_5 );
void get_vol6( uint16_t adc, TVOL * voltage, uint16_t * sr_6 );

#define REF_256 (1<<REFS1)|(1<<REFS0)
#define REF_VCC (1<<REFS0)

#define LED1 (1<<PB0)
#define LED2 (1<<PB1)
#define LED3 (1<<PB2)
#define LED4 (1<<PD7)
#define LED1_ON PORTB |= LED1
#define LED2_ON PORTB |= LED2
#define LED3_ON PORTB |= LED3
#define LED1_OFF PORTB &= ~LED1
#define LED2_OFF PORTB &= ~LED2
#define LED3_OFF PORTB &= ~LED3
#define LED1_TOG PORTB ^= LED1
#define LED2_TOG PORTB ^= LED2
#define LED3_TOG PORTB ^= LED3
#define LED4_TOG PORTD ^= LED4

int main( void ) {

DDRB |= LED1 | LED2 | LED3; //Ustawiamy PB0 i PB1 i PB2 jako wyjscia
DDRD |= LED4;

// inicjalizacja ADC
ADCSRA |= (1<<ADEN); // włącz ADC
ADCSRA |= (1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); // preskaler
ADCSRA |= (1<<ADIE); // Free Runing Mode plus Interrupt enable
ADMUX |= REF_VCC;// ustawiamy wewn. źr odn. 2,56V

//************************* KALIBRACJA CZUJNIKÓW ******************************

nap1.ref_adc = 597;
nap1.ref_v = 2000;

nap2.ref_adc = 1023;
nap2.ref_v = 500;

nap3.ref_adc = 300;
nap3.ref_v = 600;

nap4.ref_adc = 400;
nap4.ref_v = 600;

nap5.ref_adc = 500;
nap5.ref_v = 600;

nap6.ref_adc = 150;
nap6.ref_v = 5;

//************************* INIZJALIZACJA UART ********************************
uart_init( __UBRR );

//************************* Wyswietlanie na Ekran Terminala *********************

tr_cls(0);
uart_puts( "miernik napięcia:" );
_delay_ms( 1 );
tr_cls(1);

tr_locate(0,3);
tr_attr(1,YELLOW,BLACK);
uart_puts( "ATmega8 ");

tr_locate(4,3);
tr_attr(1,RED,BLUE);
uart_puts( "6 KANAŁOWY MIERNIK NAPIĘCIA ");

set_chanel( PC0 );
sei();
ADCSRA |= (1<<ADSC); // start konwersji

uint16_t tmp_wynik1=0;
uint16_t tmp_wynik2=0;
uint16_t tmp_wynik3=0;
uint16_t tmp_wynik4=0;
uint16_t tmp_wynik5=0;
uint16_t tmp_wynik6=0;

/* Timer2 – konfigurcajca Timera 8bit w trybie NORMAL */
TCCR2 |= (1<<CS22)|(1<<CS21)|(1<<CS20); // preskaler = 1024
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<<OCIE2); // Odblokowanie przerwania CompareMatch

sei();

//Wczytanie z pamieci EEPROM
kWh_stan = eeprom_read_byte (uiAddress);
//********** Start Pętli głównej *****************************
while(1) {

uint8_t sreg = SREG;
cli();
tmp_wynik1 = vtab[0];//wynik;
tmp_wynik2 = vtab[1];//wynik;
tmp_wynik3 = vtab[2];//wynik;
tmp_wynik4 = vtab[3];//wynik;
tmp_wynik5 = vtab[4];//wynik;
tmp_wynik6 = vtab[5];//wynik;

SREG = sreg;

get_vol1( tmp_wynik1, &nap1, asr1 );
get_vol2( tmp_wynik2, &nap2, asr2 );
get_vol3( tmp_wynik3, &nap3, asr3 );
get_vol4( tmp_wynik4, &nap4, asr4 );
get_vol5( tmp_wynik5, &nap5, asr5 );
get_vol6( tmp_wynik6, &nap6, asr6 );


tr_locate(7,3);
tr_attr(1,MAGENTA,BLACK);
uart_puts( "PC0 ");
uart_putlong( vtab[0], 10 );
uart_puts( " / 1023");
tr_locate(7,20);
uart_puts( "napięcie: ");
uart_puts( nap1.v1 );
uart_puts( ".");
uart_puts( nap1.v2 );
uart_puts( " V ");

tr_locate(8,3);
tr_attr(1,MAGENTA,BLACK);
uart_puts( "PC1 ");
uart_putlong( vtab[1], 10 );
uart_puts( " / 1023");
tr_locate(8,20);
uart_puts( "napięcie: ");
uart_puts( nap2.v1 );
uart_puts( ".");
uart_puts( nap2.v2 );
uart_puts( " V ");

tr_locate(9,3);
tr_attr(1,MAGENTA,BLACK);
uart_puts( "PC2 ");
uart_putlong( vtab[2], 10 );
uart_puts( " / 1023");
tr_locate(9,20);
uart_puts( "napięcie: ");
uart_puts( nap3.v1 );
uart_puts( ".");
uart_puts( nap3.v2 );
uart_puts( " V ");

tr_locate(10,3);
tr_attr(1,MAGENTA,BLACK);
uart_puts( "PC3 ");
uart_putlong( vtab[3], 10 );
uart_puts( " / 1023");
tr_locate(10,20);
uart_puts( "napięcie: ");
uart_puts( nap4.v1 );
uart_puts( ".");
uart_puts( nap4.v2 );
uart_puts( " V ");

tr_locate(11,3);
tr_attr(1,MAGENTA,BLACK);
uart_puts( "PC4 ");
uart_putlong( vtab[4], 10 );
uart_puts( " / 1023");
tr_locate(11,20);
uart_puts( "napięcie: ");
uart_puts( nap5.v1 );
uart_puts( ".");
uart_puts( nap5.v2 );
uart_puts( " V ");

tr_locate(12,3);
tr_attr(1,MAGENTA,BLACK);
uart_puts( "PC5 ");
uart_putlong( vtab[5], 10 );
uart_puts( " / 1023 ");
tr_locate(12,20);
uart_puts( "natężenie: ");
uart_puts( nap6.v1 );
uart_puts( ".");
uart_puts( nap6.v2 );
uart_puts( " A ");


// funkcja atol - zamiana stringa na integer * 100
uint32_t Nap1 = ( atol (nap1.v1)) * 100 + ( atol (nap1.v2));
uint32_t Nat6 = ( atol (nap6.v1)) * 100 + ( atol (nap6.v2));
uint32_t Moc1 = Nap1 * Nat6 / 10000;

if (Timer2 == 0){

//KASKADA START

Nap = Nap1 / 100;
if ((Nap<30) && (bieg == 1) && (Timer1 == 0)) {
LED1_OFF;
LED2_OFF;
LED3_OFF;
bieg = 1; //Ustawiamy 67W
Timer1 = 100;
}
if ((Nap>30) && (bieg == 1) && (Timer1 == 0)) {
LED1_OFF;
LED2_ON;
LED3_OFF;
bieg = 2; //Ustawiamy 100W
Timer1 = 100;
}
if ((Nap<20) && (bieg == 2) && (Timer1 == 0)) {
LED1_OFF;
LED2_OFF;
LED3_OFF;
bieg = 1; //Ustawiamy 67W
Timer1 = 100;
}
if ((Nap>20) && (Nap<30) && (bieg == 2) && (Timer1 == 0)){
LED1_OFF;
LED2_ON;
LED3_OFF;
bieg = 2; //Ustawiamy 100W
Timer1 = 100;
}
if ((Nap>30) && (bieg == 2) && (Timer1 == 0)) {
LED1_ON;
LED2_OFF;
LED3_OFF;
bieg = 3; //Ustawiamy 200W
Timer1 = 100;
}
if ((Nap<20) && (bieg == 3) && (Timer1 == 0)) {
LED1_OFF;
LED2_ON;
LED3_OFF;
bieg = 2; //Ustawiamy 100W
Timer1 = 100;
}
if ((Nap>20) && (Nap<30) && (bieg == 3) && (Timer1 == 0)) {
LED1_ON;
LED2_OFF;
LED3_OFF;
bieg = 3; //Ustawiamy 200W
Timer1 = 100;
}
if ((Nap>30) && (bieg == 3) && (Timer1 == 0)) {
LED1_OFF;
LED2_OFF;
LED3_ON;
bieg = 4; //Ustawiamy 300W
Timer1 = 100;
}
if ((Nap<20) && (bieg == 4) && (Timer1 == 0)) {
LED1_ON;
LED2_OFF;
LED3_OFF;
bieg = 3; //Ustawiamy 200W
Timer1 = 100;
}
if ((Nap>20) && (Nap<30) && (bieg == 4) && (Timer1 == 0)) {
LED1_OFF;
LED2_OFF;
LED3_ON;
bieg = 4; //Ustawiamy 300W
Timer1 = 100;
}
if ((Nap>30) && (bieg == 4) && (Timer1 == 0)) {
LED1_ON;
LED2_OFF;
LED3_ON;
bieg = 5; //Ustawiamy 400W
Timer1 = 100;
}
if ((Nap<20) && (bieg == 5) && (Timer1 == 0)) {
LED1_OFF;
LED2_OFF;
LED3_ON;
bieg = 4; //Ustawiamy 300W
Timer1 = 100;
}
if ((Nap>20) && (Nap<30) && (bieg == 5) && (Timer1 == 0)) {
LED1_ON;
LED2_OFF;
LED3_ON;
bieg = 5; //Ustawiamy 400W
Timer1 = 100;
}
if ((Nap>30) && (bieg == 5) && (Timer1 == 0)) {
LED1_ON;
LED2_ON;
LED3_ON;
bieg = 6; //Ustawiamy 600W
Timer1 = 100;
}
if ((Nap<20) && (bieg == 6) && (Timer1 == 0)) {
LED1_ON;
LED2_OFF;
LED3_ON;
bieg = 5; //Ustawiamy 400W
Timer1 = 100;
}
if ((Nap>20) && (bieg == 6) && (Timer1 == 0)) {
LED1_ON;
LED2_ON;
LED3_ON;
bieg = 6; //Ustawiamy 600W
Timer1 = 100;
}
//KASKADA STOP

Moc = Moc + Moc1;
Timer2 = 30;
LED4_TOG;
if (Moc >= 300) { //1 [kWh] = 3600000 [Ws]
// kWh_stan = Moc/500 ; //dodaj jedną kilowatogodzinę do RAM
kWh_stan = kWh_stan+1 ;
cli();
eeprom_write_byte (uiAddress, kWh_stan); // zapis do eeprom
sei();
Moc = 0 ; //wyzeruj licznik Watosekund
}
}

tr_locate(15,3);
tr_attr(1,YELLOW,BLACK);
uart_putlong( Moc, 10 );
uart_puts( " Moc w watosekundach ");
tr_locate(16,3);
uart_putlong( Nap1, 10 );
uart_puts( " Napiecie INP1 ");
tr_locate(17,3);
uart_putlong( Nat6, 10 );
uart_puts( " Natezenie INP6 ");
tr_locate(18,3);
uart_putlong( kWh_stan, 10 );
uart_puts( " / ");
uart_putlong( *uiAddress,10 );
uart_puts( " Licznik kWh ");

tr_locate(19,3);
uart_putlong( bieg, 10 );
uart_puts( " Numer \"biegu\" ");
tr_locate(20,3);
uart_puts( "Timer1 ");
uart_putlong( Timer1, 10 );
uart_puts( " ");
tr_locate(21,3);
uart_puts( "Timer2 ");
uart_putlong( Timer2, 10 );
uart_puts( " ");


}
}

// *******************FUNKCJE ********************************
ISR( ADC_vect ) {
static uint8_t idx;

vtab[idx++] = ADCW;
if( idx>5 ) idx=0; //Definiowanie ilosci kanalow idx>5 = 6 kanałów

ADMUX = (ADMUX & 0b11111000) | idx;

ADCSRA |= (1<<ADSC);

//wynik = ADCW;
}

uint16_t pomiar( uint8_t kanal ) {

ADMUX = (ADMUX & 0b11111000) | kanal;

ADCSRA |= (1<<ADSC); // start konwersji

while( ADCSRA & (1<<ADSC) );

return ADCW;
}

void get_vol1( uint16_t adc1, TVOL * voltage, uint16_t * sr_1 ) {

uint32_t sr1=0;
uint8_t i;

sr_1[ voltage->idx++ & (SR1-1) ] = adc1;

for(i=0; i<SR1; i++) sr1+=sr_1[i];
sr1 /= SR1;

voltage->adc_mid = sr1;

uint16_t wynik = ( sr1 * (uint32_t)voltage->ref_v ) / voltage->ref_adc;

div_t divmod = div(wynik, 100);
itoa( divmod.quot, voltage->v1, 10 );
itoa( divmod.rem, voltage->v2, 10);
if( divmod.rem < 10 ) {
voltage->v2[0]='0';
voltage->v2[1]=divmod.rem+'0';
}

voltage->v1[2]=0;
voltage->v2[2]=0;
}

void get_vol2( uint16_t adc2, TVOL * voltage, uint16_t * sr_2 ) {

uint32_t sr2=0;
uint8_t i;

sr_2[ voltage->idx++ & (SR2-1) ] = adc2;

for(i=0; i<SR2; i++) sr2+=sr_2[i];
sr2 /= SR2;

voltage->adc_mid = sr2;

uint16_t wynik = ( sr2 * (uint32_t)voltage->ref_v ) / voltage->ref_adc;

div_t divmod = div(wynik, 100);
itoa( divmod.quot, voltage->v1, 10 );
itoa( divmod.rem, voltage->v2, 10);
if( divmod.rem < 10 ) {
voltage->v2[0]='0';
voltage->v2[1]=divmod.rem+'0';
}

voltage->v1[2]=0;
voltage->v2[2]=0;
}

void get_vol3( uint16_t adc3, TVOL * voltage, uint16_t * sr_3 ) {

uint32_t sr3=0;
uint8_t i;

sr_3[ voltage->idx++ & (SR3-1) ] = adc3;

for(i=0; i<SR3; i++) sr3+=sr_3[i];
sr3 /= SR3;

voltage->adc_mid = sr3;

uint16_t wynik = ( sr3 * (uint32_t)voltage->ref_v ) / voltage->ref_adc;

div_t divmod = div(wynik, 100);
itoa( divmod.quot, voltage->v1, 10 );
itoa( divmod.rem, voltage->v2, 10);
if( divmod.rem < 10 ) {
voltage->v2[0]='0';
voltage->v2[1]=divmod.rem+'0';
}

voltage->v1[2]=0;
voltage->v2[2]=0;
}

void get_vol4( uint16_t adc4, TVOL * voltage, uint16_t * sr_4 ) {

uint32_t sr4=0;
uint8_t i;

sr_4[ voltage->idx++ & (SR4-1) ] = adc4;

for(i=0; i<SR4; i++) sr4+=sr_4[i];
sr4 /= SR4;

voltage->adc_mid = sr4;

uint16_t wynik = ( sr4 * (uint32_t)voltage->ref_v ) / voltage->ref_adc;

div_t divmod = div(wynik, 100);
itoa( divmod.quot, voltage->v1, 10 );
itoa( divmod.rem, voltage->v2, 10);
if( divmod.rem < 10 ) {
voltage->v2[0]='0';
voltage->v2[1]=divmod.rem+'0';
}

voltage->v1[2]=0;
voltage->v2[2]=0;
}

void get_vol5( uint16_t adc5, TVOL * voltage, uint16_t * sr_5 ) {

uint32_t sr5=0;
uint8_t i;

sr_5[ voltage->idx++ & (SR5-1) ] = adc5;

for(i=0; i<SR5; i++) sr5+=sr_5[i];
sr5 /= SR5;

voltage->adc_mid = sr5;

uint16_t wynik = ( sr5 * (uint32_t)voltage->ref_v ) / voltage->ref_adc;

div_t divmod = div(wynik, 100);
itoa( divmod.quot, voltage->v1, 10 );
itoa( divmod.rem, voltage->v2, 10);
if( divmod.rem < 10 ) {
voltage->v2[0]='0';
voltage->v2[1]=divmod.rem+'0';
}

voltage->v1[2]=0;
voltage->v2[2]=0;
}

void get_vol6( uint16_t adc6, TVOL * voltage, uint16_t * sr_6 ) {

uint32_t sr6=0;
uint8_t i;

sr_6[ voltage->idx++ & (SR6-1) ] = adc6;

for(i=0; i<SR6; i++) sr6+=sr_6[i];
sr6 /= SR6;

voltage->adc_mid = sr6;

uint16_t wynik = ( (sr6-102) * (uint32_t)voltage->ref_v ) / (voltage->ref_adc-102);

div_t divmod = div(wynik, 100);
itoa( divmod.quot, voltage->v1, 10 );
itoa( divmod.rem, voltage->v2, 10);
if( divmod.rem < 10 ) {
voltage->v2[0]='0';
voltage->v2[1]=divmod.rem+'0';
}

voltage->v1[2]=0;
voltage->v2[2]=0;
}
//Funkcje Zapisu do EEPROM

//*** przerwanie Timer2 CompareMatch
ISR(TIMER2_COMP_vect) {

uint16_t n, m;

n = Timer1;
m = Timer2;

if (n) Timer1 = --n;
if (m) Timer2 = --m;
}[/syntax]

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

]]>