ATNEL tech-forum 2015-05-28T22:50:52+01:00 https://forum.atnel.pl/feed.php?f=4&t=11747&mode 2015-05-28T22:50:52+01:00 2015-05-28T22:50:52+01:00 https://forum.atnel.pl/viewtopic.php?t=11747&p=130327#p130327 <![CDATA[Re: Atmega644 - ustawianie serw według kolejki]]> Oto kawałek kodu, który pomógł:

[syntax=c]if(key_flag) // jeśli flaga = 0, wykonaj program
{
key_flag = 0;

if (KEY1_DOWN) //klawisz 1 wcisniety
{
if(KEY1_DOWN && servo1!=SERVO_MAX)
{
servo1+=20;
}
if (KEY1_DOWN && servo2!=SERVO_MAX && servo1==SERVO_MAX)
{
servo2+=20;
}
if (KEY1_DOWN && servo3!=SERVO_MAX && servo2==SERVO_MAX)
{
servo3+=20;
}
if (KEY1_DOWN && servo4!=SERVO_MAX && servo3==SERVO_MAX)
{
servo4 +=20;
}
if (KEY1_DOWN && servo5!=SERVO_MAX && servo4==SERVO_MAX)
{
servo5 +=20;
}
}[/syntax]

Tutaj wrzucam filmik z działaniem:
https://www.youtube.com/watch?v=AAyQoECwwXM

Statystyki: Napisane przez Panicz74 — 28 maja 2015, o 22:50

]]> 2015-05-22T19:55:14+01:00 2015-05-22T19:55:14+01:00 https://forum.atnel.pl/viewtopic.php?t=11747&p=129851#p129851 <![CDATA[Re: Atmega644 - ustawianie serw według kolejki]]> Panicz74 napisał(a):

Niestety, program działa jak ten pierwotny Wszystkie serwa ruszają jednocześnie.

Sprawdź to jeszcze raz. Ostatecznie zmodyfikuj kod w ten sposób, a zamiast serw podłącz LEDy
[syntax=c]//0
//if (TCNT1 >= servo1) PORTB &= ~SERVO1;
//if (TCNT1 >= servo2) PORTB &= ~SERVO2;
//if (TCNT1 >= servo3) PORTB &= ~SERVO3;
//if (TCNT1 >= servo4) PORTB &= ~SERVO4;
//if (TCNT1 >= servo5) PORTB &= ~SERVO5;[/syntax]

Statystyki: Napisane przez Krauser — 22 maja 2015, o 19:55

]]> 2015-05-20T23:16:34+01:00 2015-05-20T23:16:34+01:00 https://forum.atnel.pl/viewtopic.php?t=11747&p=129742#p129742 <![CDATA[Re: Atmega644 - ustawianie serw według kolejki]]> Wszystkie serwa ruszają jednocześnie. Tak sobie pomyślałem, czy istnieje jakiś sposób by zapauzować w danym miejscu program, aby go wznowić należałoby wcisnąć ponownie przycisk i by działał do momentu wystąpienia kolejnej pauzy?

Na przykład takie coś:
[syntax=c]while (1) {
if (key_flag) // jeśli flaga = 1 wykonaj
{
key_flag = 0;
if (KEY1_DOWN) //klawisz 1 wcisniety
{
servo1 = SERVO_MAX;
servo2 = SERVO_MIN;

//pauza, oczekiwanie na KEY1_DOWN

servo3 = SERVO_MAX;
servo4 = SERVO_MIN;

//pauza, oczekiwanie na KEY1_DOWN

servo5 = SERVO_MAX;

}
.
.
.[/syntax]

Jest na to jakiś sposób?

Statystyki: Napisane przez Panicz74 — 20 maja 2015, o 23:16

]]> 2015-05-20T16:14:08+01:00 2015-05-20T16:14:08+01:00 https://forum.atnel.pl/viewtopic.php?t=11747&p=129703#p129703 <![CDATA[Re: Atmega644 - ustawianie serw według kolejki]]> - i jest w warunkach przycisków, a po starcie program wcale nie wymaga aby jakikolwiek był wciśnięty bo ustawia serwa na pozycje środkowe
- jeśli wszystkie klawisze byłyby wciśnięte to po spełnieniu warunku i jest zwiększone i w następnym warunku ma odpowiednią wartość
- i tworzysz już w warunku i zawsze a taką samą wartość w każdym obiegu pętli

Spróbuj jak poniżej. Dołożone są dodatkowe zmienne. Po starcie są zerami, a serwa zostaną uruchomione jak będą miały wartość różną od zera. W cyklicznym przerwaniu z pomocą dodatkowego licznika są one ustawiane po pewnym czasie od startu programu. Raz ustawione nie są już zmieniane.
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define KEY1 (1<<PA0) // definicja pinow przycisków
#define KEY2 (1<<PA1)
#define KEY3 (1<<PA3)

#define KEY1_DOWN ( !(PINA & KEY1) ) // definicja wciśniętego przycisku
#define KEY2_DOWN ( !(PINA & KEY2) )
#define KEY3_DOWN ( !(PINA & KEY3) )

#define SERVO1 (1<<PB0) // definicja pinow silników
#define SERVO2 (1<<PB1)
#define SERVO3 (1<<PB2)
#define SERVO4 (1<<PB3)
#define SERVO5 (1<<PB4)

#define SERVO_MID 1500 // definicja położenia silnika
#define SERVO_MIN 1000
#define SERVO_MAX 2000

uint16_t servo1, servo2, servo3, servo4, servo5;

volatile uint8_t key_flag; // zmienne uzywana przez main i przerwanie
volatile uint8_t servo1_enable, servo2_enable, servo3_enable, servo4_enable, servo5_enable;

int main(void) {
servo1 = servo2 = servo3 = servo4 = servo5 = SERVO_MID; // ustawienie początkowe silników
PORTA |= KEY1 | KEY2 | KEY3; // pull up - przyciski
DDRB |= SERVO1 | SERVO2 | SERVO3 | SERVO4 | SERVO5; // wyjścia do silników
TCCR1A |= 1 << WGM11;
TCCR1B |= 1 << WGM12 | 1 << WGM13 | 1 << CS10; //rejestry odpowiedzialne za PWM
TIMSK1 |= 1 << OCIE1A; // timer dla TCCR1B & TCCR1A

ICR1 = 19999; //zawez okres

sei();
//zezwolenie na przerwania

while (1) {
if (key_flag) // jeśli flaga = 1 wykonaj
{
key_flag = 0;
if (KEY1_DOWN) //klawisz 1 wcisniety
{
servo1 = SERVO_MAX;
servo2 = SERVO_MIN;
servo3 = SERVO_MAX;
servo4 = SERVO_MIN;
servo5 = SERVO_MAX;
}
if (KEY2_DOWN) //klawisz 2 wcisniety
{
servo1 = SERVO_MIN;
servo2 = SERVO_MAX;
servo3 = SERVO_MIN;
servo4 = SERVO_MAX;
servo5 = SERVO_MIN;
}
if (KEY3_DOWN) //klawisz 3 wcisniety
{
servo1 = SERVO_MID;
servo2 = SERVO_MID;
servo3 = SERVO_MID;
servo4 = SERVO_MID;
servo5 = SERVO_MID;
}

}
//1
if (TCNT1 >= 0 && TCNT1 < servo1 && servo1_enable) PORTB |= SERVO1;
if (TCNT1 >= 0 && TCNT1 < servo2 && servo2_enable) PORTB |= SERVO2;
if (TCNT1 >= 0 && TCNT1 < servo3 && servo3_enable) PORTB |= SERVO3;
if (TCNT1 >= 0 && TCNT1 < servo4 && servo4_enable) PORTB |= SERVO4;
if (TCNT1 >= 0 && TCNT1 < servo5 && servo5_enable) PORTB |= SERVO5;
//0
if (TCNT1 >= servo1) PORTB &= ~SERVO1;
if (TCNT1 >= servo2) PORTB &= ~SERVO2;
if (TCNT1 >= servo3) PORTB &= ~SERVO3;
if (TCNT1 >= servo4) PORTB &= ~SERVO4;
if (TCNT1 >= servo5) PORTB &= ~SERVO5;
}
}
ISR (TIMER1_COMPA_vect) //przerwanie co 20 ms
{
static uint16_t counter; //zmienna zachowywana po wyjsciu z funkcji
key_flag = 1;

++counter;
if(counter > 100) // po 100*20 ms = 2 s
servo1_enable = 1;
if(counter > 200) // po 200*20 ms = 4 s
servo2_enable = 1;
if(counter > 300) // po 300*20 ms = 6 s
servo3_enable = 1;
if(counter > 400) // po 400*20 ms = 8 s
servo4_enable = 1;
if(counter > 500) // po 500*20 ms = 10 s
servo5_enable = 1;
}[/syntax]

------------------------ [ Dodano po: 2 pikosekundach ]

Panicz74 napisał(a):

A jest jakaś możliwość aby zmniejszyć prędkość serw?

Tak jeśli przykładowo do zmiennej servo1 nie przypiszesz od razu docelowej liczby tylko z stopniowo będziesz ją zwiększał, aż do wymaganej wartości.

Statystyki: Napisane przez Krauser — 20 maja 2015, o 16:14

]]> 2015-05-19T23:22:08+01:00 2015-05-19T23:22:08+01:00 https://forum.atnel.pl/viewtopic.php?t=11747&p=129657#p129657 <![CDATA[Re: Atmega644 - ustawianie serw według kolejki]]>
------------------------ [ Dodano po: 33 minutach ]

Spróbowałem wstawić licznik ale to nic nie daje. Dalej serwa ruszają jednocześnie.

[syntax=c]while(1)
{
if(key_flag) // jeśli flaga = 0, wykonaj program
{
key_flag = 0;
int i = 0;
if (KEY1_DOWN && i==0) //klawisz 1 wcisniety
{
servo1 = SERVO_MAX; i++;
}
if (KEY1_DOWN && i==1)
{
servo2 = SERVO_MIN; i++;
}
if (KEY1_DOWN && i==2)
{
servo3 = SERVO_MAX; i++;
}
if (KEY1_DOWN && i==3)
{
servo4 = SERVO_MIN; i++;
}
if (KEY1_DOWN && i==4)
{
servo5 = CHWYTAK_MAX; i++;
}
i = 0;
.
.
.[/syntax]

Chodzi mi o to abym mógł sobie ustawić przerwy pomiędzy ruchem kolejnych silników... Jakieś pomysły? :(

Statystyki: Napisane przez Panicz74 — 19 maja 2015, o 23:22

]]> 2015-05-19T21:37:40+01:00 2015-05-19T21:37:40+01:00 https://forum.atnel.pl/viewtopic.php?t=11747&p=129651#p129651 <![CDATA[Re: Atmega644 - ustawianie serw według kolejki]]> [syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define KEY1 (1<<PA0) // definicja przycików
#define KEY2 (1<<PA1)
#define KEY3 (1<<PA3)

#define KEY1_DOWN ( !(PINA & KEY1) ) // definicja wciśniętego przycisku
#define KEY2_DOWN ( !(PINA & KEY2) )
#define KEY3_DOWN ( !(PINA & KEY3) )

#define SERVO1 (1<<PB0) // definicja silników
#define SERVO2 (1<<PB1)
#define SERVO3 (1<<PB2)
#define SERVO4 (1<<PB3)
#define SERVO5 (1<<PB4)

#define SERVO1_START 0
#define SERVO2_START 3000
#define SERVO3_START 6000
#define SERVO4_START 9000
#define SERVO5_START 12000 //zawsze < 19 999

#define SERVO_MID 1500 // definicja położenia silnika
#define SERVO_MIN 1000
#define SERVO_MAX 2000

uint16_t servo1, servo2, servo3, servo4, servo5;
volatile uint8_t key_flag; // zmienna pomijana przez kompilator

int main(void) {
servo1 = servo2 = servo3 = servo4 = servo5 = SERVO_MID; // ustawienie początkowe silników
PORTA |= KEY1 | KEY2 | KEY3; // wyjścia - przyciski
DDRB |= SERVO1 | SERVO2 | SERVO3 | SERVO4 | SERVO5; // wyjścia do silników
TCCR1A |= 1 << WGM11;
TCCR1B |= 1 << WGM12 | 1 << WGM13 | 1 << CS10; //rejestry odpowiedzialne za PWM
TIMSK1 |= 1 << OCIE1A; // timer dla TCCR1B & TCCR1A

ICR1 = 19999; //rozciagnij, zawez okres

sei();
//uruchomienie przerwań

while (1) {
if (key_flag) // jeśli flaga = 0, wykonaj program
{
key_flag = 0;
if (KEY1_DOWN) //klawisz 1 wcisniety
{

servo1 = SERVO1_START + SERVO_MAX;
servo2 = SERVO2_START + SERVO_MIN;
servo3 = SERVO3_START + SERVO_MAX;
servo4 = SERVO4_START + SERVO_MIN;
servo5 = SERVO5_START + SERVO_MAX;

}
if (KEY2_DOWN) //klawisz 2 wcisniety
{
servo1 = SERVO1_START + SERVO_MIN;
servo2 = SERVO2_START + SERVO_MAX;
servo3 = SERVO3_START + SERVO_MIN;
servo4 = SERVO4_START + SERVO_MAX;
servo5 = SERVO5_START + SERVO_MIN;

}
if (KEY3_DOWN) //klawisz 3 wcisniety
{
servo1 = SERVO1_START + SERVO_MID;
servo2 = SERVO2_START + SERVO_MID;
servo3 = SERVO3_START + SERVO_MID;
servo4 = SERVO4_START + SERVO_MID;
servo5 = SERVO5_START + SERVO_MID;

}

}
//0
if (TCNT1 >= servo1) PORTB &= ~SERVO1; //nakierowanie mechanizmu przerwania
if (TCNT1 >= servo2) PORTB &= ~SERVO2;
if (TCNT1 >= servo3) PORTB &= ~SERVO3;
if (TCNT1 >= servo4) PORTB &= ~SERVO4;
if (TCNT1 >= servo5) PORTB &= ~SERVO5;
//1
if (TCNT1 >= SERVO1_START && TCNT1 < servo1) PORTB |= SERVO1; //nakierowanie mechanizmu przerwania
if (TCNT1 >= SERVO2_START && TCNT1 < servo2) PORTB |= SERVO2;
if (TCNT1 >= SERVO3_START && TCNT1 < servo3) PORTB |= SERVO3;
if (TCNT1 >= SERVO4_START && TCNT1 < servo4) PORTB |= SERVO4;
if (TCNT1 >= SERVO5_START && TCNT1 < servo5) PORTB |= SERVO5;

}
}
ISR (TIMER1_COMPA_vect) {
key_flag = 1; // jeśli flaga = 1, program sie wykonał
}[/syntax]

Statystyki: Napisane przez Krauser — 19 maja 2015, o 21:37

]]> 2015-05-19T15:51:50+01:00 2015-05-19T15:51:50+01:00 https://forum.atnel.pl/viewtopic.php?t=11747&p=129595#p129595 <![CDATA[Atmega644 - ustawianie serw według kolejki]]>
Dany jest testowy kod, który steruje 5 serwomechanizmami:
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define KEY1 (1<<PA0)// definicja przycików
#define KEY2 (1<<PA1)
#define KEY3 (1<<PA3)

#define KEY1_DOWN ( !(PINA & KEY1) )// definicja wciśniętego przycisku
#define KEY2_DOWN ( !(PINA & KEY2) )
#define KEY3_DOWN ( !(PINA & KEY3) )

#define SERVO1 (1<<PB0)// definicja silników
#define SERVO2 (1<<PB1)
#define SERVO3 (1<<PB2)
#define SERVO4 (1<<PB3)
#define SERVO5 (1<<PB4)


#define SERVO_MID 1500// definicja położenia silnika
#define SERVO_MIN 1000
#define SERVO_MAX 2000


uint16_t servo1, servo2, servo3, servo4, servo5;
volatile uint8_t key_flag;// zmienna pomijana przez kompilator

int main(void)
{
servo1 = servo2 = servo3 = servo4 = servo5 = SERVO_MID;// ustawienie początkowe silników
PORTA |= KEY1 | KEY2 | KEY3;// wyjścia - przyciski
DDRB |= SERVO1 | SERVO2 | SERVO3 | SERVO4 | SERVO5; // wyjścia do silników
TCCR1A |= 1<<WGM11;
TCCR1B |= 1<<WGM12 | 1<<WGM13 | 1<<CS10;//rejestry odpowiedzialne za PWM
TIMSK1 |= 1<<OCIE1A;// timer dla TCCR1B & TCCR1A

ICR1 = 19999;//rozciagnij, zawez okres

sei();//uruchomienie przerwań

while(1)
{
if(key_flag) // jeśli flaga = 0, wykonaj program
{
key_flag = 0;
if (KEY1_DOWN) //klawisz 1 wcisniety
{

servo1 = SERVO_MAX;
servo2 = SERVO_MIN;
servo3 = SERVO_MAX;
servo4 = SERVO_MIN;
servo5 = SERVO_MAX;

}
if (KEY2_DOWN) //klawisz 2 wcisniety
{
servo1 = SERVO_MIN;
servo2 = SERVO_MAX;
servo3 = SERVO_MIN;
servo4 = SERVO_MAX;
servo5 = SERVO_MIN;

}
if (KEY3_DOWN) //klawisz 3 wcisniety
{
servo1 = SERVO_MID;
servo2 = SERVO_MID;
servo3 = SERVO_MID;
servo4 = SERVO_MID;
servo5 = SERVO_MID;

}

}
if(TCNT1 >= servo1) PORTB &= ~SERVO1; //nakierowanie mechanizmu przerwania
if(TCNT1 >= servo2) PORTB &= ~SERVO2;
if(TCNT1 >= servo3) PORTB &= ~SERVO3;
if(TCNT1 >= servo4) PORTB &= ~SERVO4;
if(TCNT1 >= servo5) PORTB &= ~SERVO5;

}
}
ISR (TIMER1_COMPA_vect)
{
PORTB |= SERVO1 | SERVO2 | SERVO3 | SERVO4 | SERVO5;
key_flag = 1; // jeśli flaga = 1, program sie wykonał
}[/syntax]

Problem polega na tym, że serwa startują jednocześnie, zachodzi zjawisko hazardu. Domyślam się, że na pewno chodzi o tę część:
[syntax=c]ISR (TIMER1_COMPA_vect)
{
PORTB |= SERVO1 | SERVO2 | SERVO3 | SERVO4 | SERVO5;
key_flag = 1; // jeśli flaga = 1, program sie wykonał
}[/syntax]

Sprawa niby prosta, ale jakakolwiek zmiana powoduje brak działania programu. Czy wie ktoś co zrobić aby uruchamiać serwa po kolei, tzn. od SERVO1 do SERVO5?

Statystyki: Napisane przez Panicz74 — 19 maja 2015, o 15:51

]]>