ATNEL tech-forum 2014-03-25T16:02:26+01:00 https://forum.atnel.pl/feed.php?f=8&t=5404&mode 2014-03-25T16:02:26+01:00 2014-03-25T16:02:26+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=75709#p75709 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Krauser napisał(a):

zmienna = zmienna + 10;
do tego samego doszedłem właśnie rano przy wizycie w wc że brakowało mi miejsca gdzie ma ta nowa wartość być umieszczona i że to tak w locie się nie dzieje :]

Statystyki: Napisane przez L.h.michalak — 25 mar 2014, o 16:02

]]> 2014-03-25T08:59:56+01:00 2014-03-25T08:59:56+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=75665#p75665 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> ++zmienna;
to jest to samo co:
zmienna = zmienna + 1;

Linia:
zmienna + 10;
nic nie robi, a dopiero:
zmienna = zmienna + 10;
lub:
zmienna += 10;

Statystyki: Napisane przez Krauser — 25 mar 2014, o 08:59

]]> 2014-03-24T13:24:56+01:00 2014-03-24T13:24:56+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=75565#p75565 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]>
[syntax=c]/*
* main.c
*
* Created on: 02-01-2014
* Author: Administrator
*/
#include <avr/io.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include <util/delay.h>


#define PWM_1 (1<<PB7)
#define WEJ (1<<PD7)
#define LED_2 (1<<PD4)
#define LED_2_TOG PORTD ^= LED_2

#define KL_1 (1<<PB0)
#define KL_2 (1<<PB1)
#define KL_3 (1<<PB2)
#define KL_4 (1<<PB4)

#define KEY_DOWN1 !(PINB & KL_1)
#define KEY_DOWN2 !(PINB & KL_2)
#define KEY_DOWN3 !(PINB & KL_3)
#define KEY_DOWN4 !(PINB & KL_4)

volatile uint16_t zmienna;
volatile uint8_t imp_na_sek;

int main(void)
{
//wewnętrzny prescaler CPU
CLKPR = (1<<CLKPCE);
//prescaler = 1
CLKPR = 0;

//ustawienie czujnika
//DDRD &= ~WEJ; //ustawienie portu jako wejście
DDRD |= LED_2 ; wbudowana led jako kontrolka
PORTD |= WEJ | LED_2;//wybrany pin 7 do odczytu, podciagnięcie do Vcc


DDRB |= PWM_1; //ustawienie portu B jako wyjście, pin 7
PORTB |= KL_1 | KL_2 | KL_3 | KL_4 ; // podciągnięcie do Vcc klawiszy

//ustawienia licznika 0 tryb zwykłej pracy
// ustawienie licznika 2 odczyt stanu licznika 0

TCCR0A = 0;
TCCR0B |= (1<<CS02) | (1<<CS01) | (1<<CS00); // zewnętrzny zegar wejcie T0 (D7), rosnące zbocze
//timer2 jako timer systemowy 10ms
OCR2A = F_CPU/100/1024 -1 ; //77.125
TCCR2A |= (1<<WGM21); //tryb CTC
TCCR2B |= (1<<CS22) |(1<<CS21) |(1<<CS20); //preskaler 1024
TIMSK2 |= (1<<OCIE2A); //włącz przerwania
sei();

// ustawienie licznika 1 do PWM OCR na TOP, preskaler 1024
TCCR1A |= (1<<COM1C1) | (1<<WGM11) | (1<<WGM10);
TCCR1B |= (1<<WGM12) | (1<<WGM13)| (1 << CS12)| (1<<CS10) ;

//przerwania
PCICR |= (1<<PCIE0); //zezwolenie na przerwania PCINT
PCMSK0 |= (1<<PCINT0) | (1<<PCINT1) | (1<<PCINT2) | (1<<PCINT3); // przerwania na portach B 0.1.2.3

while(1)
{
//zmienna= 250;
OCR1A=zmienna;
OCR1C=zmienna/4;
}
}

ISR(TIMER2_COMPA_vect)
{
//raz na 10ms
static uint8_t licznik;
licznik++;
if(licznik >= 100)
{
//raz 5 sekund
licznik = 0;
imp_na_sek = TCNT0; //odczytaj wartość licznika timera0
TCNT0 = 0;
LED_2_TOG;
}

}

ISR(PCINT0_vect)
{
if (KEY_DOWN1)
{
_delay_ms(80);
if (KEY_DOWN1) {++zmienna;}
}
if (KEY_DOWN2)
{
_delay_ms(80);
if (KEY_DOWN2) {--zmienna;}
}
}[/syntax]

Statystyki: Napisane przez L.h.michalak — 24 mar 2014, o 13:24

]]> 2014-03-12T19:56:44+01:00 2014-03-12T19:56:44+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=74030#p74030 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Statystyki: Napisane przez Krauser — 12 mar 2014, o 19:56

]]> 2014-03-11T18:39:21+01:00 2014-03-11T18:39:21+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=73873#p73873 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Statystyki: Napisane przez L.h.michalak — 11 mar 2014, o 18:39

]]> 2014-03-07T18:57:29+01:00 2014-03-07T18:57:29+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=73336#p73336 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Statystyki: Napisane przez Krauser — 7 mar 2014, o 18:57

]]> 2014-03-07T16:00:34+01:00 2014-03-07T16:00:34+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=73322#p73322 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Statystyki: Napisane przez L.h.michalak — 7 mar 2014, o 16:00

]]> 2014-03-06T00:27:58+01:00 2014-03-06T00:27:58+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=73174#p73174 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Statystyki: Napisane przez L.h.michalak — 6 mar 2014, o 00:27

]]> 2014-03-05T21:40:19+01:00 2014-03-05T21:40:19+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=73149#p73149 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Statystyki: Napisane przez Krauser — 5 mar 2014, o 21:40

]]> 2014-03-04T16:03:58+01:00 2014-03-04T16:03:58+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=73007#p73007 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]>
Czerwony wykres to sygnały z otrzymywane z czujnika, niebieski z wyjścia na PB7

http://youtu.be/bR0odEvDcWA

i jeszcze wersja programu z testu
[syntax=c]/*
* main.c
*
* Created on: 02-01-2014
* Author: Administrator
*/
#include <avr/io.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include <util/delay.h>


#define PWM_1 (1<<PB7)

volatile uint8_t zmienna;
volatile uint8_t imp_na_sek;

int main(void)
{
//wewnętrzny prescaler CPU
CLKPR = (1<<CLKPCE);
//prescaler = 1
CLKPR = 0;

//ustawienie czujnika
DDRD &= ~(1<<PD7); //ustawienie portu jako wejście
PORTD |= (1<<PD7);//wybrany pin 7 do odczytu, podciagnięcie do Vcc

DDRB |= PWM_1; //ustawienie portu B jako wyjście, pin 7


//ustawienia licznika 0 tryb zwykłej pracy
// ustawienie licznika 2 odczyt stanu licznika 0

TCCR0A = 0;
TCCR0B |= (1<<CS02) | (1<<CS01)| (1<<CS00); // zewnętrzny zegar wejcie T0 (D7), rosnące zbocze
//timer2 jako timer systemowy 10ms
OCR2A = F_CPU/100/1024 -1 ; //77.125
TCCR2A |= (1<<WGM21); //tryb CTC
TCCR2B |= (1<<CS22) |(1<<CS21) |(1<<CS20); //preskaler 1024
TIMSK2 |= (1<<OCIE2A); //włącz przerwania
sei();

// ustawienie licznika 1 do PWM OCR na TOP, preskaler 1024
TCCR1A |= (1<<COM1C1) | (1<<COM1C0) | (1<<WGM11) | (1<<WGM10);
TCCR1B |= (1<<WGM12) | (1<<WGM13)| (1 << CS12) | (1<<CS10);


while(1)

{
zmienna= 255 - imp_na_sek;
OCR1A=zmienna;
OCR1C=zmienna/2;
}
}

ISR(TIMER2_COMPA_vect)
{
//raz na 10ms
static uint8_t licznik;
licznik++;
if(licznik >= 100)
{
//raz 5 sekund
licznik = 0;
imp_na_sek = TCNT0; //odczytaj wartość licznika timera0
TCNT0 = 0;
}
}[/syntax]

w pętli głównej przy zapisaniu [syntax=c]OCR1A=imp_na_sek;
OCR1C=imp_na_sek/2;[/syntax] sygnał pwm zachowuje się tak samo

Statystyki: Napisane przez L.h.michalak — 4 mar 2014, o 16:03

]]> 2014-02-26T19:08:13+01:00 2014-02-26T19:08:13+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=72162#p72162 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> L.h.michalak napisał(a):

a czemu tutaj akurat OCR1A i OCR1C do ustawiania wypełnienia i czasu?

Bo tak jest w specyfikacji procesora przy opisie fast PWM dla trybu 15. Jak wybierzesz inny tryb to będzie inaczej.
50% możesz też generować na nóżce OC1A dla tego trybu i nie korzystać z innego rejestru do ustawiania wypełnienia. Wystarczy, że ustawisz bity COM1A1 i COM1A0 na 0 i 1. Wtedy przy każdym doliczeniu timera do OCR1A wyprowadzenie OC1A zmieni stan na przeciwny.

Statystyki: Napisane przez Krauser — 26 lut 2014, o 19:08

]]> 2014-02-26T18:06:23+01:00 2014-02-26T18:06:23+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=72155#p72155 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Statystyki: Napisane przez L.h.michalak — 26 lut 2014, o 18:06

]]> 2014-02-25T19:13:53+01:00 2014-02-25T19:13:53+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=72032#p72032 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> L.h.michalak napisał(a):

[syntax=c]// ustawienie licznika 1 do PWM OCR na TOP, preskaler 1024
   TCCR1A |= (1<<COM1C1) | (1<<COM1C0) | (1<<WGM11) | (1<<WGM10);
   TCCR1B |= (1<<WGM12) | (1<<WGM13)| (1 << CS12) | (1<<CS10);[/syntax]

W tym trybie zresztą jak sam piszesz to OCR1A wyznacza TOP, więc powinno to wyglądać tak:
[syntax=c]OCR1A=imp_na_sek;
OCR1C=imp_na_sek/2;[/syntax]
To bardzo dobry tryb, bo OCR1A jest buforowany w przeciwieństwie do ICR1, a tutaj TOP ciągle się zmienia.

Statystyki: Napisane przez Krauser — 25 lut 2014, o 19:13

]]> 2014-02-25T16:47:59+01:00 2014-02-25T16:47:59+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=72014#p72014 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]>
[syntax=c]/*
* main.c
*
* Created on: 02-01-2014
* Author: Administrator
*/
#include <avr/io.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include <util/delay.h>


#define PWM_1 (1<<PB7)

volatile uint8_t imp_na_sek;

int main(void)
{
//wewnętrzny prescaler CPU
CLKPR = (1<<CLKPCE);
//prescaler = 1
CLKPR = 0;

//ustawienie czujnika
DDRD |= ~(1<<PD7); //ustawienie portu jako wejście
PORTD |= (1<<PD7);//wybrany pin 7 do odczytu, podciagnięcie do Vcc

DDRB |= PWM_1; //ustawienie portu B jako wyjście, pin 7


//ustawienia licznika 0 tryb zwykłej pracy
// ustawienie licznika 2 odczyt stanu licznika 0

TCCR0A = 0;
TCCR0B |= (1<<CS02) | (1<<CS00); // zewnętrzny zegar wejcie T0 (D7), rosnące zbocze
//timer2 jako timer systemowy 10ms
OCR2A = F_CPU/100/1024 -1 ; //77.125
TCCR2A |= (1<<WGM21); //tryb CTC
TCCR2B |= (1<<CS22) |(1<<CS21) |(1<<CS20); //preskaler 1024
TIMSK2 |= (1<<OCIE2A); //włącz przerwania
sei();

// ustawienie licznika 1 do PWM OCR na TOP, preskaler 1024
TCCR1A |= (1<<COM1C1) | (1<<COM1C0) | (1<<WGM11) | (1<<WGM10);
TCCR1B |= (1<<WGM12) | (1<<WGM13)| (1 << CS12) | (1<<CS10);


while(1)

{
ICR1=imp_na_sek;
OCR1C=imp_na_sek/2;
}
}

ISR(TIMER2_COMPA_vect)
{
//raz na 10ms
static uint8_t licznik;
licznik++;
if(licznik >= 100)
{
//raz 5 sekund
licznik = 0;
imp_na_sek = TCNT0; //odczytaj wartość licznika timera0
TCNT0 = 0;
}
}[/syntax]

Statystyki: Napisane przez L.h.michalak — 25 lut 2014, o 16:47

]]> 2014-02-24T18:26:29+01:00 2014-02-24T18:26:29+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=71849#p71849 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> L.h.michalak napisał(a):

Hmm co do bitów tak wiem że domyślnie są wszystkie wyzerowane, ale to mnie zdziwiło zerując jeden bit WGM pozostałe 3 dostają 1 ?
Tu też się mylisz. Do ustawiania bitów używa się takiej konstrukcji:
[syntax=c]PORTB |= (1<<PB4); //tylko bit PB4 zostanie ustawiony, a pozostałe niezmienione
//co jest równoważne:
PORTB |= (1<<4);
PORTB |= 0b00010000;
PORTB = PORTB | 0b00010000; // | czegokolwiek z 0 nic nie zmienia[/syntax]
do zerowania:
[syntax=c]PORTB &= ~(1<<PB4); //tylko bit PB4 zostanie wyzerowany, a pozostałe niezmienione
//co jest równoważne:
PORTB &= ~(1<<4);
PORTB &= ~0b00010000;
PORTB &= 0b11101111;
PORTB = PORTB & 0b11101111; // & czegokolwiek z 1 nic nie zmienia[/syntax]
Jak zmieszasz jedno z drugim:
[syntax=c]PORTB |= ~(1<<PB4); //zły przykład, bo wszystkie inne bity zostaną ustawione a PB4 niezmieniony
//co jest równoważne:
PORTB |= ~(1<<4);
PORTB |= ~0b00010000;
PORTB |= 0b11101111;
PORTB = PORTB | 0b11101111;[/syntax]

Statystyki: Napisane przez Krauser — 24 lut 2014, o 18:26

]]> 2014-02-24T00:02:43+01:00 2014-02-24T00:02:43+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=71791#p71791 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]>
Hmm co do bitów tak wiem że domyślnie są wszystkie wyzerowane, ale to mnie zdziwiło zerując jeden bit WGM pozostałe 3 dostają 1 ? poprawię to chyba na standardowy sposób ustawiania 1 tylko dla tych potrzebnych

Statystyki: Napisane przez L.h.michalak — 24 lut 2014, o 00:02

]]> 2014-02-21T18:27:54+01:00 2014-02-21T18:27:54+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=71399#p71399 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> ). Generalnie zawsze należy sprawdzić w specyfikacji jaki tryb został wybrany za pomocą bitów WGMxy. ICR powinno być większe od OCR. Do ICR wpisuj imp_na_sek a do OCR imp_na_sek/2
2. Jak chcesz zliczać impulsy sprzętowo to musisz wykorzystać dedykowane wejście T0, ale możesz też zliczać programowo, badając stan dowolnego z wejść.
3. Napisać najprostszy program do migania LEDem co sekundę. Preskaler można też zmienić podczas działania programu.
L.h.michalak napisał(a):

[syntax=c]TCCR1A |= (1<<COM1C1) | (1<<COM1C0) | (1<<WGM11) | ~(1<<WGM10);[/syntax]


Nigdy nie używaj takiej konstrukcji. Czy wiesz, że samo:
[syntax=c]TCCR1A |= ~(1<<WGM10);[/syntax]
ustawia wszystkie bity poza WGM10.
Domyślnie większość bitów jest wyzerowana i nie trzeba się nimi martwić, a tylko ustawić te bity co mają mieć 1, a jak już chcesz wyzerować bity to zrób to w osobnej linijce.

Statystyki: Napisane przez Krauser — 21 lut 2014, o 18:27

]]> 2014-02-21T15:10:37+01:00 2014-02-21T15:10:37+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=71353#p71353 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]>
1. problem przy ustawianiu PWM, przy ręcznym wpisywaniu ustawień OCR i ICR dostaje ładny wykres przebiegu natomiast przy przypisywaniu ze zmiennej dostaje ciągłą linie (zakładam że błąd jest w sposobie zapisywania do ICR/OCR lub złym funkcjonowaniu licznika) czy do zapisania zmiennej w rejestr wystarczy zwykłe [syntax=c]ICR3 = imp_na_sek[/syntax] ?

1a. Przy ustawieniu trybu fast pwm i ICR na top ICR odpowiada za okres impulsu a OCR za wypełnienie, czy na odwrót? u siebie chciałbym regulować okres a wypełnienie mieć stałe 50%

2. przy ustawieniu licznika w tryb zwykłej pracy (czyli zliczanie impulsów) taktowanie musi być z wyjścia T0, czyli jak mam impulsy do zliczenia na wejściu D1 to i tak do wejścia T0 musze podpiąć zewnętrzny zegar? czy może impulsy mają trafiać na wejście T0

3. Ciekawostka dotycząca samego układu at90usb1287 domyślnie jest dostarczany z kwarcem 8MHz i zprogramowanym preskalerem 8 co daje wyjściowe 1 MHz, jest jakiś sposób by sprawdzić aktualną częstotliwość pracy układu?

dorzucę jeszcze kod całego programu w razie potrzeb
[syntax=c]/*
* main.c
*
* Created on: 02-01-2014
* Author: Administrator
*/
#include <avr/io.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include <util/delay.h>


#define LED_PIN (1<<PD2)
#define LED_TOG PORTD ^= LED_PIN
#define PWM_1 (1<<PB7)

volatile uint8_t imp_na_sek;

int main(void)
{
//wewnętrzny prescaler CPU
CLKPR |= (1<<CLKPCE);
//prescaler = 1
CLKPR = 0;

//ustawienie czujnika
DDRD &= ~(1<<PD1); //ustawienie portu jako wejście
PORTD |=(1<<PIND1); //wybrany pin 0 do odczytu, podciagnięcie do Vcc

DDRB |= PWM_1; //ustawienie portu B jako wyjście, pin 7


//ustawienia licznika 1

TCCR0A = 0;
TCCR0B |= (1<<CS01); // wewnętrzny zegar, (preskaler 8)
//timer2 jako timer systemowy 10ms
OCR2A = F_CPU/100/1024 -1 ; //77.125
TCCR2A |= (1<<WGM21); //tryb CTC
TCCR2B |= (1<<CS22) |(1<<CS20); //preskaler 1024
TIMSK2 |= (1<<OCIE2A); //włącz przerwania
sei();

// ustawienie licznika 2 do PWM ICR na TOP
TCCR1A |= (1<<COM1C1) | (1<<COM1C0) | (1<<WGM11) | ~(1<<WGM10);
TCCR1B |= (1<<WGM12) | (1<<WGM13)| (1 << CS12) | (1<<CS10);


while(1)

{
ICR1=200;
OCR1C=imp_na_sek;
}
}

ISR(TIMER2_COMPA_vect)
{
//raz na 10ms
static uint8_t licznik;
licznik++;
if(licznik >= 100)
{
//raz 5 sekund
licznik = 0;
imp_na_sek = TCNT0; //odczytaj wartość licznika timera0
TCNT0 = 0;
}
}[/syntax]

Statystyki: Napisane przez L.h.michalak — 21 lut 2014, o 15:10

]]> 2014-01-30T21:25:21+01:00 2014-01-30T21:25:21+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=67517#p67517 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Statystyki: Napisane przez L.h.michalak — 30 sty 2014, o 21:25

]]> 2014-01-28T16:39:21+01:00 2014-01-28T16:39:21+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=67087#p67087 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Obrazek

kiedy łopata zbliża się do cienia wieży obciążenie ma być jak najmniejsze i dopiero kiedy wejdzie w cień wieży ma ono być dołączane, Przy stałej prędkości to nie jest trudne i tutaj wystarczyło by dobrać okreś trwania impulsu i wypełnienie 50%, jednak że to ma być aktywne sterowanie i zakładając że obroty mogą się zmieniać nie mogę użyć tutaj rozwiązania ze stałym okresem, im większe obroty tym mniejszy okres impulsu tak aby hmm zdążył się wyrobić między łopatami.

Statystyki: Napisane przez L.h.michalak — 28 sty 2014, o 16:39

]]> 2014-01-23T19:28:20+01:00 2014-01-23T19:28:20+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=66374#p66374 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> jak 100Hz
Sztywny ten wzór nie jest bo jest jeszcze preskaler 1024 lub inny, ale obliczając sobie na oko musisz się zmieścić w OCR2A, który może mieć maksymalnie 255. Jeśli się nie udaje to wtedy przechodzimy na inną częstotliwość np. 1kHz, a licznik w przerwaniu musi zliczyć 1000 i wtedy musi mieć rozmiar 16bit (uint16_t). Licznik oczywiście można porównywać z większą liczbą uwzględniając pojemność zmiennej. Dla prędkości 1000 obr/min (przy 3 impulsach na obrót) wyjdzie 3*1000/60 = 50, a dla 3000 wyjdzie 3*3000/60 = 150, więc spokojnie się zmieści.

Aby przenieść to na PWM to myślę że wystarczy wpisać wprost do OCR3A, a ICR3 powinien mieć stałą wartość np. 200 i wtedy dla 50 masz wypełnienie 50/200 = 25% dla 100 - 50% i dla 150 - 75%. Większa prędkość -> większe wypełnienie i bardziej obciążysz turbinę. Oczywiście można jeszcze liczbę impulsów potraktować jakąś funkcją i wtedy wpisać do OCR3A. To już zależy co dokładnie ma się dziać.

Statystyki: Napisane przez Krauser — 23 sty 2014, o 19:28

]]> 2014-01-22T19:08:37+01:00 2014-01-22T19:08:37+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=66199#p66199 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> [syntax=c]OCR2A = F_CPU/1000/1024 -1 ; //100Hz[/syntax] jest to jakiś "sztywny" wzór czy trzeba go odpowiednio dobrać wg swoich parametrów aby te 10ms otrzymać ( dokładniej mnie zastanawia skąd się ten 1000 wziął) bo przy częstotliwości 16Mhz wychodzi mi tu 15 z groszami. Wartośc obrotów będzie się zmieniać może to być 1000 a może też być chyba 3000 obr/min nie więcej, więc w liczniku powinno się to zmieścić przeliczając na impulsy na sekunde, w przerwaniu rozumiem określany jest czas przechwycenia 1s gdybym chiciał np 5 czy 10 sekund najwygodniej jest zmienić myśle wartośc tutaj
[syntax=c]if(licznik >= 100)[/syntax]
zamiast 100 odpowiednio dla 5s -500 i dla 10s - 1000

drugie pytanie jak z tego przejśc do określenia pwm? mając już impulsy/sek mamy w sumie częstotliwość z której można policzyć okres (T=1/f) starczy wpisać to w rejestry kolejnego licznika ustawionego w tryb pwm? w dobrą strone myślę czy już coś pomieszałem?
PS. przyszedł mi już BB takżę będę dokładniej mógł zgłębić ten temat :]

Statystyki: Napisane przez L.h.michalak — 22 sty 2014, o 19:08

]]> 2014-01-21T19:19:08+01:00 2014-01-21T19:19:08+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=66050#p66050 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> Ten tryb pracy się tu nie nadaje. Na razie skup się na jednej rzeczy, czyli wyznaczeniu prędkości obrotowej. Masz 3 impulsy na obrót i około 2000 obr/min, czyli 3 * 2000 impulsów/min = 6000 impulsów/min => 100 impulsów/sek i tego się trzymasz. Jeden timer ma pracować jako licznik tzn., że taktowany jest z wejścia T...(wejście które posiada aką alternatywną funkcję), a nie razem z procesorem. Drugi timer należy skonfigurować aby generował przerwanie co 1 sekundę co nie zawsze się da, ale można sobie w przerwaniu zwielokrotnić mniejszy czas. Pierwszy z timerów zlicza sobie impulsy podawane na wejście, a drugi co sekundę odczytuje jego wartość i zeruje. Przykład:
[syntax=c]volatile uint8_t imp_na _sek;
int main()
{
//LED
DDRD |= (1<<DD7); //wyjście
//timer0 jako licznik impulsów zewnętrznych
TCCR0A = 0;
TCCR0B |= (1<<CS02) | (1<<CS01); //zewnętrzny zegar, (opadające zbocze)
//timer2 jako timer systemowy 10ms
OCR2A = F_CPU/1000/1024 -1 ; //100Hz
TCCR2A |= (1<<WGM21); //tryb CTC
TCCR2B |= (1<<CS22) | (1<<CS21) |(1<<CS20); //preskaler 1024
TIMSK2 |= (1<<OCIE2A); //włącz przerwania
sei();

while(1)
{
if(impulsy_na_sek > 100) PORTD |= 1<<PD7; //włącz obciążenie
else PORTD &= ~(1<<PD7); //wyłącz obciążenie
}
return 0;
}
ISR(TIMER2_COMPA_vect)
{
//raz na 10ms
static uint8_t licznik;
licznik++;
if(licznik >= 100)
{
//raz sekundę
licznik = 0;
imp_na_sek = TCNT0; //odczytaj wartość licznika timera0
TCNT0 = 0;
}
}[/syntax]

Statystyki: Napisane przez Krauser — 21 sty 2014, o 19:19

]]> 2014-01-21T13:23:24+01:00 2014-01-21T13:23:24+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=65977#p65977 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]>
Quote:

n = 60 / (ti * ni)
n - prędkość obrotowa [obr/min]
ti - czas trwania impulsu [s]
ni - ilość impulsów na obrót

ti = i * p / F_CPU
ti - czas trwania impulsu [s]
i - ilość zliczonych impulsów w timerze
p - preskaler timera
F_CPU - częstotliwość taktowania procesora [Hz]

czyli
n = (60 * F_CPU) / (i * p * ni)


wirnik ma 3 łopaty dlatego też pełny obrót następuje po 3 impulsach, podzielone przez 60 daje mi liczbę obrotów na sekundę czyli mam częstotliwość i okres ze wzoru 1/f, chyba że moje rozumowanie gdzieś wtedy zawiodło, a i jeszcze jedno do licznika w trybie pwm trzeba prescaler ustawiać?

Statystyki: Napisane przez L.h.michalak — 21 sty 2014, o 13:23

]]> 2014-01-17T21:43:56+01:00 2014-01-17T21:43:56+01:00 https://forum.atnel.pl/viewtopic.php?t=5404&p=65366#p65366 <![CDATA[Re: aktywne sterowanie obciążeniem z pwm]]> [syntax=c]TCCR1B |= (1<<CS11);/* preskaler = 8 w zależności od potrzeby*/
TCCR1B &= ~(1<<ICES1);/* opadające zbocze w zależności od potrzeby*/
TIMSK1 |= (1<<ICIE1);/* włącz generowanie przerwania */
TCNT1 = 0; /*wyzerowanie timera*/[/syntax]
Twój kod ustawiania licznika 1 jest błędny w sensie tego co chcesz robić.
OCR1A to rejestr do porównywania i tu nie należy go używać tylko rejestr ICR1:
[syntax=c]ISR(TIMER1_CAPT_vect)
{
impuls = ICR1; /*skopiowanie przechwyconej wartości*/
TCNT1 = 0; /*wyzerowanie timera*/
}[/syntax]
To działa w ten sposób, że timer1 sobie liczy impulsy i jak zmieni się stan na wejściu przechwytywania to wtedy aktualna wartość timera1 jest kopiowana do rejestru ICR1 (timer liczy dalej) i zostaje wygenerowane przerwanie które powoduje przeskok do funkcji ISR(TIMER1_CAPT_vect) gdzie spokojnie odczytujesz sobie wartość z ICR1 i zerujesz timer1. Preskaler trzeba tak dobrać, żeby przerwania występowały na tyle często, że timer1 nie przekręci się z 65535 na 0, bo wtedy impulsy nie odpowiadają stanowi faktycznemu. Dziwne jest to obliczenie dla PWM, bo wychodzi na to, że OCR3A = 1/ICR3

Statystyki: Napisane przez Krauser — 17 sty 2014, o 21:43

]]>