ATNEL tech-forum

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-08-06T16:22:00+01:00

Zacząłem szukać jakiś przykładów PWMu programowego ale są one dla mnie trochę niejasne. Czy mógłby ktoś podpowiedzieć coś więcej? Chodzi mi głównie o ATtiny 13. Czytałem że potrzebne są dwa timery w innym przykładzie że tylko jeden wystarczy. Jak to wygląda w praktyce?

Statystyki: Napisane przez Kobuz — 6 sie 2012, o 16:22

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-08-05T21:22:03+01:00

Kobuz napisał(a):

... wystarczyłoby gdybym odkrył w jaki sposób to działa... jak wysterować no 2 serwa z jednego kanału PWM np. w ATtiny...

To wiesz co? gdybyś to kiedyś odkrył to daj nam znać ... żart oczywiście

Z jednego kanału PWM nie wysterujesz więcej niż jednego serwa, ale jeśli sobie zrobisz programowe PWM'y to wtedy uzyskasz dowolną ilość kanałów i na pinach które ci się podobają, więc wtedy wysterujesz ich kilka.

Oczywiście trochę przesadziłem z tą dowolną ilością kanałów programowych PWM ale kilka na pewno dasz radę zrobić

Statystyki: Napisane przez mirekk36 — 5 sie 2012, o 21:22

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-08-05T21:07:23+01:00

Witam, jestem co prawda nowy na forum ale to nie tak że wpadnę, zadam pytanie i uciekam.
Zacząłem uczyć się C, niedawno. Powili zaczynam to "ogarniać" jednak zagadkę stanowi dla mnie właśnie sterowanie kilkoma serwami...
Na przykład z takiej ATtiny13 czy ATmegi8 (z tymi do tej pory miałem kontakt) mają one odpowiednio dwa i 3 kanały PWM więc jak Wy podłączacie tam tyle serw? ;p
Staram się rozgryźć kod z poprzedniej strony ale idzie powoli.
Byłbym wdzięczny za wskazówki
Oczywiście nie mam zamiaru rzucać się na głęboką wodę, wystarczyłoby gdybym odkrył w jaki sposób to działa... jak wysterować no 2 serwa z jednego kanału PWM np. w ATtiny...

Statystyki: Napisane przez Kobuz — 5 sie 2012, o 21:07

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-17T19:36:28+01:00

hehehe no pewnie że tak

Statystyki: Napisane przez SunRiver — 17 cze 2012, o 19:36

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-17T19:14:20+01:00

To już chyba prościej było by napisać od zera

Statystyki: Napisane przez Gość — 17 cze 2012, o 19:14

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-17T12:30:19+01:00

nikt nie mówił że będzie prosto prawda ...

Statystyki: Napisane przez SunRiver — 17 cze 2012, o 12:30

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-17T12:27:24+01:00

No ale jest to C++

Statystyki: Napisane przez janbernat — 17 cze 2012, o 12:27

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T22:10:01+01:00

obiecałem i macie, teoretycznie max32 kanały ale używałem tylko 12stu

[syntax=c]

#include
#include
#include
#include

#include "common.h"
#include "opled.h"
#include "usart.h"
#include "twi_aap.h"
#include "eeprom.h"

namespace PWM0 {
void inline Init() {
CLRBIT(PRR,PRTIM0);
// fast PWM mode oraz ustwienie oby wyjść na plus
TCCR0A = (1 << COM0A1) | (1 << COM0B1) | (1 << WGM01) | (1 << WGM00);
TCCR0B = (1 << CS01) | (1 << CS00); // clkI/O / 64 -> full cycle 2.5ms 6.4MHz (6.5536MHz)
SETBIT(DDRD,0x40|0x20); // Port D pin 5 i 6
CLRBIT(PORTD,0x40|0x20);
OCR0A = 0x00;
OCR0B = 0x00;
TCNT0 = 0x00;
}
void inline DisableChA() { CLRBIT(TCCR0A,(1 << COM0A1)); }
void inline DisableChB() { CLRBIT(TCCR0A,(1 << COM0B1)); }
void inline DisableChAB() { CLRBIT(TCCR0A,(1 << COM0A1) | (1 << COM0B1)); }
void inline EnableChA() { SETBIT(TCCR0A,(1 << COM0A1)); }
void inline EnableChB() { SETBIT(TCCR0A,(1 << COM0B1)); }
void inline EnableChAB() { SETBIT(TCCR0A,(1 << COM0A1) | (1 << COM0B1)); }
void inline SetChannelA(uint8_t aValue) { OCR0A = aValue; }
void inline SetChannelB(uint8_t aValue) { OCR0B = aValue; }
void inline EnableIRQ_A() { SETBIT(TIMSK0,(1 << OCIE0A)); }
void inline EnableIRQ_B() { SETBIT(TIMSK0,(1 << OCIE0B)); }
void inline EnableIRQ_Overflow() { SETBIT(TIMSK0,(1 << TOIE0)); }
void inline EnableOnlyIRQ_A() { TIMSK0 = (1 << OCIE0A); }
void inline EnableOnlyIRQ_B() { TIMSK0 = (1 << OCIE0B); }
void inline EnableOnlyIRQ_Overflow() { TIMSK0 = (1 << TOIE0); }
void inline DisableIRQ_A() { CLRBIT(TIMSK0,(1 << OCIE0A)); }
void inline DisableIRQ_B() { CLRBIT(TIMSK0,(1 << OCIE0B)); }
void inline DisableIRQ_Overflow() { CLRBIT(TIMSK0,(1 << TOIE0)); }
void inline DisableIRQ_All() { TIMSK0 = 0; }
bool inline IsPendingIRQ_A() { return (TESTBIT(TIFR0,(1 << OCF0A)) != 0); }
bool inline IsPendingIRQ_B() { return (TESTBIT(TIFR0,(1 << OCF0B)) != 0); }
bool inline IsPendingIRQ_Overflow() { return (TESTBIT(TIFR0,(1 << TOV0)) != 0); }
void inline ClearPendingIRQ_A() { TIFR0 = (1 << OCF0A); }
void inline ClearPendingIRQ_B() { TIFR0 = (1 << OCF0B); }
void inline ClearPendingIRQ_Overflow() { TIFR0 = (1 << TOV0); }
void inline ClearPendingIRQ_All() { TIFR0 = (1 << OCF0A) | (1 << OCF0B) | (1 << TOV0); }
}

// 16-bit timer zdołowany do 8-bit
namespace PWM1 {
void inline Init() {
CLRBIT(PRR,PRTIM0);
// fast PWM mode outA ioutB --->
TCCR1A = (1 << COM1A1) | (1 << COM1B1) | (1 << WGM10);
TCCR1B = (1 << CS01) | (1 << CS00) | (1 << WGM12);
SETBIT(DDRB,0x02|0x04);
CLRBIT(PORTB,0x02|0x04);
OCR1A = 0x0000;
OCR1B = 0x0000;
ICR1 = 0x0000;
TCNT1 = 0x0000;
}
void inline DisableChA() { CLRBIT(TCCR1A,(1 << COM1A1)); }
void inline DisableChB() { CLRBIT(TCCR1A,(1 << COM1B1)); }
void inline DisableChAB() { CLRBIT(TCCR1A,(1 << COM1A1) | (1 << COM1B1)); }
void inline EnableChA() { SETBIT(TCCR1A,(1 << COM1A1)); }
void inline EnableChB() { SETBIT(TCCR1A,(1 << COM1B1)); }
void inline EnableChAB() { SETBIT(TCCR1A,(1 << COM1A1) | (1 << COM1B1)); }

void inline SetChannelA(uint8_t aValue) { OCR1AL = aValue; }
void inline SetChannelB(uint8_t aValue) { OCR1BL = aValue; }
void inline EnableIRQ_A() { SETBIT(TIMSK1,(1 << OCIE1A)); }
void inline EnableIRQ_B() { SETBIT(TIMSK1,(1 << OCIE1B)); }
void inline EnableIRQ_Overflow() { SETBIT(TIMSK1,(1 << TOIE1)); }
void inline EnableOnlyIRQ_A() { TIMSK1 = (1 << OCIE1A); }
void inline EnableOnlyIRQ_B() { TIMSK1 = (1 << OCIE1B); }
void inline EnableOnlyIRQ_Overflow() { TIMSK1 = (1 << TOIE1); }
void inline DisableIRQ_A() { CLRBIT(TIMSK1,(1 << OCIE1A)); }
void inline DisableIRQ_B() { CLRBIT(TIMSK1,(1 << OCIE1B)); }
void inline DisableIRQ_Overflow() { CLRBIT(TIMSK1,(1 << TOIE1)); }
void inline DisableIRQ_All() { TIMSK1 = 0; }
bool inline IsPendingIRQ_A() { return (TESTBIT(TIFR1,(1 << OCF1A)) != 0); }
bool inline IsPendingIRQ_B() { return (TESTBIT(TIFR1,(1 << OCF1B)) != 0); }
bool inline IsPendingIRQ_Overflow() { return (TESTBIT(TIFR1,(1 << TOV1)) != 0); }
void inline ClearPendingIRQ_A() { TIFR1 = (1 << OCF1A); }
void inline ClearPendingIRQ_B() { TIFR1 = (1 << OCF1B); }
void inline ClearPendingIRQ_Overflow() { TIFR1 = (1 << TOV1); }
void inline ClearPendingIRQ_All() { TIFR1 = (1 << OCF1A) | (1 << OCF1B) | (1 << TOV1); }
}

// 32-kanały pwm PWM0 i PWM1
namespace Servo32 {
const int ChNum = 32;
const uint8_t MaxData = 250;
uint8_t LedCnt;
uint8_t Data[ChNum];
uint8_t CurIdx;
const uint8_t AddrTable[8] PROGMEM = {0,4,2,6,1,5,3,7};

void Advance();
void inline Init() {
GTCCR = (1 << TSM) | (1 << PSRSYNC); // Synchronizacja PWMów
PWM0::Init();
PWM1::Init();
CurIdx = 0;
LedCnt = 0;
for(int i=0;iSETBIT(DDRC,0x07); // Port C piny 0 1 2 -->piny adresowe
SETBIT(PORTC,0x07);
Advance();
GTCCR = (1 << PSRSYNC);
}

void inline SetIRQToChannel0() { PWM1::DisableIRQ_All(); PWM0::EnableOnlyIRQ_A(); }
void inline SetIRQToChannel1() { PWM1::DisableIRQ_All(); PWM0::EnableOnlyIRQ_B(); }
void inline SetIRQToChannel2() { PWM0::DisableIRQ_All(); PWM1::EnableOnlyIRQ_A(); }
void inline SetIRQToChannel3() { PWM0::DisableIRQ_All(); PWM1::EnableOnlyIRQ_B(); }

// następne 4 kanały
void Advance() {
PWM0::ClearPendingIRQ_All();
PWM1::ClearPendingIRQ_All();

uint8_t MuxAddr = pgm_read_byte(AddrTable+(CurIdx >> 2));

uint8_t Data0 = Data[CurIdx+0];
uint8_t Data1 = Data[CurIdx+1];
uint8_t Data2 = Data[CurIdx+2];
uint8_t Data3 = Data[CurIdx+3];

if ((Data0 | Data1 | Data2 | Data3) == 0) {
// wszystkie kanały =0. czekanie na przerwanie
SetIRQToChannel0();

// Update kanałów ....

PORTC = (PORTC & ~0x07) | (MuxAddr);
PWM0::DisableChA();
PWM0::DisableChB();
PWM1::DisableChA();
PWM1::DisableChB();
PWM0::SetChannelA(128);
PWM0::SetChannelB(1);
PWM1::SetChannelA(1);
PWM1::SetChannelB(1);
} else {
// ustawienie IRQ na max
if (Data0 > Data1) {
if (Data2 > Data3) {
if (Data0 > Data2) {
// CH0 = max
SetIRQToChannel0();
} else {
// CH2 = max
SetIRQToChannel2();
}
} else {
if (Data0 > Data3) {
// CH0 = max
SetIRQToChannel0();
} else {
// CH3 = max
SetIRQToChannel3();
}
}
} else {
if (Data2 > Data3) {
if (Data1 > Data2) {
// CH1 = max
SetIRQToChannel1();
} else {
// CH2 = max
SetIRQToChannel2();
}
} else {
if (Data1 > Data3) {
// CH1 = max
SetIRQToChannel1();
} else {
// CH3 = max
SetIRQToChannel3();
}
}
}

// Update danych na kanałach
PORTC = (PORTC & ~0x07) | (MuxAddr);

if (Data0 == 0) PWM0::DisableChA(); else PWM0::EnableChA();
if (Data1 == 0) PWM0::DisableChB(); else PWM0::EnableChB();
if (Data2 == 0) PWM1::DisableChA(); else PWM1::EnableChA();
if (Data3 == 0) PWM1::DisableChB(); else PWM1::EnableChB();
PWM0::SetChannelA(Data0+1);
PWM0::SetChannelB(Data1+1);
PWM1::SetChannelA(Data2+1);
PWM1::SetChannelB(Data3+1);
}
CurIdx+=4;
if (CurIdx >= ChNum) CurIdx = 0;
PWM0::ClearPendingIRQ_All();
PWM1::ClearPendingIRQ_All();
if (++LedCnt == 200) {
LedCnt = 0;
OpLed::Toggle();
}
}
}

SIGNAL(SIG_OUTPUT_COMPARE1A) {Servo32::Advance();}
SIGNAL(SIG_OUTPUT_COMPARE1B) {Servo32::Advance();}
SIGNAL(SIG_OVERFLOW1) {Servo32::Advance();}
SIGNAL(SIG_OUTPUT_COMPARE0A) {Servo32::Advance();}
SIGNAL(SIG_OUTPUT_COMPARE0B) {Servo32::Advance();}
SIGNAL(SIG_OVERFLOW0) {Servo32::Advance();}

const uint8_t AddrTable[32] PROGMEM = {
0+0,4+0,8+0,12+0,16+0,20+0,24+0,28+0,
0+1,4+1,8+1,12+1,16+1,20+1,24+1,28+1,
0+2,4+2,8+2,12+2,16+2,20+2,24+2,28+2,
0+3,4+3,8+3,12+3,16+3,20+3,24+3,28+3
};
uint8_t Address;

namespace UsartComm {
const uint8_t CmdSync = 'c';
const uint8_t CmdAddr = 'a';
const uint8_t CmdRead = 'r';
const uint8_t CmdWrite = 'w';
const uint8_t CmdReadNoInc = 'R';
const uint8_t CmdWriteNoInc = 'W';
const uint8_t StatOK = '*';
const uint8_t StatError = 'E';
enum States {
State_Idle = 0,
State_Address,
State_Data,
State_DataNoInc
} State;
inline void Init(uint16_t aBaudSetting) {
USART0::Init(aBaudSetting);
State = State_Idle;
Address = 0;
}
void StateMachine() {
uint8_t CurData = USART0::FastReceiveData();
uint8_t TranslatedAddress;
OpLed::Toggle();
if (State == State_Idle) {
if (CurData == CmdAddr) {
USART0::FastSendData(StatOK);
State = State_Address;
} else if (CurData == CmdWrite) {
USART0::FastSendData(StatOK);
State = State_Data;
} else if (CurData == CmdWriteNoInc) {
USART0::FastSendData(StatOK);
State = State_DataNoInc;
} else if (CurData == CmdRead) {
TranslatedAddress = pgm_read_byte(AddrTable+Address);
USART0::FastSendData(Servo32::Data[TranslatedAddress]);
++Address;
if (Address >= Servo32::ChNum) Address = 0;
State = State_Idle;
} else if (CurData == CmdReadNoInc) {
TranslatedAddress = pgm_read_byte(AddrTable+Address);
USART0::FastSendData(Servo32::Data[TranslatedAddress]);
State = State_Idle;
} else if (CurData == CmdSync) {
USART0::FastSendData(CmdSync);
State = State_Idle;
} else {
// Jesli bład ......
USART0::FastSendData(StatError);
State = State_Idle;
}
} else if (State == State_Data) {
TranslatedAddress = pgm_read_byte(AddrTable+Address);
if (CurData > Servo32::MaxData) CurData = Servo32::MaxData;
Servo32::Data[TranslatedAddress] = CurData;
++Address;
if (Address >= Servo32::ChNum) Address = 0;
USART0::FastSendData(StatOK);
State = State_Idle;
} else if (State == State_DataNoInc) {
TranslatedAddress = pgm_read_byte(AddrTable+Address);
if (CurData > Servo32::MaxData) CurData = Servo32::MaxData;
Servo32::Data[TranslatedAddress] = CurData;
USART0::FastSendData(StatOK);
State = State_Idle;
} else if (State == State_Address) {
if (Address >= Servo32::ChNum) {
USART0::FastSendData(StatError);
} else {
Address = CurData;
USART0::FastSendData(StatOK);
}
State = State_Idle;
}
}
}

namespace TWI {
extern const sConfigRecord ConfigRecord PROGMEM = {UniqueIDUnassigned,DevClassServoController,DevUmServo32};

enum UserStates {
US_ReceiveAddr = TWI::US_Base,
US_ReceiveData,
US_SendData
};

void HandleUserReceive() {
State = US_ReceiveAddr;
}

void HandleUserTransmit() {
uint8_t TranslatedAddress = pgm_read_byte(AddrTable+Address);
TWIPrevData = Servo32::Data[TranslatedAddress];
TWDR = TWIPrevData;
++Address;
if (Address >= Servo32::ChNum) Address = 0;
State = US_SendData;
}

void HandleUserState() {
uint8_t TranslatedAddress;
switch (State) {
case US_ReceiveAddr:
switch (TWIStatus) {
case TW_SR_DATA_ACK:
if (TWIData >= Servo32::ChNum) Address = Servo32::ChNum - 1; else Address = TWIData;
State = US_ReceiveData;
break;
default:
ResetTWI();
break;
}
break;
case US_ReceiveData:
switch (TWIStatus) {
case TW_SR_DATA_ACK:
TranslatedAddress = pgm_read_byte(AddrTable+Address);
Servo32::Data[TranslatedAddress] = TWIData;
++Address;
if (Address >= Servo32::ChNum) Address = 0;

break;
default:
ResetTWI();
break;
}
break;
case US_SendData:
switch (TWIStatus) {
case TW_ST_DATA_ACK:
TranslatedAddress = pgm_read_byte(AddrTable+Address);
TWIPrevData = Servo32::Data[TranslatedAddress];
TWDR = TWIPrevData;
++Address;
if (Address >= Servo32::ChNum) Address = 0;
SETBIT(TWIControl,(1 << TWEA)); // wymagany sygnał ACK
break;
default:
ResetTWI();
break;
}
break;
default:

ResetTWI();
break;
}
}
}

SIGNAL(SIG_USART_RECV) {UsartComm::StateMachine();}

int main() {
OSCCAL = 0x7a; // kwarc 6.5MHz
cli();
EEPROM::Init();
OpLed::Init();
Servo32::Init();
UsartComm::Init(USART0::baud57600_6_5MHz);
TWI::Init();
sei();
while (true) {
}
return 0;
}
[/syntax]

możecie rozgryzać a łatwo nie będzie

Statystyki: Napisane przez SunRiver — 16 cze 2012, o 22:10

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T21:18:25+01:00

No nie przyszło mi to do głowy.
Jakoś się zafiksowałem że wymagana rozdzielczość jest 16bit.

Statystyki: Napisane przez janbernat — 16 cze 2012, o 21:18

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T20:34:21+01:00

ale przecież obsługę pilota można spokojnie przenieść do timera 8-bitowego i wtedy 16-bitowy będzie wolny

Statystyki: Napisane przez mirekk36 — 16 cze 2012, o 20:34

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T19:59:37+01:00

No to weź mój kod i sprawdź na większej ilości serw.
Wiem że działa bez pudła- ale...
Serwa mają dużą oporność wejściową i jakiekolwiek zakłócenia sprawiają że zaczynają drżeć.
Mimo że sygnał sterujący jest stabilny.
Trzeba jednak dać na linie sterujące jakiś opornik (1k) do masy i jakiś kondensator (100p-1n) też do masy.
A tanie serwa to już robią co chcą.
Wszystkie osiem serw podłaczyłem na płytce stykowej i początkowo muślałem że się załamię.
Serwa reagowały na sygnały z sąsiednich serw.
No ale się w końcu udało odkłócić i działało bez problemu.
W książce Mirka jest sterowanie pilotem- ale też wykorzystuje timer 16 bit.
Chyba Mirek powinien się przestawić na ARM- ten jeden timer 16bit w AVR to za mało.
Apetyt rośnie w miarę jedzenia.

Statystyki: Napisane przez janbernat — 16 cze 2012, o 19:59

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T19:11:28+01:00

Janbernat, nie miałem nic złego na myśli, po prostu mam złe nawyki z elki, i elportalu, wiecznie ktoś czegoś chce by mu coś zrobić, zero własnej inwencji.
Sam ostatnio przebrnąłem przez sterowanie serwami . Całe szczęście miałem tylko jedno, ale z moją wiedzą to i tak cud, że zadziałało.

Statystyki: Napisane przez Gość — 16 cze 2012, o 19:11

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T19:02:23+01:00

obiecuję że zamieszczę kod do hexapoda, ale musicie się w cierpliwość uzbroić bo mam sporo na głowie i wiele rzeczy robię na raz

twój kod jest całkiem całkiem muszę przyznać

Statystyki: Napisane przez SunRiver — 16 cze 2012, o 19:02

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T18:48:18+01:00

No i na stare lata zostałem roszczeniowym pasożytem...
Zamieszczam rozwiązanie dla ośmiu serw- to rozwiąże problem autora tematu.
Sterowanie z ośmiu potencjometrów podpiętych do ADC.
Można to przerobić na sterowanie z jakichś innych źródeł sygnałów.
Można to znaleźć na elce.
I parę innych moich gotowców też.
[syntax=c]
//Program do sterowania serwami
//Max 8 serw z 8 kanałów ADC
//Wszystko jest w pliku main- można to zrobić w serwa.c i serwa.h
//Nie jest to więc gotowiec- ale sprawdzony od 1-16MHz i od 1-8 serw.
//ATMega32

#include
#include

#define LICZBA_KANALOW 8 //maksymalnie-8
#if F_CPU>2000000ul
#define PRESCALER 8
#else
#define PRESCALER 1
#endif

#define OCR1A_VALUE ((2*F_CPU/PRESCALER/100)/LICZBA_KANALOW)// sygnał co 20ms
#define OCR1B_MIN (6*F_CPU/PRESCALER/10000) //Pozycja min serwa- tutaj 0.6ms- dopasować do serwa
#define OCR1B_ADC (18*F_CPU/PRESCALER/10000)//Pozycja max serwa- tutaj 1.8+0.6ms- dopasować do serwa
// Zwykle jest 1-2ms- no ale serwa są różne
volatile unsigned int kanal;

static inline void init_ADC(void)
{
ADMUX |= _BV(REFS0);

ADCSRA = _BV(ADEN);
#if F_CPU>=8000000ul
ADCSRA|=_BV(ADPS0)|_BV(ADPS1)|_BV(ADPS2);
#endif
#if ((F_CPU>=4000000ul)&&(F_CPU<8000000ul))
ADCSRA|=_BV(ADPS0)|_BV(ADPS2);
#endif
#if ((F_CPU>=2000000ul)&&(F_CPU<4000000ul))
ADCSRA|=_BV(ADPS2);
#endif
#if ((F_CPU>=1000000ul)&&(F_CPU<2000000ul))
ADCSRA|= _BV(ADPS0)|_BV(ADPS1);
#endif
#if F_CPU<1000000ul//poniżej 1MHz to już niedobrze działa
#error system timer is too slow
#endif

ADCSRA |= _BV(ADSC);
while (!(ADCSRA & _BV(ADIF)));
ADCSRA |= _BV(ADIF);
}

static inline void init_Timer1(void)
{
#if PRESCALER==1
TCCR1B|=_BV(CS10)|_BV(WGM12);
#else
TCCR1B|=_BV(CS11)|_BV(WGM12);
#endif
TIMSK|= _BV(OCIE1A)|_BV(OCIE1B);
OCR1A=OCR1A_VALUE;
OCR1B=OCR1A_VALUE-5;

TIMSK|= _BV(OCIE1A)|_BV(OCIE1B);
}

static inline void init_Ports(void)
{
PORTC=0;
DDRC=255;
}

int main(void)
{
init_Ports();
init_ADC();
init_Timer1();
sei();

while(1)
{
//a tu co chciał wstawić
}

}

ISR(TIMER1_COMPA_vect)
{
PORTC=0;
OCR1B = (OCR1A_VALUE - OCR1B_MIN) - OCR1B_ADC*ADCW/1024;
kanal++;
if(kanal>=LICZBA_KANALOW) kanal=0;
ADMUX = ((ADMUX&0xF0)+ kanal);
}

ISR(TIMER1_COMPB_vect)
{
static unsigned char port = 1;
ADCSRA |= _BV(ADSC);
PORTC |= port;
port <<= 1;
if(kanal>=LICZBA_KANALOW-1) port=1;
}
[/syntax]
Co nie zmienia mojej ciekawości jak to SunRiver rozwiązał dla 12 serw.

Statystyki: Napisane przez janbernat — 16 cze 2012, o 18:48

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T14:42:23+01:00

rezasurmar napisał(a):

Gotowe rozwiązania masz na elce, tu gotowca nikt ci nie da . Wysil trochę szare komórki.

Otóż to

Statystyki: Napisane przez kierlan — 16 cze 2012, o 14:42

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T13:10:43+01:00

Gotowe rozwiązania masz na elce, tu gotowca nikt ci nie da . Wysil trochę szare komórki.

Statystyki: Napisane przez Gość — 16 cze 2012, o 13:10

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-06-16T12:26:36+01:00

SunRiver- bardzo czekam na kod do sterowania 12serw.
Zrobiłem program do sterowania ośmiu na timerze 16bit.
Ale więcej niż osiem to się tam nie zmieści.
Zacząłem tworzyć na dwóch timerach dla większej ilości- ale ostatnio zmuszony byłem to odłożyć na potem.

Statystyki: Napisane przez janbernat — 16 cze 2012, o 12:26

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-05-25T22:29:20+01:00

elsat1 napisał(a):

kierlan napisał(a):

Albo nie umiesz czytać, albo nie myślisz lub jedno i drugie. Istnieje jeszcze opcja, że czekasz znowu aż ktoś Ci poda na tacy gotowca.

Kto pyta nie błądzi.

Właśnie za tego typu wypowiedzi dostałeś ostrzeżenie .... (SunRiver)[/quote]

Nie widzę w moich pytaniach na tym forum czegoś obraźliwego....

Statystyki: Napisane przez elsat1 — 25 maja 2012, o 22:29

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-05-25T21:42:23+01:00

ejejej panowie spokojnie.

Kol. ELSAT1

najpierw odpowiem na pytanie :

1. Typowe serwo modelarskie ma kąt pracy 180 nie 120st
2. Sterujesz tak samo jak nie przerobionym tyle tylko że serwo nie dotrze nigdy do końca w żadną stronę
dlatego będzie mogło się obracać do okoła , i tu musisz tylko zadbać o to by ono wiedziało że już ma stanąć

a druga sprawa w twoim poście.

Statystyki: Napisane przez SunRiver — 25 maja 2012, o 21:42

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-05-25T21:38:22+01:00

wiesz, ale tu już padła odpowiedź na to pytanie. Sam ją przytoczyłeś.

Statystyki: Napisane przez kierlan — 25 maja 2012, o 21:38

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-05-25T21:28:32+01:00

kierlan napisał(a):

Albo nie umiesz czytać, albo nie myślisz lub jedno i drugie. Istnieje jeszcze opcja, że czekasz znowu aż ktoś Ci poda na tacy gotowca.

[/quote]

Kto pyta nie błądzi.

Właśnie za tego typu wypowiedzi dostałeś ostrzeżenie .... (SunRiver)

Statystyki: Napisane przez elsat1 — 25 maja 2012, o 21:28

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-05-25T21:13:43+01:00

elsat1 napisał(a):

SunRiver napisał(a):

W przypadku przerabiania serwa na obrotowe 360st trzeba potencjometr skręcić w skrajne położenie lewe/prawe (niema znaczenia)
usunąć blokadę i klin obracający potencjometrem -- w ten sposób uzyskujemy silnik z przekładnią który możemy sterować
w obie strony L/P ale nie zatrzymuje się tylko kręci dookoła w żądanym impulsami kierunku.

A jak to zrobić w typowych serwach modelarskich, gdzie jest kąt tylko 120' ?
Przydało by się pełne sterowanie kątem np. kamery o 360 '.
Pewnie potrzebna będzie przystawka do kanału x. Nie wiem czy to jest możliwe by zastosować taką przystawkę do standardowych nadajników.
Może masz pomysł ?

Albo nie umiesz czytać, albo nie myślisz lub jedno i drugie. Istnieje jeszcze opcja, że czekasz znowu aż ktoś Ci poda na tacy gotowca.

Statystyki: Napisane przez kierlan — 25 maja 2012, o 21:13

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-05-25T20:28:59+01:00

SunRiver napisał(a):

Statystyki: Napisane przez elsat1 — 25 maja 2012, o 20:28

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-05-25T20:05:45+01:00

hmmm ... to trochę dziwne jest poszukam na dysku gdzieś się chyba jeszcze wala , kiedyś robiłem hexapoda
sterowanie było na 12 serw zrobione --- po 2 na nogę zapodam i sprawdzisz
czy ci działają dobrze.

Statystyki: Napisane przez SunRiver — 25 maja 2012, o 20:05

Re: Pilny problem z wysterowaniem serwomechanizmów

2012-05-25T16:06:32+01:00

Serwa nie przerabiałem, niedawno je zakupiłem. Jednak sytuacja się powtarza na kilku różnych serwach.
Sprzętowo sterując za pomocą timera 16 bitowego, wszystko elegancko działa.
Dopiero jak próbuje programowo to mam problem.
Próbuje to zrobić z kolei programowo, ponieważ potrzebuje niezależnie sterować 3 serwami a sprzętowo udawało mi się jedynie dwoma. Jak próbowałem kolejne za pomocą timera 8 bitowego wysterować to nie działało.

Statystyki: Napisane przez ruben — 25 maja 2012, o 16:06