ATNEL tech-forum

Re: Zwiększenie liczby po przerwaniu

2012-12-17T18:50:39+01:00

Ok temat wydaje mi się rozwiązany. Dziękuje Krauser za pomoc. Wyślę Ci na pw link do filmiku jak to wygląda.

Statystyki: Napisane przez gedo — 17 gru 2012, o 18:50

Re: Zwiększenie liczby po przerwaniu

2012-12-15T22:27:52+01:00

Częstotliwość zmienia się o zadaną w (!check), tylko częstotliwość startowa jest zła.
Ustawiłem w SIGNALS[0][i] czyli sinus i początkowa częstotliwość to ~7kHz. Jak dałem na stale kwadrat to zaczyna 1kHz. Krauser bardzo fajny pomysł z tym temp_tab. Nie wiem czemu tak sinusa zaczyna od tak wysokiej częstotliwości.

Statystyki: Napisane przez gedo — 15 gru 2012, o 22:27

Re: Zwiększenie liczby po przerwaniu

2012-12-15T20:00:39+01:00

Proponuję:
[syntax=c]R2RPORT = pgm_read_byte(&SIGNALS[typ][akumulator >> 8]);[/syntax]
zstąpić:
[syntax=c]R2RPORT = temp_tab[akumulator >> 8];[/syntax]
a w warunku zmiany sygnału wypełniać temp_tab odpowiednią tablicą z pamięci programu:
[syntax=c]if(!check){
if (fout>19000){
fout=1000;
typ++; //zmiana o 1
if (typ>5) typ=0; // jeśli wartość wskaźnika jest większa niż 5 to zeruj
for(uint16_t i; i<256 ; i++)
temp_tab[i] = pgm_read_byte(&SIGNALS[typ][i]);
}
else fout=fout+1000;
deltaPhase=(fout/resolution);
check=~check;
}[/syntax]
Ta pętla for musi również znaleźć się na starcie programu.

Statystyki: Napisane przez Krauser — 15 gru 2012, o 20:00

Re: Zwiększenie liczby po przerwaniu

2012-12-15T17:42:40+01:00

Krauser, próbowałem coś podobnego ale bez użycia register. Dodanie tylko dwóch linijek:

Code:

typ++;
 if (typ>5) typ=0;

w pętli:

Code:

          if(!check){
                 if (fout>19000){
                     fout=1000;
                     typ++; //zmiana o 1
                     if (typ>5) typ=0; // jeśli wartość wskaźnika jest większa niż 5 to zeruj
                    }
                    else fout=fout+1000;

                deltaPhase=(fout/resolution);
                check=~check;
                }

powoduje spadek zadanej częstotliwość fout=1000 z 1kHz do 0.57kHz

wszystkie ingerencje w zmianę typu sygnału powodują spadek częstotliwości. 2 linijki w C będę musiał nadrobić kwarcem 16MHz -> 24MHz w Atmega8

Statystyki: Napisane przez gedo — 15 gru 2012, o 17:42

Re: Zwiększenie liczby po przerwaniu

2012-12-15T16:43:41+01:00

W 1 przypadku dostęp jest najwolniejszy bo skoro to zmienna z modyfikatorem volatile to może zmienić się w każdym momencie i co chwila jest odczytywana z pamięci do rejestrów. W drugim przypadku nie ma któregoś z odczytów, ale jak nie ma volatile to zmiana w przerwaniu nie zostanie zauważona przez pętlę główną. Trzeci przypadek zmienna lokalna jest przechowywana w rejestrze (chyba że jest ich dużo) i od razu można na niej wykonywać operacje. Powinieneś wszystkie operacje przeprowadzać w pętli głównej na zmiennych lokalnych. Możesz również spróbować dodać modyfikator register dla zmiennych do których dostęp ma być możliwie szybki.

[syntax=c]#define resolution 16
const uint8_t sinewave[] PROGMEM={} // tutaj tablica sinusa, mam takich 6 rożnych tablic

const uint8_t *SIGNALS[] ={ // wskazniki do tablic
sinewave,
squarewave,
trianglewave,
sawtoothwave,
rewsawtoothwave,
ECG
};

volatile uint8_t check // wskaźnik, volatile bo używam w przerwaniu

int main(void)
{
register uint16_t akumulator=0;
register uint16_t deltaPhase;
register uint16_t fout=1000;
register uint8_t typ=0; // zmienna typ która używana jet kilka linijek niżej do zmiany rodzaju sygnału. Gdy typ=1 to pobierany jest wskaźnik z tablicy SIGNALS o numerze 1

while(1){
while(check){
akumulator += deltaPhase;
R2RPORT = pgm_read_byte(&SIGNALS[typ][akumulator >> 8]);
}

if(!check){
if (fout>=19000){
fout=1000;
typ++; //zmiana o 1
if (typ>5) typ=0; // jeśli wartość wskaźnika jest większa niż 5 to zeruj
}
else fout=fout+2000;
deltaPhase=(fout/resolution);
check=~check;
}
}
}

ISR(TIMER1_COMPA_vect){
check=~check; // zmiana stanu flagi przerwania, gdy zmieni tą zmienną na 0 to w pętli while przechodzimy do obliczenia nowej wartości deltaPhase na podstawie zmienionej wartości
}[/syntax]

Statystyki: Napisane przez Krauser — 15 gru 2012, o 16:43

Re: Zwiększenie liczby po przerwaniu

2012-12-15T11:52:00+01:00

już odpowiadam, a do tego wyżej to i tak chyba nie działa, bo przypisałem na twardo w przerwaniu *wsk=7; czyli coś poza tablicą i pętla leci dalej a nie powinna?

robię teraz tak jak Pan pisze ( jest jakiś sposób aby zapisać znak and - shift+7 na forum bo pojawia się właśnie &)

Code:

volatile uint8_t typ=0;

Code:

R2RPORT = pgm_read_byte(&SIGNALS[typ][akumulator >> 8]);

a w przerwaniu

Code:

        
   typ++;
        if (typ>5) typ=0;

i częstotliwość mi spada dramatycznie, bo z zadanej 1kHz spada do 0.55kHz, czyli muszę znowu rozdzielczość obniżyć aby podnieść częstotliwość a to wiąże się z utratą ilości próbek na okres, czyli dostaje przysłowiowe "schodki". Chciałem zostawić resoulution na 16 i nie schodzić niżej a właśnie znaleźć sposób na tą zmianę rodzaju sygnału. Tego wyżej też próbowałem. Na koniec prób właśnie wyszły takie fikołki ze wskaźnikami.

Teraz przedstawię taki mój test. Umieszczam 3 rodzaje zmiennych:

1. volatile uint8_t typ1=0; zmienna globalna volatile
2. uint8_t typ2=0; zmienna globalna
3. uint8_t typ3=0; zmienna lokalna w main

i kolejno ręcznie podstawiam w linijce:
R2RPORT = pgm_read_byte(&SIGNALS[typ#][akumulator >> 8]);

I co uzyskuje na mierniku:
1. 0.55kHz
2. 0.78kHz
3. 1Khz

czyli to że zmienna jest globalna już powoduje mi spadek częstotliwości. Częstotliwość wyjściowa jest zależna od rozdzielczości a ta rozdzielczość od taktowania uC oraz ilości linijek kodu, więc widzicie Panowie, taka drobna zmiana i już mam gorszy sygnał.

Statystyki: Napisane przez gedo — 15 gru 2012, o 11:52

Re: Zwiększenie liczby po przerwaniu

2012-12-15T09:56:37+01:00

powiedz mi po co takie sztuczki cyrkowe - w ogóle niepotrzebne

[syntax=c]volatile uint8_t *wsk;

..................

int main(void)
{
uint8_t typ=0;

..................

wsk=&typ;[/syntax]

a potem w przerwaniu:

[syntax=c]*wsk++;

...........

if (*wsk>5) *wsk=0;[/syntax]

nie mówię, że to jest błąd - ale widać, że próbujesz sobie w GIGANTYCZNY sposób utrudniać życie dlaczego nie możesz zmiennej typ zrobić globalnej i volatile. Nie dość że nie będziesz musiał jej zerować jawnie to jeszcze posługiwać się nią i w przerwaniu i funkcji main()

Statystyki: Napisane przez mirekk36 — 15 gru 2012, o 09:56

Re: Zwiększenie liczby po przerwaniu

2012-12-15T04:31:52+01:00

Czy to ma prawo działać bo nie mam przy sobie oscyloskopu aby sprawdzić a weekend jest długi aby czekać. Wklejam tylko potrzebne linijki kodu, które są kluczowe. Do rzucenia okiem jest ta pętla while, przerwanie, oraz wskażnik wsk oraz zmienia typ. 4 rzeczy dla specjalistów.

[syntax=c]
#define resolution 16
const uint8_t sinewave[] PROGMEM={} // tutaj tablica sinusa, mam takich 6 roznych tablic

const uint8_t *SIGNALS[] ={ // wskazniki do tablic
sinewave,
squarewave,
trianglewave,
sawtoothwave,
rewsawtoothwave,
ECG
};

volatile uint8_t *wsk; // wskaźnik, volatile bo uzywam w przerwaniu

int main(void)
{
uint8_t typ=0; // zmienna typ która uzywana jet kilka linijek nizej do zmiany rodzaju sygnalu. Gdy typ=1 to pobierany jest wskaznik z tablicy SIGNALS o numerze 1
wsk=&typ; //przypisanie adresu do wskaznika

while(1){
while(check){
akumulator += deltaPhase;
R2RPORT = pgm_read_byte(&SIGNALS[typ][akumulator >> 8]);
}

if(!check){
deltaPhase=(fout/resolution);
check=~check;
}
}
}

ISR(TIMER1_COMPA_vect){
check=~check; // zmiana stanu flagi przerwania, gdy zmieni tą zmienną na 0 to w pętli while przechodzimy do obliczenia nowej wartości deltaPhase na podstawie zmienionej wartości fout w przerwaniu

if (check==0){
if (fout>=19000){ // pętla, gdy czestotliwosc wyjsciowa przekroczy 19kHz to zaczynamy od 1000 oraz zwiekszenie wartosci wskaznika gdy przekroczymy zakres = zmiana kształtu sygnału
fout=1000;
*wsk++; //zmiana wartosci wskaznika o 1
}
else fout=fout+2000;
}
if (*wsk>5) *wsk=0; // jesli wartość wskaznika jest wieksza niz 5 to zeruj
}
[/syntax]

Zostawiłem co potrzebne. Resztę kodu wyciąłem aby nikt nie musiał analizować i patrzeć na niepotrzebne.
Proszę mi odpowiedzieć czy zostanie w tej linijce R2RPORT = pgm_read_byte(&SIGNALS[typ][akumulator >> 8]); zmieniony sygnał np na kwadrat jak w przerwaniu częstotliwość dojdzie do 19kHz. Robię to w ten sposób bo każda inna zmiana jaką próbowałem BARDZO wpływa na częstotliwość wyjściową, po prostu ją obniża.

pgm_read_byte(&SIGNALS[typ][akumulator >> 8]); jak wpisze zamiast TYP:
1. np. 1 to działa super odwołując się do tablicy SIGNALS
2. jak dam tam zmienną zadeklarowaną w int main która to ma przypisane stałą wartość to również działa ok
3. Gdy zamiast typ wstawię wskaźnik do zmiennej mode która zmieniana jest w przerawniu to częstotliwość mi spada aż o POŁOWĘ
4. Gdy w przerwaniu będę zmieniał jakąś zmienną o 1 np mode po każdym przekroczeniu a potem tą zmienną użyję w SIGNALS[typ] zamiast typ to również częstotliwość mi spada.

Statystyki: Napisane przez gedo — 15 gru 2012, o 04:31

Re: Zwiększenie liczby po przerwaniu

2012-12-14T22:17:21+01:00

dzięki Krauser działa, muszę popracować nad zmniejszeniem programu bo zajmuje już za dużo. Zaraz popatrzę na to resolution

teraz zamierzam dodać kolejne tabelę z innymi kształtami + zmiana tabeli po przejściu do częstotliwości granicznej.

edit
w przerwaniu po osiągnięciu maksymalnej częstotliwości zmieniam wartość zmiennej mode o jeden. Ma to na celu zmienić typ sygnału. O w tej linijce:
R2RPORT = pgm_read_byte(&sinewave[akumulator >> 8]); jak teraz optymalnie podmieniać pogrubione w zależności od mode

mode to volatile uint8_t mode=0; <- zmieniane w przerwaniu

wpadłem na pomysł zrobienia takiej tablicy

Code:

const uint8_t *SIGNALS[] ={
   sinewave,
   squarewave,
   trianglewave,
   sawtoothwave,
   rewsawtoothwave,
   ECG
};

utworzeniu zmiennej globalnej uint8_t *wsk;, przypisania adresu wsk=&mode a następnie takiego odwołania R2RPORT = pgm_read_byte(&SIGNALS[*wsk][akumulator >> 8]);

Nie jestem dziś sprawdzić czy typ sygnału się zmienia, w pon będę miał dostęp do oscyloskopu.

No i dostaje przy wsk=&mode; warning assignment discards qualifiers from pointer target type

Może ktoś ma inny pomysł jak podmienić rodzaj sygnału najprościej.

każda podmiana w &SIGNALS[] w nawiasach kwadratowych jakąś zmienną powoduje spadek częstotliwości z 1kHz dla do 0.57kHz. Jak wpisze &SIGNALS[1] to jest równo 1kHz. Jak podmienić wartość w nawiasach bez spadku wydajność?

Statystyki: Napisane przez gedo — 14 gru 2012, o 22:17

Re: Zwiększenie liczby po przerwaniu

2012-12-14T10:03:18+01:00

[syntax=c]while(1){
while(check){
akumulator += deltaPhase;
R2RPORT = sinewave[akumulator >> 8];
}
if(!check){
deltaPhase=(fout/resolution);
check=~check;
}
}[/syntax]
A z tym #define resolution 16.2 to nie da się nic zrobić? Przecież wystarczy dać #define resolution 162 i podczas działań na fout wynik pomnożyć razy 10 albo lepiej najpierw pomnożyć razy 10UL i później podzielić przez resolution

Statystyki: Napisane przez Krauser — 14 gru 2012, o 10:03

Zwiększenie liczby po przerwaniu

2012-12-13T19:47:48+01:00

Mam prosty kod w C który generuje częstotliwości, chce aby po każdym przerwaniu zwiększać częstotliwość o 1kHz. Przerwanie wykonuje się przy porównaniu z maksymalną wartością OCR1A. Kod musi być najprostszy bo każde linijki kodu powodują zmniejszenie rozdzielczości wyjściowej i dostaje "schodki" na wyjściu. Program wchodzi w pętle i generuje częstotliwość ale chce uzyskać efekt, że przerwanie zmienia zmienną częstotliwość i ta się zmienia zmienia na wyjściu.

[syntax=c]
int main(void)
{
R2RDDR = 0xff;
uint16_t akumulator=0;
uint16_t deltaPhase;
uint16_t fout=15000;

//************* licznik TIMER1 *******************
TCCR1B |= (1<TCCR1B |= (1<TIMSK |= (1<OCR1A=65535; //wartosc zliczania rowna 1s dla 16MHz
sei(); // zezwolenie na globalne przerwania

// wybieranie czestotliwosc
deltaPhase=(fout/resolution); // wartosc kroku w zaleznosci od czesotliwosci wyjsciowej

while(1){
akumulator += deltaPhase;
R2RPORT = sinewave[akumulator >> 8];
}
}

ISR(TIMER1_COMPA_vect){
//przerwanie
}
[/syntax]

Jak najprościej zwiększyć częstotliwość w tym while? Próbowałem przez cały dzień wiele sposobów.

czy można ustawić w przerwaniu odpowiednią flagę, lub ustawić wskaźnik który zmieni wartość pod np. deltaphase podczas przerwania?

Moje ostatnie próby to:

[syntax=c]
#include
#include
#include
#include
#include
#include

#define R2RPORT PORTD
#define R2RDDR DDRD

#define resolution 16.2

const uint8_t sinewave[] =
{
0x80,0x83,0x86,0x89,0x8c,0x8f,0x92,0x95,0x98,0x9c,0x9f,0xa2,0xa5,0xa8,0xab,0xae,
0xb0,0xb3,0xb6,0xb9,0xbc,0xbf,0xc1,0xc4,0xc7,0xc9,0xcc,0xce,0xd1,0xd3,0xd5,0xd8,
0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xed,0xef,0xf0,0xf2,0xf3,0xf5,
0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfc,0xfd,0xfe,0xfe,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xfe,0xfd,0xfc,0xfc,0xfb,0xfa,0xf9,0xf8,0xf7,
0xf6,0xf5,0xf3,0xf2,0xf0,0xef,0xed,0xec,0xea,0xe8,0xe6,0xe4,0xe2,0xe0,0xde,0xdc,
0xda,0xd8,0xd5,0xd3,0xd1,0xce,0xcc,0xc9,0xc7,0xc4,0xc1,0xbf,0xbc,0xb9,0xb6,0xb3,
0xb0,0xae,0xab,0xa8,0xa5,0xa2,0x9f,0x9c,0x98,0x95,0x92,0x8f,0x8c,0x89,0x86,0x83,
0x80,0x7c,0x79,0x76,0x73,0x70,0x6d,0x6a,0x67,0x63,0x60,0x5d,0x5a,0x57,0x54,0x51,
0x4f,0x4c,0x49,0x46,0x43,0x40,0x3e,0x3b,0x38,0x36,0x33,0x31,0x2e,0x2c,0x2a,0x27,
0x25,0x23,0x21,0x1f,0x1d,0x1b,0x19,0x17,0x15,0x13,0x12,0x10,0x0f,0x0d,0x0c,0x0a,
0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x03,0x02,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x02,0x03,0x03,0x04,0x05,0x06,0x07,0x08,
0x09,0x0a,0x0c,0x0d,0x0f,0x10,0x12,0x13,0x15,0x17,0x19,0x1b,0x1d,0x1f,0x21,0x23,
0x25,0x27,0x2a,0x2c,0x2e,0x31,0x33,0x36,0x38,0x3b,0x3e,0x40,0x43,0x46,0x49,0x4c,
0x4f,0x51,0x54,0x57,0x5a,0x5d,0x60,0x63,0x67,0x6a,0x6d,0x70,0x73,0x76,0x79,0x7c
};

const uint8_t squarewave[]= //square wave
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
};

const uint8_t *SIGNALS[] ={
sinewave,
squarewave
};

volatile uint8_t check=0;
volatile uint16_t fout=1000;

int main(void)
{
R2RDDR = 0xff;
uint16_t akumulator=0;
uint16_t deltaPhase;

//************* licznik TIMER1 *******************
TCCR1B |= (1<TCCR1B |= (1<TIMSK |= (1<OCR1A=65535; //wartosc zliczania rowna 1s dla 16MHz
sei(); // zezwolenie na globalne przerwania

// wybieranie czestotliwosc
deltaPhase=(fout/resolution); // wartosc kroku w zaleznosci od czesotliwosci wyjsciowej

while(1){
while(check){
akumulator += deltaPhase;
R2RPORT = sinewave[akumulator >> 8];
}
}

}

ISR(TIMER1_COMPA_vect){
check=~check;
if (check==0)
{
if (fout>=50000) fout=1000;
else fout=fout+1000;
}
}
[/syntax]

Poprawiłem znaczniki [syntax=c ] a nie syntax= C SunRiver

Statystyki: Napisane przez gedo — 13 gru 2012, o 19:47