ATNEL tech-forum 2016-10-09T20:42:49+01:00 https://forum.atnel.pl/feed.php?f=30&t=16435&mode 2016-10-09T20:42:49+01:00 2016-10-09T20:42:49+01:00 https://forum.atnel.pl/viewtopic.php?t=16435&p=171076#p171076 <![CDATA[Re: problem z częstotliwością przełączania]]> tomcat65 napisał(a):

ale funkcje ISR piszemy na początku.


Zdecydowanie wolę na początku główną funkcję main() dla porządku. A ISR() po niej albo w ogóle w osobnym pliku

Statystyki: Napisane przez mirekk36 — 9 paź 2016, o 20:42

]]> 2016-10-09T19:51:02+01:00 2016-10-09T19:51:02+01:00 https://forum.atnel.pl/viewtopic.php?t=16435&p=171068#p171068 <![CDATA[Re: problem z częstotliwością przełączania]]> Pierwszy to mój post na tym forum.
Nie wnikam w kod - za długi :), ale funkcje ISR piszemy na początku.

Statystyki: Napisane przez tomcat65 — 9 paź 2016, o 19:51

]]> 2016-10-09T17:47:04+01:00 2016-10-09T17:47:04+01:00 https://forum.atnel.pl/viewtopic.php?t=16435&p=171024#p171024 <![CDATA[Re: problem z częstotliwością przełączania]]>
#define F_CPU 8000000UL

TEGO BADZIEWIA NIGDY NIE PISZE się w kodzie programu ... i moja gorąca prośba - jeśli już będziesz się upierał przy tym to przynajmniej jak będziesz wklejał swoje kody na to forum to wywalaj to z kodu ok ? A później błędów szukaj sam ... albo

... albo obejrzyj dokładnie to:

iframe

Statystyki: Napisane przez mirekk36 — 9 paź 2016, o 17:47

]]> 2016-10-09T17:40:19+01:00 2016-10-09T17:40:19+01:00 https://forum.atnel.pl/viewtopic.php?t=16435&p=171023#p171023 <![CDATA[problem z częstotliwością przełączania]]>
Usiłuję z płytki arduino pro mini z mikroprocesorem atmega328p zrobić uniwersalny sterownik silników krokowych z regulowaną częstotliwością przełączania za pomocą potencjometru od 0 do 1000 Hz.
Potrafię tak zaprogramować na konkretną częstotliwość lub żeby sie zmieniała w ograniczonym zakresie (wykorzystując przerwania) i wtedy działa. Albo z ograniczoną rozdzielczością przełączania (początkowe wartości fajnie się dzielą przez 2 później już gorzej) jednak mnie interesuje pełna rozdzielczość (1,2,3,456,789,998,999 itp.).
Po nieudanych eksperymentach z próbą regulacji w przerwaniu (przerwanie działało, regulacja już nie) spróbowałem zrobić licznik do liczby 8000000 przy założeniu że częstotliwość taktowania procesora wynosi 8000000Hz. Wtedy czas przełączania wynosiłby idealnie 1 sekundę o ile sie nie myle xd a 8000000 fajnie by sie dzieliło przez 2 żeby potem elegancko uzyskać kolejne częstotliwości przełączania w kierunku 1000Hz. Niestety, albo diody śmigają za szybko albo za wolno.
Zacząłem podejżewać iż procesor atmega328p nie przechowuje tak dużych liczb i dlatego poprawne jej porównanie w liczniku nie jest możliwe więc próbowałem rodzdzielić ten licznik na dwie części tj. licznik w liczniku ale to też niewiele dało... diody świecą się cały czas.

Program piszę w eclipsie a wgrywam mkAVRcalculatorem (częstotliwość taktowania 8kHz zaznaczona w fusebitach) korzystając z USBasp.

[syntax=c]/*[/syntax]

Quote:

#define F_CPU 8000000UL <--- tego NIGDY nie pisze się w kodzie


[syntax=c]#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define wybortrybu PC2
#define wyborkierunku PC3

volatile uint8_t krok = 0;
volatile uint8_t tryb = 1;
volatile uint8_t kierunek = 1;
volatile unsigned int adc, x;
volatile unsigned int licznik = 0;

int main(void) {

//inicjalizacja ADC
ADMUX |= (1 << REFS0);
ADCSRA = (1 << ADEN) | (1 << ADATE) | (1 << ADSC) | (1 << ADIE)
| (1 << ADPS0) | (1 << ADPS1) | (1 << ADPS2);
DDRC &= ~(1 << PC0);

// ustawienie timer1
TCCR1B |= (1 << CS10);

// ustawienie timer0 pwm
TCCR0A |= (1 << COM0A1) | (1 << COM0B1);
TCCR0A |= (1 << WGM01) | (1 << WGM00);
TCCR0B |= (1 << CS00);
DDRD |= (1 << DDD6);
DDRD |= (1 << DDD5);

// ustawienie timer2 pwm
TCCR2A |= (1 << COM2A1) | (1 << COM2B1);
TCCR2A |= (1 << WGM21) | (1 << WGM20);
TCCR2B |= (1 << CS20);
DDRD |= (1 << DDD3);
DDRB |= (1 << DDB3);

//ustawienie wyjśc początkowe
OCR2B = 255;
OCR0B = 255;
OCR0A = 255;
OCR2A = 255;

//ustawienie wejśc pod przyciski i rezystorów podciągających
DDRC &= ~(1 << wybortrybu);
PORTC |= (1 << wybortrybu);
DDRC &= ~(1 << wyborkierunku);
PORTC |= (1 << wyborkierunku);

while (1) {

//obsługa wyboru trybów i kierunku (zerowanie bądź ustawianie liczników)
if (tryb == 1 && kierunek == 1 && krok >= 4)
krok = 0;
if (tryb == 1 && kierunek == 2 && krok == 1)
krok = 5;

if (tryb == 2 && kierunek == 1 && krok >= 4)
krok = 0;
if (tryb == 2 && kierunek == 2 && krok == 1)
krok = 5;

if (tryb == 3 && kierunek == 1 && krok >= 8)
krok = 0;
if (tryb == 3 && kierunek == 2 && krok == 1)
krok = 9;

if (tryb == 4 && kierunek == 1 && krok >= 16)
krok = 0;
if (tryb == 4 && kierunek == 2 && krok == 1)
krok = 17;
//////////////////////////////////////////////////////////////////// TO NIE DZIAŁA
if (ADC > 0) {

if (TCNT1 >= x) {
licznik++;

if (licznik >= adc) {

if (kierunek == 1)
krok++;
if (kierunek == 2)
krok--;

licznik = 0;
}
TCNT1=0;
}
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////

//obsługa przycisku wyboru trybu
while (!(PINC & (1 << wybortrybu))) {

TCCR2A |= (1 << COM2B1);
TCCR0A |= (1 << COM0B1);
TCCR0A |= (1 << COM0A1);
TCCR2A |= (1 << COM2A1);

if (tryb == 4)
tryb = 0;
tryb++;

}

//obsługa przycisku wyboru kierunku
while (!(PINC & (1 << wyborkierunku))) {
if (kierunek == 2)
kierunek = 0;
kierunek++;

}

//tryb falowy ////////////////////////////////////////////////////////////////////////////
OCR2B = 255;
OCR0B = 255;
OCR0A = 255;
OCR2A = 255;

if (krok == 1 && tryb == 1) {
TCCR2A |= (1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}

if (krok == 2 && tryb == 1) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A |= (1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}

if (krok == 3 && tryb == 1) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A |= (1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}

if (krok == 4 && tryb == 1) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A |= (1 << COM2A1);
}

//tryb pełny krok ////////////////////////////////////////////////////////////////////////////
OCR2B = 255;
OCR0B = 255;
OCR0A = 255;
OCR2A = 255;

if (krok == 1 && tryb == 2) {
TCCR2A |= (1 << COM2B1);
TCCR0A |= (1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}

if (krok == 2 && tryb == 2) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A |= (1 << COM0B1);
TCCR0A |= (1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}

if (krok == 3 && tryb == 2) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A |= (1 << COM0A1);
TCCR2A |= (1 << COM2A1);
}

if (krok == 4 && tryb == 2) {
TCCR2A |= (1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A |= (1 << COM2A1);
}

//tryb półkrok (1/2 kroku) ////////////////////////////////////////////////////////////////////////////
OCR2B = 255;
OCR0B = 255;
OCR0A = 255;
OCR2A = 255;

if (krok == 1 && tryb == 3) {
TCCR2A |= (1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}

if (krok == 2 && tryb == 3) {
TCCR2A |= (1 << COM2B1);
TCCR0A |= (1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}

if (krok == 3 && tryb == 3) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A |= (1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}

if (krok == 4 && tryb == 3) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A |= (1 << COM0B1);
TCCR0A |= (1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 5 && tryb == 3) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A |= (1 << COM0A1);
TCCR2A &= ~(1 << COM2A1);
}

if (krok == 6 && tryb == 3) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A |= (1 << COM0A1);
TCCR2A |= (1 << COM2A1);
}

if (krok == 7 && tryb == 3) {
TCCR2A &= ~(1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A |= (1 << COM2A1);
}

if (krok == 8 && tryb == 3) {
TCCR2A |= (1 << COM2B1);
TCCR0A &= ~(1 << COM0B1);
TCCR0A &= ~(1 << COM0A1);
TCCR2A |= (1 << COM2A1);
}

//tryb mikrokrok (1/4 kroku) ////////////////////////////////////////////////////////////////////////////
if (krok == 1 && tryb == 4) {
OCR2B = 255;
TCCR2A |= (1 << COM2B1);
OCR0B = 255;
TCCR0A &= ~(1 << COM0B1);
OCR0A = 255;
TCCR0A &= ~(1 << COM0A1);
OCR2A = 255;
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 2 && tryb == 4) {
OCR2B = 235;
TCCR2A |= (1 << COM2B1);
OCR0B = 96;
TCCR0A |= (1 << COM0B1);
OCR0A = 255;
TCCR0A &= ~(1 << COM0A1);
OCR2A = 255;
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 3 && tryb == 4) {
OCR2B = 181;
TCCR2A |= (1 << COM2B1);
OCR0B = 181;
TCCR0A |= (1 << COM0B1);
OCR0A = 255;
TCCR0A &= ~(1 << COM0A1);
OCR2A = 255;
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 4 && tryb == 4) {
OCR2B = 96;
TCCR2A |= (1 << COM2B1);
OCR0B = 235;
TCCR0A |= (1 << COM0B1);
OCR0A = 255;
TCCR0A &= ~(1 << COM0A1);
OCR2A = 255;
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 5 && tryb == 4) {
OCR2B = 255;
TCCR2A &= ~(1 << COM2B1);
OCR0B = 255;
TCCR0A |= (1 << COM0B1);
OCR0A = 255;
TCCR0A &= ~(1 << COM0A1);
OCR2A = 255;
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 6 && tryb == 4) {
OCR2B = 255;
TCCR2A &= ~(1 << COM2B1);
OCR0B = 235;
TCCR0A |= (1 << COM0B1);
OCR0A = 96;
TCCR0A |= (1 << COM0A1);
OCR2A = 255;
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 7 && tryb == 4) {
OCR2B = 255;
TCCR2A &= ~(1 << COM2B1);
OCR0B = 181;
TCCR0A |= (1 << COM0B1);
OCR0A = 181;
TCCR0A |= (1 << COM0A1);
OCR2A = 255;
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 8 && tryb == 4) {
OCR2B = 255;
TCCR2A &= ~(1 << COM2B1);
OCR0B = 96;
TCCR0A |= (1 << COM0B1);
OCR0A = 235;
TCCR0A |= (1 << COM0A1);
OCR2A = 255;
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 9 && tryb == 4) {
OCR2B = 255;
TCCR2A &= ~(1 << COM2B1);
OCR0B = 255;
TCCR0A &= ~(1 << COM0B1);
OCR0A = 255;
TCCR0A |= (1 << COM0A1);
OCR2A = 255;
TCCR2A &= ~(1 << COM2A1);
}
if (krok == 10 && tryb == 4) {
OCR2B = 255;
TCCR2A &= ~(1 << COM2B1);
OCR0B = 255;
TCCR0A &= ~(1 << COM0B1);
OCR0A = 235;
TCCR0A |= (1 << COM0A1);
OCR2A = 96;
TCCR2A |= (1 << COM2A1);
}
if (krok == 11 && tryb == 4) {
OCR2B = 255;
TCCR2A &= ~(1 << COM2B1);
OCR0B = 255;
TCCR0A &= ~(1 << COM0B1);
OCR0A = 181;
TCCR0A |= (1 << COM0A1);
OCR2A = 181;
TCCR2A |= (1 << COM2A1);
}
if (krok == 12 && tryb == 4) {
OCR2B = 255;
TCCR2A &= ~(1 << COM2B1);
OCR0B = 255;
TCCR0A &= ~(1 << COM0B1);
OCR0A = 96;
TCCR0A |= (1 << COM0A1);
OCR2A = 235;
TCCR2A |= (1 << COM2A1);
}
if (krok == 13 && tryb == 4) {
OCR2B = 255;
TCCR2A &= ~(1 << COM2B1);
OCR0B = 255;
TCCR0A &= ~(1 << COM0B1);
OCR0A = 255;
TCCR0A &= ~(1 << COM0A1);
OCR2A = 255;
TCCR2A |= (1 << COM2A1);
}
if (krok == 14 && tryb == 4) {
OCR2B = 96;
TCCR2A |= (1 << COM2B1);
OCR0B = 255;
TCCR0A &= ~(1 << COM0B1);
OCR0A = 255;
TCCR0A &= ~(1 << COM0A1);
OCR2A = 235;
TCCR2A |= (1 << COM2A1);
}
if (krok == 15 && tryb == 4) {
OCR2B = 181;
TCCR2A |= (1 << COM2B1);
OCR0B = 255;
TCCR0A &= ~(1 << COM0B1);
OCR0A = 255;
TCCR0A &= ~(1 << COM0A1);
OCR2A = 181;
TCCR2A |= (1 << COM2A1);
}
if (krok == 16 && tryb == 4) {
OCR2B = 235;
TCCR2A |= (1 << COM2B1);
OCR0B = 255;
TCCR0A &= ~(1 << COM0B1);
OCR0A = 255;
TCCR0A &= ~(1 << COM0A1);
OCR2A = 96;
TCCR2A |= (1 << COM2A1);
}
}

}

//obsługa przerwania po zakończeniu konwersji ADC
ISR(ADC_vect) {
adc = ADC;


if (ADC <= 100){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=8000;
adc = 1000 / adc;
}

if ((ADC <= 101) && (ADC<=200)){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=4000;
adc = 1000 / (adc-100);
}

if ((ADC <= 201) && (ADC<=300)){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=2000;
adc = 1000 / (adc-200);
}

if ((ADC <= 301) && (ADC<=400)){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=1000;
adc = 1000 / (adc-300);
}

if ((ADC <= 401) && (ADC<=500)){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=500;
adc = 1000 / (adc-400);
}

if ((ADC <= 501) && (ADC<=600)){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=250;
adc = 1000 / (adc-500);
}

if ((ADC <= 601) && (ADC<=700)){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=125;
adc = 1000 / (adc-600);
}

if ((ADC <= 701) && (ADC<=800)){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=62;
adc = 1000 / (adc-700);
}

if ((ADC <= 801) && (ADC<=900)){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=31;
adc = 1000 / (adc-800);
}

if ((ADC <= 901) && (ADC<=1000)){
if (adc > 1000)
adc = 1000;
if (adc == 0)
adc = 1;
x=15;
adc = 1000 / (adc-900);
}
}[/syntax]

zdjęcie:
Obrazek

No i to w sumie tyle. Bardzo proszę kogokolwiek o konstruktywną krytykę i pomoc w rozwiązaniu problemu (bądź też podanie innego działającego sposobu).

Statystyki: Napisane przez Karlislaw — 9 paź 2016, o 17:40

]]>