ATNEL tech-forum 2012-09-02T21:59:20+01:00 https://forum.atnel.pl/feed.php?f=4&t=1491&mode 2012-09-02T21:59:20+01:00 2012-09-02T21:59:20+01:00 https://forum.atnel.pl/viewtopic.php?t=1491&p=14306#p14306 <![CDATA[Re: Atmega8 dwa kanały ADC – problem z wartością ADCW]]> i ile radochy jak się samemu coś uruchamia ....

a nawet nie wiesz jak miło autorowi jest usłyszeć że książka chociaż w minimalnym stopniu pomogła w rozwijaniu pasji - bo taki jest GŁÓWNY cel tego co piszę .... i jak słyszę takie słowa to aż chce się dalej to robić ...

Więc jak będziesz oczywiście miał pytanka to dawaj śmiało starając się jednak jakoś lepiej je precyzować - aby można było z chirurgiczną precyzją szybko pomóc ;)

Statystyki: Napisane przez mirekk36 — 2 wrz 2012, o 21:59

]]> 2012-09-02T21:50:12+01:00 2012-09-02T21:50:12+01:00 https://forum.atnel.pl/viewtopic.php?t=1491&p=14304#p14304 <![CDATA[Re: Atmega8 dwa kanały ADC – problem z wartością ADCW]]>

Czasami wpadam w nieskończoną pętle i pomimo błahego problemu zaczynam kombinować w najróżniejsze strony oprócz właściwej :)

Poskładałem dzisiaj wszystkie elementy na prototypową płytkę i spróbuje przeprowadzić testy w aucie. Jak wszystko będzie grać to przejdę do napisania wszystkiego w jedna spójną całość i popróbuję sił w eaglu (gratuluje nagrania świetnego kursu) i trawieniu płytki. Nie polecam nikomu lutowania na dziurawce którą miałem bo z każdym elementem zaczyna być ciaśniej i kosztuje to bardzo dużo pracy i nerwów gdy się rozleje cyna po różnych zakończeniach.

Komputerek który wykonuje jest tak prosty z świadomego wyboru, montuje go w dosyć starym aucie które wykorzystuje do worzenia najróżniejszych rzeczy i będzie idealnie pasował do wystroju japońskiego auta z lat dziewięćdziesiątych :)

Co najśmieszniejsze to dzięki komputerkowi jaki kupiłem wcześniej jako gotowy i zamontowałem w innym autku dotarło do mnie jakie możliwości daje umiejętność programowania i znajomość elektroniki. Jak chyba większość poczatkujących rozpocząłem zabawę w bascomie i nie do opisania jest radość pierwszego odpalenia własnego programu który miga diodą :D Potem natrafiłem na Twój blog i dzięki temu postanowiłem rozstać się z bascomem i przejść na C czego nie żałuje. Książkę dostałem na święta i pomalutku próbuje się rozwijać, miałem po zimie przerwę i dopiero w sierpniu ruszyłem ponownie dozbrajając się w stacje lutownicza bo stara transformatorówka jest mało wygodna :) A pomysłów z zastosowaniem mikrokontrolerów nie brakuje, pozostaje tylko się uczyć aby je zrealizować.

Tak wygląda mój dzisiejszy „Frankenstein” :)

Obrazek

Obrazek

Statystyki: Napisane przez Tomiplis — 2 wrz 2012, o 21:50

]]> 2012-09-02T13:21:24+01:00 2012-09-02T13:21:24+01:00 https://forum.atnel.pl/viewtopic.php?t=1491&p=14266#p14266 <![CDATA[Re: Atmega8 dwa kanały ADC – problem z wartością ADCW]]> na błędach ....

a na poważnie to bardzo fajnie że udało ci się samemu rozwikłać swoją zagadkę

super też, że np korzystasz z zewnętrznego źródła taktowania ..... ale mam nadzieję, że zrozumiałeś też teraz dobitnie, iż aby otrzymać czasem dobrą podpowiedź na forum to trzeba jeszcze umiejętnie zadać pytanie ....

skąd ktoś miałby się spodziewać że u ciebie jest tak a nie inaczej skoro nie pokazujesz np schematu ;)

dlatego mam nadzieję że na przyszłość będzie lepiej

Statystyki: Napisane przez mirekk36 — 2 wrz 2012, o 13:21

]]> 2012-09-02T01:58:50+01:00 2012-09-02T01:58:50+01:00 https://forum.atnel.pl/viewtopic.php?t=1491&p=14240#p14240 <![CDATA[Re: Atmega8 dwa kanały ADC – problem z wartością ADCW]]> Nie jestem testerem „googlowych” teorii i nie testuję bezmyślnie tego co ktoś opublikował z pretensjami, że nie działa. Wiem, że tak mój wpis wygląda i chciałem to sprostować bo działam w dobrej wierze. Co najgorsze to kod który napisałem był mój o czy później.

To, że napisałem o poszukiwaniu podobnego tematu odnosiło się jedynie do atmegi8 i kilku kanałów odczytywanych bezpośrednio po sobie bez wychodzenia z funkcji. Po prostu nie potrafię napisać o co mi chodzi a znalazłem podobnych do mnie :)

A teraz najlepsze, chciałem przeprosić za własna głupotę bo z powodu wpisania „!” w pętli sprawdzającej koniec konwersji doprowadziłem do natychmiastowego wyjścia z pętli :(

Zawracam głowę na forum i tracę czas innych. Ja straciłem kilka dni :D

Co do źródła REF to mam zewnętrzne tylko i wyłącznie z powodów poznawczych bo jak pisałem nie jestem elektronikiem a próbuję się czegoś nauczyć. Opisane w książce zagadnienie ADC przerobiłem i działa bez zastrzeżeń od zimy w woltomierzu który zrobiłem do auta. Teraz chciałem sam cos napisać i wyszło jak zawsze :)

Z pokazaniem schematu może być ciężko bo dopiero ogarniam eagle i wszystko masakruje w zeszycie i na stykówce. Wiem, że to nie elegancki sposób ale tak na razie robię. Zastosowałem LM385Z-1.2 bo taki miałem, środkowa nóżka do procka i rezystora który idzie do VCC a dwie zewnętrzne do masy. Na mierniku mam dokładnie 1,235V i tu chyba wszystko gra.

Wkleję kod który męczę i jakoś działa, ale dostane zaraz opr bo opisy robiłem tylko dla siebie i nie wszystko jest logiczne a znam nastawienie autora książki :? Dodatkowo kod jest pisany w sposób mocno przypadkowy, gdyż szukałem sposobów na ogarniecie impulsów VSS i wtrysku tak, aby uzyskać wynik (impulsy generuje tym samym procesorem bo nie mam generatora). Wszystko będę zmieniał i wrzucał do funkcji z wieloma argumentami a nie jak jest teraz każda zmienna żyje własnym życiem :)
Tak to wygląda na biurku :D
http://www.youtube.com/watch?v=xw2z3GF0wmM&feature=youtu.be


Jak pisałem wcześniej, chciałem tylko zapytać czy atmega8 może bezpośrednio po konwersji ADC z jednego kanału rozpocząć kolejną bez wpływu na wynik (kolejny oczywiście). I żył bym z tym pytaniem nadal gdyby nie ten zimny prysznic który mnie uświadomił. Najgorsze jest to, że zdołałem sobie poradzić z problemem robiąc jakieś dziwne pętle które poniekąd były substytutem _delay i wszystko mi niby działało.

Mam jeszcze jedno głupie pytanie, w „ADMUX = (ADMUX & 0xF8) | kanal;” jest f8 a nie f0. Efekt generalnie ten sam bo bit MUX3 jest nie wykorzystany, ale gdy przypadkiem będzie miał 1 to może coś się pokrzaczyć, chociaż tylko ja mógł bym tam wpisać 1 :D

Jedno małe „!” zniszczyło mi życie :D

Dziękuje za pomoc, teraz się dwa razy zastanowię zanim coś nowego odkryję odnośnie AVR :D
Pozdrawiam


Kod w wersji z odczytem ADC w petli, PWN_LED nie oznacza PWN bo na multipleksie nie działa (włącza tylko dodatkowy rezystor na anody)
Proszę go traktowac jako przestrogę a nie przykład :D

[syntax=c]/*
* main.c
*
* Created on: 2012-08-05
* Author: Tomasz Pliszczak
*/

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

#include "d_led.h"

#define KEY_PIN1 (1<<PC3)
#define KEY_DOWN1 !(PINC & KEY_PIN1)
#define KEY_PIN2 (1<<PC2)
#define KEY_DOWN2 !(PINC & KEY_PIN2)
#define PWM_PIN (1<<PD4)


void przelicz();//przeliczenie
void display_manu();//wyswietla konfiguracje
void display_tripkm(); // trip km
void display(uint8_t m); // wszystko
uint8_t przycisk(); //klawisze


extern volatile uint8_t cy1;
extern volatile uint8_t cy2;
extern volatile uint8_t cy3;
extern volatile uint8_t cy4;
extern volatile uint8_t kr1;
extern volatile uint8_t kr2;
extern volatile uint8_t kr3;
extern volatile uint8_t kr4;
extern volatile uint16_t Timer1, Timer2, Timer3;


volatile uint32_t VSS_CZAS; //licznik czasu co 100us
volatile uint32_t VSS_OBLICZ;

volatile uint32_t INJ_OBL;
volatile uint16_t INJ_CZAS;

uint8_t DISP_NAPIECIE;
uint8_t DISP_PRETKOSC;
uint16_t DISP_CHWIL;
uint16_t DISP_TRIP;
uint16_t DISP_TRIP_KM;
uint16_t ADC_LED;

enum {nap,pre,chwil,trip,tripkm}; // nazwy manu

typedef struct {
uint16_t stala_drogi;
uint16_t stala_wtrysku;
uint16_t pwm_led;
uint32_t inj_trip1;
uint32_t vss_trip1;
uint8_t manu;
} CONFIG;

CONFIG EEMEM ee_config; // definiujemy strukturę w pamięci EEPROM
CONFIG ram_config; // definiujemy strukturę w pamięci RAM


int main(void){
d_led_init();

if(MCUSR&(1<<WDRF)) kr4=1; // pies
MCUSR&=~(1<<WDRF);
wdt_reset();
wdt_enable(WDTO_2S);
WDTCR |= (1<<WDCE) | (1<<WDE);
WDTCR |= (1<<WDP2) | (1<<WDP1)| (1<<WDP0);

eeprom_read_block(&ram_config, &ee_config, sizeof(ram_config)); // odczyt bloku eeprom
if(ram_config.stala_drogi==0)ram_config.stala_drogi=784; //po pierwszym wlaczeniu
if(ram_config.stala_wtrysku==0)ram_config.stala_wtrysku=320;
if(ram_config.pwm_led==0)ram_config.pwm_led=700;

//ustawienie TIMER0
TCCR0 |= (1<<CS01);// preskaler = 8
TCNT0=156; // co 0,0001s 10000hz
TIMSK |= (1<<TOIE0);// zezwolenie na przerwanie CompareMatch

//ustawienie TIMER1
TCCR1B |= (1<<CS12)|(1<<CS10);// preskaler = 1024 0,000128s
//TCCR1B |= (1<<CS12);// preskaler = 256 0,000032s
TCCR1B|=(1<<ICNC1); //redukcaja Noise Canceler
TIMSK |= (1<<TICIE1); // Przerwanie od ICP1
TCCR1B &= ~(1<<ICES1); // Zbocze opadające na ICP1

//Przerwanie INT0
MCUCR |= (1<<ISC01);// wyzwalanie zboczem opadajacym
GICR |= (1<<INT0);// odblokowanie przerwania
ADMUX = 0; //ADC
ADMUX &= ~((1<<REFS1)|(1<<REFS0)); //zew ref 1,235v
ADCSRA = (1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); //128 preskaler

// ************pomocnicza testowa************
DDRC|=(1<<PC5)|(1<<PC4);
PORTC|=(1<<PC5)|(1<<PC4);
//*******************************************

DDRC&=~(KEY_PIN1|KEY_PIN2|(1<<PC0)|(1<<PC1)); // przyciski wejscia
PORTC|=KEY_PIN1|KEY_PIN2; // przyciski do vcc
//PORTC&=~((1<<PC0)|(1<<PC1));
DDRD|=PWM_PIN; // wyjscie podswietlenia
PORTD|=PWM_PIN;



DDRD&=~((1<<PD2)|(1<<PD3)); //PRZERWANIA WEJSCIA
PORTD|=(1<<PD2); // PRZERWANIA DO VSS
DDRB&=~(1<PB0); // ICP1 wtrysk
PORTB|=(1<<PB0); //ICP1 wtrysk

sei();

while(1){
static uint8_t start=1;
while(start){//start zawsze napiecie
przelicz();
display(nap);
PORTD&=~PWM_PIN; // podswietlenie max
if(przycisk(10))start=0;
if(DISP_NAPIECIE>140||DISP_CHWIL>0){
uint16_t x=1;
while(x){
przelicz();
display(nap);
x++;
if(x>50)x=0;
_delay_ms(100);
wdt_reset();
}
start=0;
}
_delay_ms(100);
wdt_reset();
}

if(przycisk(50)){
if(przycisk(25)==1){
if(ram_config.manu==nap)ram_config.manu=tripkm;
else ram_config.manu--;
//_delay_ms(20);
}
if(przycisk(25)==2){
if(ram_config.manu==tripkm)ram_config.manu=nap;
else ram_config.manu++;
//_delay_ms(20);
}
if(przycisk(50)==3){
_delay_ms(50);
if(przycisk(30)==3){
if(ram_config.manu==nap)ram_config.pwm_led=ADC_LED;
Timer2=500;
_delay_ms(50);
while(Timer2>0){
if(ram_config.manu==trip||ram_config.manu==tripkm){
wdt_reset();
_delay_ms(1500);
wdt_reset();
if(przycisk(30)==3){
ram_config.vss_trip1=0;
ram_config.inj_trip1=0;
cy1=14;cy2=14;cy3=14;cy4=14;
kr1=0;kr2=0;kr3=0; //zerowanie kropek
_delay_ms(500);
break;
}
}
display_manu();
if(przycisk(40)==1){
Timer2=500;
if(ram_config.manu==nap){
ram_config.pwm_led-=1;
if(ram_config.pwm_led<1)ram_config.pwm_led=1023;
if(KEY_DOWN1){
_delay_ms(100);
while(KEY_DOWN1){
ram_config.pwm_led-=1;
if(ram_config.pwm_led<1)ram_config.pwm_led=1023;
_delay_ms(15);
display_manu();
Timer2=500;
wdt_reset();
}
}
}
if(ram_config.manu==pre)--ram_config.stala_drogi;
if(ram_config.manu==chwil)--ram_config.stala_wtrysku;
//_delay_ms(10);
}
if(przycisk(40)==2){
Timer2=500;
if(ram_config.manu==nap){
ram_config.pwm_led+=1;
if(ram_config.pwm_led>1023)ram_config.pwm_led=0;
if(KEY_DOWN2){
_delay_ms(100);
while(KEY_DOWN2){
ram_config.pwm_led+=1;
if(ram_config.pwm_led>1023)ram_config.pwm_led=0;
_delay_ms(15);
display_manu();
Timer2=500;
wdt_reset();
}
}
}
if(ram_config.manu==pre)++ram_config.stala_drogi;
if(ram_config.manu==chwil)++ram_config.stala_wtrysku;
//_delay_ms(10);
}
if(Timer2<10){ // do testow
eeprom_update_block(&ram_config, &ee_config, sizeof(ram_config));
Timer2=0;
}
wdt_reset();
}
}
}
}
//***********************************************************************************
if(!Timer3){ //co 100ms przelicz i wyswietl
przelicz();
display(ram_config.manu);
Timer3=10;
}
//zerowanie tripow po przed przepelnieniem okolo 2000km
if(ram_config.inj_trip1>310000000UL||ram_config.vss_trip1>5000000UL){
ram_config.vss_trip1=0;
ram_config.inj_trip1=0;
}
//jasnosc*****************************************
if(ADC_LED>ram_config.pwm_led)PORTD&=~PWM_PIN;
if(ADC_LED<(ram_config.pwm_led-100))PORTD|=PWM_PIN;


//if(DISP_TRIP_KM>999&&!(DISP_TRIP_KM-1000))

wdt_reset();
}
}
//*******************************funkcje****************************************************
uint8_t przycisk(uint16_t ms){
_delay_ms(ms);
if(KEY_DOWN1&&KEY_DOWN2)return 3;
else{
if(KEY_DOWN1)return 1;
if(KEY_DOWN2)return 2;
}
return 0;
}
void display_manu(){
kr1=0;kr2=0;kr3=0; //zerowanie kropek
if(ram_config.manu==nap){
cy4=ram_config.pwm_led%10;
cy3=(ram_config.pwm_led/10)%10;
cy2=(ram_config.pwm_led/100)%10;
cy1=(ram_config.pwm_led/1000)%10;
}
if(ram_config.manu==pre){
cy4=ram_config.stala_drogi%10;
cy3=(ram_config.stala_drogi/10)%10;
cy2=(ram_config.stala_drogi/100)%10;
cy1=(ram_config.stala_drogi/1000)%10;
}
if(ram_config.manu==chwil){
cy4=ram_config.stala_wtrysku%10;
cy3=(ram_config.stala_wtrysku/10)%10;
cy2=(ram_config.stala_wtrysku/100)%10;
cy1=(ram_config.stala_wtrysku/1000)%10;
}
}
void display(uint8_t m){
kr1=0;kr2=0;kr3=0; //zerowanie kropek
if(m==nap){
kr2=1; // kropka 2
cy4=13; // wyswietla u
cy3=DISP_NAPIECIE%10;
cy2=(DISP_NAPIECIE/10)%10;
cy1=DISP_NAPIECIE/100;if(cy1==0)cy1=11;
}
if(m==pre){
cy4=12; // h
cy3=DISP_PRETKOSC%10;
cy2=(DISP_PRETKOSC/10)%10;
if(cy2==0&&DISP_PRETKOSC<100)cy2=11,cy1=11;
else cy1=DISP_PRETKOSC/100;if(!cy1)cy1=11;
}
if(m==chwil){

kr2=1; // kropka 2
cy4=10; // wyswietla L
cy3=DISP_CHWIL%10;
cy2=(DISP_CHWIL/10)%10;
cy1=DISP_CHWIL/100;if(cy1==0)cy1=11;
}
if(m==trip){

kr2=1; // kropka 2
cy4=10; // wyswietla L
cy3=DISP_TRIP%10;
cy2=(DISP_TRIP/10)%10;
cy1=DISP_TRIP/100;if(cy1==0)cy1=11;
}
if(m==tripkm){
kr3=1; // kropka 2
if(DISP_TRIP_KM>9999){
DISP_TRIP_KM/=10;
kr3=0;
}
//DISP_TRIP_KM=ADC_LED;
cy4=DISP_TRIP_KM%10;
cy3=(DISP_TRIP_KM/10)%10;
cy2=(DISP_TRIP_KM/100)%10;
cy1=(DISP_TRIP_KM/1000)%10;

}
}
void przelicz(){
//****************napiecie***********************************************

static uint8_t adc_nr;
static uint8_t flagaadc;
static uint8_t flagaadc2;

if(adc_nr<2){
//static uint8_t srednia_led[5]={0,0,0,0,0};
//static uint8_t n_led, s_led;
//uint16_t wynik_led=0;
ADMUX |=(1<<MUX0); //ADC
ADCSRA |= (1<<ADSC); //odczyt ADC
while( !(ADCSRA & (1<<ADSC)) );
while( (ADCSRA & (1<<ADIF)) );
if(flagaadc){
ADC_LED=ADCW;
/*srednia_led[n_led]=ADC_LED; // srednia 5 pomiarow
for(uint8_t i=0;i<5;i++){
wynik_led=wynik_led+srednia_led[i];
}
n_led++;
if(n_led>4)n_led=0,s_led=1;
if(s_led)ADC_LED=wynik_led/5; // po 5 pomiarach usrednianie
if(!ADC_LED){n_led=0;s_led=0;}*/
}
flagaadc++;
flagaadc2=0;
}
else{
ADMUX &=~(1<<MUX0);
static uint8_t srednia[10]={0,0,0,0,0,0,0,0,0,0}; //adc
static uint8_t n, s;
uint16_t wynik1=0;
ADCSRA |= (1<<ADSC); //odczyt ADC
while( !(ADCSRA & (1<<ADSC)) );
while( (ADCSRA & (1<<ADIF)) );
if(flagaadc2){
DISP_NAPIECIE = (ADCW*1206UL*13)/100000UL; //obliczenie napiecia dzielnik 13
srednia[n]=DISP_NAPIECIE; // srednia 10 pomiarow
for(uint8_t i=0;i<10;i++){
wynik1=wynik1+srednia[i];
}
n++;
if(n>9)n=0,s=1;
if(s)DISP_NAPIECIE=wynik1/10; // po 10 pomiarach usrednianie
}
flagaadc2++;
flagaadc=0;
}
++adc_nr;
if(adc_nr>9)adc_nr=0;

//**************predkosc*******************************************************

DISP_PRETKOSC=(((ram_config.stala_drogi*1000UL)/VSS_OBLICZ)*36)/1000; //km/h
if(VSS_CZAS>28200)DISP_PRETKOSC=0; //gdy brak impulsow v=0

static uint8_t srednia_pr[10]={0,0,0,0,0,0,0,0,0,0};
static uint8_t n_pr, s_pr;
uint16_t wynik_pr=0;
srednia_pr[n_pr]=DISP_PRETKOSC; // srednia 10 pomiarow
for(uint8_t i=0;i<10;i++){
wynik_pr=wynik_pr+srednia_pr[i];
}
n_pr++;
if(n_pr>9)n_pr=0,s_pr=1;
if(s_pr)DISP_PRETKOSC=wynik_pr/10; // po 10 pomiarach usrednianie
if(!DISP_PRETKOSC){n_pr=0;s_pr=0;}




//**************spalanie chwilowe**************************************************

if(TCNT1>6000)INJ_OBL=0;
DISP_CHWIL=(((ram_config.stala_wtrysku*INJ_OBL)/100)*128UL*(36000000UL/(INJ_CZAS*128UL)))/1000000UL; //l/h preskaler 1024
if(DISP_PRETKOSC>5)DISP_CHWIL=((100000UL/DISP_PRETKOSC)*DISP_CHWIL)/1000; //ponizej 5km/h l/h

static uint8_t srednia_chwil[10]={0,0,0,0,0,0,0,0,0,0};
static uint8_t n_ch, s_ch;
uint16_t wynik_ch=0;
srednia_chwil[n_ch]=DISP_CHWIL; // srednia 10 pomiarow
for(uint8_t i=0;i<10;i++){
wynik_ch=wynik_ch+srednia_chwil[i];
}
n_ch++;
if(n_ch>9)n_ch=0,s_ch=1;
if(s_ch)DISP_CHWIL=wynik_ch/10; // po 10 pomiarach usrednianie
if(!DISP_CHWIL){n_ch=0;s_ch=0;}


//**************spalanie srednie trip*****************************************************

uint32_t vss_na1m=(ram_config.vss_trip1*ram_config.stala_drogi)/100; //pelne metry
uint32_t inj_trip1sek=ram_config.inj_trip1*10/78125UL; // pelne sekundy wtrysku
DISP_TRIP=(ram_config.stala_wtrysku*inj_trip1sek*100)/vss_na1m;

static uint8_t srednia_trip[10]={0,0,0,0,0,0,0,0,0,0};
static uint8_t n_tr, s_tr;
uint16_t wynik_tr=0;
srednia_trip[n_tr]=DISP_TRIP; // srednia 10 pomiarow
for(uint8_t i=0;i<10;i++){
wynik_tr=wynik_tr+srednia_trip[i];
}
n_tr++;
if(n_tr>9)n_tr=0,s_tr=1;
if(s_tr)DISP_TRIP=wynik_tr/10; // po 10 pomiarach usrednianie
if(!DISP_TRIP){n_tr=0;s_tr=0;}

//**********************km trip*************************************************************

DISP_TRIP_KM=ram_config.vss_trip1*ram_config.stala_drogi/100000UL; //100 000
}


//*********************przerwania************************************************************

//przerwanie INT0 VSS**************************************
ISR(INT0_vect) {
if(!Timer1){
Timer1=1;
VSS_OBLICZ=VSS_CZAS;
VSS_CZAS=0;
++ram_config.vss_trip1;
}
}
// procedura obsługi przerwania ICP1 wtrysk**************************
ISR(TIMER1_CAPT_vect){
static uint8_t zbocze;
static uint16_t icrp,icrk,icrwynik;
static uint32_t INJ_POMOC;

if(!zbocze){ //gdy wejscie opadajacym
//kr1=1;
icrp=ICR1;
TCCR1B |= (1<<ICES1); // Zbocze wzrastajace na ICP
zbocze=1;
}
else{
//kr1=0;
icrk=ICR1;
icrwynik=icrk-icrp;
if(icrwynik>6000)icrwynik=0;
ram_config.inj_trip1+=icrwynik;
if(TCNT1>3906){
INJ_OBL=ram_config.inj_trip1-INJ_POMOC;
INJ_POMOC=ram_config.inj_trip1;
INJ_CZAS=TCNT1;
TCNT1=0;
}
TCCR1B &= ~(1<<ICES1); // Zbocze opadające na ICP
zbocze=0;
}
}
//TIMER 10 000 HZ********************************
//SIGNAL(SIG_OVERFLOW0){
ISR(TIMER0_OVF_vect){

TCNT0=156;
//TCNT0=246;
++VSS_CZAS;//co 100us


//*************************************************************************testy

//test predkosci pinc
static uint32_t cnt1; //co 100 us
if(cnt1>69)PORTC|=(1<<PC5);
if(++cnt1>199){ //699 = 40
PORTC&=~(1<<PC5);// co 20 ms
cnt1=0;
}
//test predkosci pinc
static uint32_t cnt2; //co 100 us
if(cnt2>79)PORTC|=(1<<PC4);
if(++cnt2>149){
PORTC&=~(1<<PC4);// co 20 ms
cnt2=0;
}
}
[/syntax]

Statystyki: Napisane przez Tomiplis — 2 wrz 2012, o 01:58

]]> 2012-09-01T21:23:06+01:00 2012-09-01T21:23:06+01:00 https://forum.atnel.pl/viewtopic.php?t=1491&p=14236#p14236 <![CDATA[Re: Atmega8 dwa kanały ADC – problem z wartością ADCW]]> .... przede wszystkim skąd ci np takie pomysły do głowy przychodzą ?

[syntax=c]ADMUX &= ~((1<<REFS1)|(1<<REFS0)); //zew. ref. 1,235v[/syntax]

co to jest ??? Korzystasz z ZEWNĘTRZNEGO źródła odniesienia ????? ... jeśli tak to może pokaż jakiś schemat jak to podłączyłeś ?

jeśli chcesz żeby ci pomóc - to po pierwsze troszkę się uspokój i zdecyduj na jedno źródło - bo jak troszkę poczytasz w mojej książce, troszkę w jednym googlu troszkę w innym googlu a potem piszesz takie niestworzone fragmenty kodu - i to z komentarzami które nic nie mówią to nie dziw się że nie można zrozumieć co ty chcesz osiągnąć :(

A jeśli nie korzystasz z zewn. źródła odniesienia to robisz już jakieś totalne krzaki w kodzie i dlatego tym bardziej - jeśli chcesz abyśmy mogli sprowadzić dyskusję do tego samego poziomu to trzymajmy się wspólnego podstawowego kodu z książki inaczej nic nie uda mi się podpowiedzieć....

masz tu poniżej funkcję z książki do pomiaru na wybranym kanale - dlaczego nie zajrzysz do niej na stronę nr.238

[syntax=c]// DEFINICJA funkcji, która dokonuje pomiaru na wybranym kanale/wejściu
uint16_t pomiar(uint8_t kanal) {
// ustawienie wybranego kanału ADC w rejestrze ADMUX
ADMUX = (ADMUX & 0xF8) | kanal;
// START pomiaru przez ustawienie bitu ADSC w rejestrze ADCSR
ADCSR |= (1<<ADSC);
// oczekiwanie na koniec pomiaru (dopóki bit ADSC jest = 1)
while( ADCSR & (1<<ADSC) );
// po zakończeniu pomiaru, gdy bit ADSC=0, zwrócenie wyniku w postaci
// 16-to bitowej wartości z rejestrów ADCH oraz ADCL
return ADCW;
}[/syntax]

zobacz jak się robi komentarze - spróbuj tak samo zrobić w swoim kodzie ale przede wszystkim skorzystaj z tej właśnie funkcji zamiast się miotać i próbować 100x na sekundę różnych rozwiązań z gooogla

no i jak pisałem na początku

1. pokaż schemat żeby było widać z jakiego napięcia odniesienia korzystasz
2. pokaż kompletny kod

Statystyki: Napisane przez mirekk36 — 1 wrz 2012, o 21:23

]]> 2012-09-01T20:44:51+01:00 2012-09-01T20:44:51+01:00 https://forum.atnel.pl/viewtopic.php?t=1491&p=14234#p14234 <![CDATA[Re: Atmega8 dwa kanały ADC – problem z wartością ADCW]]> Przejrzałem cały projekt i na spokojnie poustawiałem wszystko co potrafiłem ustawić :)

O maskowaniu bitów i zerowaniu MUX3-0 miałem świadomość, tylko mogłem coś pokręcić bo czas na hobby znajduje tylko późnym wieczorem i najczęściej mocno się wszystko przedłuża jak coś nie idzie :D

Dzisiaj po pracy miałem trochę czasu i porobiłem eksperymenty, niestety nie udało mi się dokonać odczytów bezpośrednio po sobie na dwóch kanałach bez zakłóceń w wyniku pomimo zakończenia konwersji. Czekałem też na flagę przerwania która następnie kasowałem, ale to tez nic nie zmieniało. Może to wina mojego „laboratorium” bo wszystko jest na pająku ze skrętki na stykówce i może coś się wzbudza. W przypadku Atmegi8 czas jaki uzyskałem pomiędzy kolejnymi odczytami to jakieś 10-20 ms, poniżej tego co jakiś czas wyniki się miksują i występują nagłe skoki odczytu. W sumie nie ma to znaczenia dla mojego projektu bo odczyt z fotorezystora potrzebuje co jakiś czas w celu sprawdzenia oświetlenia, ale w przyszłości może zajść potrzeba szybkiego multipleksowania kanałów z ADC i będę miał problem. Poszukałem też trochę w googlu i znalazłem kilka wątków z podobnym problemem ale nikt tego dalej nie ciągną. Musze pobawić się ADC na atmedze32, może będzie jakaś różnica, albo popróbować free running.

Kod jak poniżej działa bez problemów, _delay wstawiony tylko do testów bo w programie oddzielam pomiary flagami.

Ustawienie ADC:
[syntax=c]
ADMUX = 0; //wyzerowanie ADMUX
ADMUX &= ~((1<<REFS1)|(1<<REFS0)); //zew. ref. 1,235v
ADCSRA = (1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); //128 preskaler[/syntax]

Wynik:
[syntax=c]
ADMUX&=0xF0; // ADMUX&=11110000 - maska MUX3..0 = 0000 czyli ADC 0
ADCSRA |= (1<<ADSC); //konwersja kanału 0
while( !(ADCSRA & (1<<ADSC)) );
ADC_0 = ADCW; //zmienna z pomiarem ADC0
_delay_ms(20);
ADMUX |=(1<<MUX0); // MUX3..0 = 0001 czyli ADC 1
ADCSRA |= (1<<ADSC);//konwersja kanału 1
while( !(ADCSRA & (1<<ADSC)) );
ADC_1=ADCW; // zmienna z pomiarem ADC1[/syntax]

Statystyki: Napisane przez Tomiplis — 1 wrz 2012, o 20:44

]]> 2012-08-31T23:26:26+01:00 2012-08-31T23:26:26+01:00 https://forum.atnel.pl/viewtopic.php?t=1491&p=14198#p14198 <![CDATA[Re: Atmega8 dwa kanały ADC – problem z wartością ADCW]]>

jak chcesz wybierać inny kanał to zawsze musisz zamaskować najpierw bity odpowiedzialne za wybór kanału, np


[syntax=c]ADMUX = (ADMUX & 0xF8) | kanal;[/syntax]

zakładając że w zmiennej kanał będziesz miał wartości od 0 do 7 możesz w ten sposób prawidłowo przełączać się pomiędzy kanałami. Bo chyba tutaj coś ci nie wychodzi prawda ?

Statystyki: Napisane przez mirekk36 — 31 sie 2012, o 23:26

]]> 2012-08-31T23:15:14+01:00 2012-08-31T23:15:14+01:00 https://forum.atnel.pl/viewtopic.php?t=1491&p=14194#p14194 <![CDATA[Atmega8 dwa kanały ADC – problem z wartością ADCW]]>
Z racji tego, że jest to mój pierwszy post na forum chciałem wszystkich serdecznie przywitać.

Ponieważ stawiam pierwsze kroki w programowaniu proszę o wyrozumiałość :) Dość późno zafascynował mnie świat programowania i elektroniki więc mam bardzo dużo do nadgonienia :)

Jestem po lekturze (kilkukrotnej :) ) książki Pana Mirka i jest to w moim odczuciu najprzyjaźniej napisany „poradnik” jaki miałem okazję studiować i jeden z lepszych prezentów które sobie wybrałem (bo znałem Mikołaja :D )

Wracając do sedna postu, mam pytanie odnośnie zmiany kanałów ADC (atmega8) w trybie pojedynczego odczytu. Prowadzę pracę nad mini komputerem do autka i napotkałem na problem z brakiem zmiany wartości w rejestrze ADCW. Pierwotnie robiłem w jednym przejściu funkcji (co 200ms) odczyty jeden po drugim i zawsze uzyskiwałem wartość pierwszego odczytu która była przypisywana do zmiennej ADC_LED i DISP_NAPIECIE . Po kilkugodzinnej walce doszedłem do poprawnego odczytu, lecz robię to w sposób „łopatologiczny” wykonując dwa odczyty z każdego kanału z czego tylko drugi jest przypisywany do zmiennej. Wszystko działa, jest napięcie a fotorezystor reaguje i zmniejsza podświetlenie, ale nurtuje mnie pytanie dlaczego pierwszy odczyt po zmianie kanału nie jest wpisywany do ADCW a dopiero drugi. Zapewne jest to gdzieś zapisane w PDF, lecz nie udało mi się tego odnaleźć. Kombinowałem z flagą ADIF ale to też nie przynosiło skutku, dawałem _delay pomiędzy odczyty. Zrobiłem też całkowite wyłączanie i ponowną inicjacje ADC pomiędzy odczytami, skutkowało to tylko problemami z multipleksowaniem wyświetlacza a wynik był z pierwszego odczytu w dwóch zmiennych.
Szukałem podobnego problemu na forum i nie udało mi się odnaleźć.

Kod jest trochę zaśmiecony bo ciągle cos dopisuję i kasuję :) W takiej postaci działa poprawnie.
[syntax=c]void przelicz(){
//****************napiecie***********************************************

static uint8_t adc_nr;
static uint8_t flagaadc;
static uint8_t flagaadc2;

if(adc_nr<2){
ADMUX |=(1<<MUX0); //ADC
ADCSRA |= (1<<ADSC); //odczyt ADC
while( !(ADCSRA & (1<<ADSC)) );
//while( (ADCSRA & (1<<ADIF)) );
if(flagaadc){
ADC_LED=ADCW;
}
flagaadc++;
flagaadc2=0;
}
else{
ADMUX &=~(1<<MUX0);
static uint8_t srednia[10]={0,0,0,0,0,0,0,0,0,0}; //adc
static uint8_t n, s;
uint16_t wynik1=0;
ADCSRA |= (1<<ADSC); //odczyt ADC
while( !(ADCSRA & (1<<ADSC)) );
//while( (ADCSRA & (1<<ADIF)) );
if(flagaadc2){
DISP_NAPIECIE = (ADCW*1206UL*13)/100000UL; //obliczenie napiecia dzielnik 13
srednia[n]=DISP_NAPIECIE; // srednia 10 pomiarow
for(uint8_t i=0;i<10;i++){
wynik1=wynik1+srednia[i];
}
n++;
if(n>9)n=0,s=1;
if(s)DISP_NAPIECIE=wynik1/10; // po 10 pomiarach usrednianie
}
flagaadc2++;
flagaadc=0;
}
++adc_nr;
if(adc_nr>3)adc_nr=0;

//**************predkosc*******************************************************[/syntax]

Statystyki: Napisane przez Tomiplis — 31 sie 2012, o 23:15

]]>