随笔：针对Servo.h库的两个疑问进行了简单的验证

绿林网页 · 发表于 2012-9-9 18:40:32

针对Servo.h库进行了简单的问题验证
问题一：Servo.h 控制舵机，舵机可以接哪些管脚；
问题二：Servo库和pwm输出是否有冲突；

问题一测试经过：

将Arduino D0 ~ D13；A0~A5 共接 20个舵机

经测试，D0~D13 舵机均能正常工作，A0~A5 舵机无反应

结论：Servo库不能通过模拟口操作舵机，可以通过所有的数字口操作，原以为只能对pwm输出端操作舵机，可以同时控制14个舵机

问题二测试经过：

将Servo接2个舵机，并将 pwm控制呼吸灯程序融合进去，运行发现
呼吸灯频率快了很多，舵机无法工作

结论：Servo库确实和pwm输出有冲突，无法同时使用，很遗憾！

这一点，在常见的超声波传感器+舵机+电机驱动板制作智能小车中，如果用Servo库控制安装超声波的舵机，则无法使用pwm对智能小车进行调速。不知道有没有高手能通过程序解决这个问题！

┏ωǒ┛菰独 · 发表于 2012-9-9 19:27:15

根据楼主的描述我猜测舵机库是用了timer的定时中断软件翻转IO实现的PWM(准确来说是PMM), 而pwm输出则使用的timer的cap/compare模块(m430中是这么称呼的,不知avr中是不是也是这么称呼)

绿林网页 · 发表于 2012-9-9 22:41:04

┏ωǒ┛菰独发表于 2012-9-9 19:27
根据楼主的描述我猜测舵机库是用了timer的定时中断软件翻转IO实现的PWM(准确来说是PMM), 而pwm输出则使用 ...

吧库文件放到这里供研究哈
[pre lang="arduino" line="1" file="Servo.h"]#ifndef Servo_h
#define Servo_h

#include <inttypes.h>

/*
* Defines for 16 bit timers used with  Servo library
*
* If _useTimerX is defined then TimerX is a 16 bit timer on the curent board
* timer16_Sequence_t enumerates the sequence that the timers should be allocated
* _Nbr_16timers indicates how many 16 bit timers are available.
*
*/

// Say which 16 bit timers can be used and in what order
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define _useTimer5
#define _useTimer1
#define _useTimer3
#define _useTimer4
typedef enum { _timer5, _timer1, _timer3, _timer4, _Nbr_16timers } timer16_Sequence_t ;

#elif defined(__AVR_ATmega32U4__)
#define _useTimer3
#define _useTimer1
typedef enum { _timer3, _timer1, _Nbr_16timers } timer16_Sequence_t ;

#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)
#define _useTimer3
#define _useTimer1
typedef enum { _timer3, _timer1, _Nbr_16timers } timer16_Sequence_t ;

#elif defined(__AVR_ATmega128__) ||defined(__AVR_ATmega1281__)||defined(__AVR_ATmega2561__)
#define _useTimer3
#define _useTimer1
typedef enum { _timer3, _timer1, _Nbr_16timers } timer16_Sequence_t ;

#else  // everything else
#define _useTimer1
typedef enum { _timer1, _Nbr_16timers } timer16_Sequence_t ;
#endif

#define Servo_VERSION          2    // software version of this library

#define MIN_PULSE_WIDTH    544    // the shortest pulse sent to a servo
#define MAX_PULSE_WIDTH    2400    // the longest pulse sent to a servo
#define DEFAULT_PULSE_WIDTH  1500    // default pulse width when servo is attached
#define REFRESH_INTERVAL 20000    // minumim time to refresh servos in microseconds

#define SERVOS_PER_TIMER    12    // the maximum number of servos controlled by one timer
#define MAX_SERVOS (_Nbr_16timers  * SERVOS_PER_TIMER)

#define INVALID_SERVO       255    // flag indicating an invalid servo index

typedef struct  {
  uint8_t nbr       :6 ;          // a pin number from 0 to 63
  uint8_t isActive :1 ;          // true if this channel is enabled, pin not pulsed if false
} ServoPin_t ;

typedef struct {
  ServoPin_t Pin;
  unsigned int ticks;
} servo_t;

class Servo
{
public:
  Servo();
  uint8_t attach(int pin);          // attach the given pin to the next free channel, sets pinMode, returns channel number or 0 if failure
  uint8_t attach(int pin, int min, int max); // as above but also sets min and max values for writes.
  void detach();
  void write(int value);          // if value is < 200 its treated as an angle, otherwise as pulse width in microseconds
  void writeMicroseconds(int value); // Write pulse width in microseconds
  int read();                      // returns current pulse width as an angle between 0 and 180 degrees
  int readMicroseconds();          // returns current pulse width in microseconds for this servo (was read_us() in first release)
  bool attached();                // return true if this servo is attached, otherwise false
private:
uint8_t servoIndex;             // index into the channel data for this servo
int8_t min;                      // minimum is this value times 4 added to MIN_PULSE_WIDTH
int8_t max;                      // maximum is this value times 4 added to MAX_PULSE_WIDTH
};

#endif[/code]

[pre lang="arduino" line="1" file="Servo.cpp"]#include <avr/interrupt.h>
#include <Arduino.h>

#include "Servo.h"

#define usToTicks(_us) (( clockCyclesPerMicrosecond()* _us) / 8)    // converts microseconds to tick (assumes prescale of 8)  // 12 Aug 2009
#define ticksToUs(_ticks) (( (unsigned)_ticks * 8)/ clockCyclesPerMicrosecond() ) // converts from ticks back to microseconds

#define TRIM_DURATION    2                            // compensation ticks to trim adjust for digitalWrite delays // 12 August 2009

//#define NBR_TIMERS       (MAX_SERVOS / SERVOS_PER_TIMER)

static servo_t servos[MAX_SERVOS];                         // static array of servo structures
static volatile int8_t Channel[_Nbr_16timers ];          // counter for the servo being pulsed for each timer (or -1 if refresh interval)

uint8_t ServoCount = 0;                                  // the total number of attached servos

// convenience macros
#define SERVO_INDEX_TO_TIMER(_servo_nbr) ((timer16_Sequence_t)(_servo_nbr / SERVOS_PER_TIMER)) // returns the timer controlling this servo
#define SERVO_INDEX_TO_CHANNEL(_servo_nbr) (_servo_nbr % SERVOS_PER_TIMER)    // returns the index of the servo on this timer
#define SERVO_INDEX(_timer,_channel)  ((_timer*SERVOS_PER_TIMER) + _channel)    // macro to access servo index by timer and channel
#define SERVO(_timer,_channel)  (servos[SERVO_INDEX(_timer,_channel)])          // macro to access servo class by timer and channel

#define SERVO_MIN() (MIN_PULSE_WIDTH - this->min * 4)  // minimum value in uS for this servo
#define SERVO_MAX() (MAX_PULSE_WIDTH - this->max * 4)  // maximum value in uS for this servo

/************ static functions common to all instances ***********************/

static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t *TCNTn, volatile uint16_t* OCRnA)
{
  if( Channel[timer] < 0 )
*TCNTn = 0; // channel set to -1 indicated that refresh interval completed so reset the timer
  else{
if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && SERVO(timer,Channel[timer]).Pin.isActive == true )
   digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,LOW); // pulse this channel low if activated
  }

  Channel[timer]++; // increment to the next channel
  if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) {
*OCRnA = *TCNTn + SERVO(timer,Channel[timer]).ticks;
if(SERVO(timer,Channel[timer]).Pin.isActive == true)    // check if activated
   digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,HIGH); // its an active channel so pulse it high
  }
  else {
// finished all channels so wait for the refresh period to expire before starting over
if( (unsigned)*TCNTn <  (usToTicks(REFRESH_INTERVAL) + 4) )  // allow a few ticks to ensure the next OCR1A not missed
   *OCRnA = (unsigned int)usToTicks(REFRESH_INTERVAL);
else
   *OCRnA = *TCNTn + 4;  // at least REFRESH_INTERVAL has elapsed
Channel[timer] = -1; // this will get incremented at the end of the refresh period to start again at the first channel
  }
}

#ifndef WIRING // Wiring pre-defines signal handlers so don't define any if compiling for the Wiring platform
// Interrupt handlers for Arduino
#if defined(_useTimer1)
SIGNAL (TIMER1_COMPA_vect)
{
  handle_interrupts(_timer1, &TCNT1, &OCR1A);
}
#endif

#if defined(_useTimer3)
SIGNAL (TIMER3_COMPA_vect)
{
  handle_interrupts(_timer3, &TCNT3, &OCR3A);
}
#endif

#if defined(_useTimer4)
SIGNAL (TIMER4_COMPA_vect)
{
  handle_interrupts(_timer4, &TCNT4, &OCR4A);
}
#endif

#if defined(_useTimer5)
SIGNAL (TIMER5_COMPA_vect)
{
  handle_interrupts(_timer5, &TCNT5, &OCR5A);
}
#endif

#elif defined WIRING
// Interrupt handlers for Wiring
#if defined(_useTimer1)
void Timer1Service()
{
  handle_interrupts(_timer1, &TCNT1, &OCR1A);
}
#endif
#if defined(_useTimer3)
void Timer3Service()
{
  handle_interrupts(_timer3, &TCNT3, &OCR3A);
}
#endif
#endif

static void initISR(timer16_Sequence_t timer)
{
#if defined (_useTimer1)
  if(timer == _timer1) {
TCCR1A = 0;          // normal counting mode
TCCR1B = _BV(CS11);    // set prescaler of 8
TCNT1 = 0;             // clear the timer count
#if defined(__AVR_ATmega8__)|| defined(__AVR_ATmega128__)
TIFR |= _BV(OCF1A);    // clear any pending interrupts;
TIMSK |=  _BV(OCIE1A) ;  // enable the output compare interrupt
#else
// here if not ATmega8 or ATmega128
TIFR1 |= _BV(OCF1A);    // clear any pending interrupts;
TIMSK1 |=  _BV(OCIE1A) ; // enable the output compare interrupt
#endif
#if defined(WIRING)
timerAttach(TIMER1OUTCOMPAREA_INT, Timer1Service);
#endif
  }
#endif

#if defined (_useTimer3)
  if(timer == _timer3) {
TCCR3A = 0;          // normal counting mode
TCCR3B = _BV(CS31);    // set prescaler of 8
TCNT3 = 0;             // clear the timer count
#if defined(__AVR_ATmega128__)
TIFR |= _BV(OCF3A);    // clear any pending interrupts;
ETIMSK |= _BV(OCIE3A);  // enable the output compare interrupt
#else
TIFR3 = _BV(OCF3A);    // clear any pending interrupts;
TIMSK3 =  _BV(OCIE3A) ; // enable the output compare interrupt
#endif
#if defined(WIRING)
timerAttach(TIMER3OUTCOMPAREA_INT, Timer3Service);  // for Wiring platform only
#endif
  }
#endif

#if defined (_useTimer4)
  if(timer == _timer4) {
TCCR4A = 0;          // normal counting mode
TCCR4B = _BV(CS41);    // set prescaler of 8
TCNT4 = 0;             // clear the timer count
TIFR4 = _BV(OCF4A);    // clear any pending interrupts;
TIMSK4 =  _BV(OCIE4A) ; // enable the output compare interrupt
  }
#endif

#if defined (_useTimer5)
  if(timer == _timer5) {
TCCR5A = 0;          // normal counting mode
TCCR5B = _BV(CS51);    // set prescaler of 8
TCNT5 = 0;             // clear the timer count
TIFR5 = _BV(OCF5A);    // clear any pending interrupts;
TIMSK5 =  _BV(OCIE5A) ; // enable the output compare interrupt
  }
#endif
}

static void finISR(timer16_Sequence_t timer)
{
//disable use of the given timer
#if defined WIRING // Wiring
  if(timer == _timer1) {
#if defined(__AVR_ATmega1281__)||defined(__AVR_ATmega2561__)
TIMSK1 &=  ~_BV(OCIE1A) ;  // disable timer 1 output compare interrupt
#else
TIMSK &=  ~_BV(OCIE1A) ;  // disable timer 1 output compare interrupt
#endif
timerDetach(TIMER1OUTCOMPAREA_INT);
  }
  else if(timer == _timer3) {
#if defined(__AVR_ATmega1281__)||defined(__AVR_ATmega2561__)
TIMSK3 &= ~_BV(OCIE3A); // disable the timer3 output compare A interrupt
#else
ETIMSK &= ~_BV(OCIE3A); // disable the timer3 output compare A interrupt
#endif
timerDetach(TIMER3OUTCOMPAREA_INT);
  }
#else
//For arduino - in future: call here to a currently undefined function to reset the timer
#endif
}

static boolean isTimerActive(timer16_Sequence_t timer)
{
  // returns true if any servo is active on this timer
  for(uint8_t channel=0; channel < SERVOS_PER_TIMER; channel++) {
if(SERVO(timer,channel).Pin.isActive == true)
   return true;
  }
  return false;
}

/****************** end of static functions ******************************/

Servo::Servo()
{
  if( ServoCount < MAX_SERVOS) {
this->servoIndex = ServoCount++;                   // assign a servo index to this instance
servos[this->servoIndex].ticks = usToTicks(DEFAULT_PULSE_WIDTH); // store default values  - 12 Aug 2009
  }
  else
this->servoIndex = INVALID_SERVO ;  // too many servos
}

uint8_t Servo::attach(int pin)
{
  return this->attach(pin, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
}

uint8_t Servo::attach(int pin, int min, int max)
{
  if(this->servoIndex < MAX_SERVOS ) {
pinMode( pin, OUTPUT) ;                                  // set servo pin to output
servos[this->servoIndex].Pin.nbr = pin;
// todo min/max check: abs(min - MIN_PULSE_WIDTH) /4 < 128
this->min  = (MIN_PULSE_WIDTH - min)/4; //resolution of min/max is 4 uS
this->max  = (MAX_PULSE_WIDTH - max)/4;
// initialize the timer if it has not already been initialized
timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
if(isTimerActive(timer) == false)
   initISR(timer);
servos[this->servoIndex].Pin.isActive = true;  // this must be set after the check for isTimerActive
  }
  return this->servoIndex ;
}

void Servo::detach()
{
  servos[this->servoIndex].Pin.isActive = false;
  timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
  if(isTimerActive(timer) == false) {
finISR(timer);
  }
}

void Servo::write(int value)
{
  if(value < MIN_PULSE_WIDTH)
  {  // treat values less than 544 as angles in degrees (valid values in microseconds are handled as microseconds)
if(value < 0) value = 0;
if(value > 180) value = 180;
value = map(value, 0, 180, SERVO_MIN(),  SERVO_MAX());
  }
  this->writeMicroseconds(value);
}

void Servo::writeMicroseconds(int value)
{
  // calculate and store the values for the given channel
  byte channel = this->servoIndex;
  if( (channel >= 0) && (channel < MAX_SERVOS) ) // ensure channel is valid
  {
if( value < SERVO_MIN() )       // ensure pulse width is valid
   value = SERVO_MIN();
else if( value > SERVO_MAX() )
   value = SERVO_MAX();

    value = value - TRIM_DURATION;
value = usToTicks(value);  // convert to ticks after compensating for interrupt overhead - 12 Aug 2009

uint8_t oldSREG = SREG;
cli();
servos[channel].ticks = value;
SREG = oldSREG;
  }
}

int Servo::read() // return the value as degrees
{
  return  map( this->readMicroseconds()+1, SERVO_MIN(), SERVO_MAX(), 0, 180);
}

int Servo::readMicroseconds()
{
  unsigned int pulsewidth;
  if( this->servoIndex != INVALID_SERVO )
pulsewidth = ticksToUs(servos[this->servoIndex].ticks)  + TRIM_DURATION ; // 12 aug 2009
  else
pulsewidth  = 0;

  return pulsewidth;
}

bool Servo::attached()
{
  return servos[this->servoIndex].Pin.isActive ;
}
[/code]

┏ωǒ┛菰独 · 发表于 2012-9-9 22:52:16

绿林网页发表于 2012-9-9 22:41
吧库文件放到这里供研究哈
#ifndef Servo_h
#define Servo_h

里面很多高级语法看不懂..

月，依旧故乡明 · 发表于 2013-2-25 19:15:12

看不懂啊。

lane3000 · 发表于 2013-4-23 20:49:55

额~表示在servo.h文件中发现了一句话Timers are seized as needed in groups of 12 servos - 24 servos use two timers, 48 servos will use four.
于是找到了#define SERVOS_PER_TIMER 12 把12改成13 之后，A0就能被这个servo库驱动了，开心中~~~

绿林网页 · 发表于 2013-5-1 21:41:07

lane3000 发表于 2013-4-23 20:49
额~表示在servo.h文件中发现了一句话Timers are seized as needed in groups of 12 servos - 24 servos use ...

学习了。。。

学慧放弃 · 发表于 2013-10-29 20:04:29

菜鸟最近做六轴，要用到PWM驱动库，不知楼主怎么使用的该库？？用来控制参数

绿林网页 · 发表于 2013-10-29 20:35:45

六轴用不到舵机吧，不需要舵机库，直接输出pwm信号就行了

沧海笑1122 · 发表于 2013-12-10 23:40:53

本帖最后由沧海笑1122 于 2013-12-11 00:11 编辑

@绿林网页兄,我正是遇到了这个问题：在小车制作中,有一个舵机(准备作为摄像头云台),电机驱动板是L298（双电机），利用PWM对两只电机分别调速，结果就出现了只能驱动一只电机的情况，另外一只电机无论如何都不能正常驱动。把舵机库暂时去除后，双电机驱动正常。

后来才查到你这篇文章，谢谢你的验证。
查阅了舵机库的资料：
The Servo library supports up to 12 motors on most Arduino boards and 48 on the Arduino Mega. On boards other than the Mega, use of the library disables analogWrite() (PWM) functionality on pins 9 and 10, whether or not there is a Servo on those pins. On the Mega, up to 12 servos can be used without interfering with PWM functionality; use of 12 to 23 motors will disable PWM on pins 11 and 12.

我感觉避开pin9,pin10，其它的pin应该是可以的，我试过5，6就没有问题。

绿林网页 · 发表于 2013-12-11 13:09:17

沧海笑1122 发表于 2013-12-10 23:40
@绿林网页兄,我正是遇到了这个问题：在小车制作中,有一个舵机(准备作为摄像头云台),电机驱动板是L298（双电 ...

你是说电机pwm不接9和10脚就可以，是吗

沧海笑1122 · 发表于 2013-12-11 16:12:41

没错，我试过，5，6，11都没问题。这才会出现我采用pin10,11，只能驱动一只电机的情况。详情在求助区设了一帖，供参考。谢谢。

帐号		自动登录	找回密码
密码			注册