Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Merge branch 'master' into MX1_MX2

  • Loading branch information...
commit c9192ee6827b4d3d3374677be7b3e2001929ca65 2 parents a8df270 + 94612a2
@EmbeddedMan EmbeddedMan authored
View
94 hardware/pic32/libraries/Servo/Servo.cpp
@@ -1,6 +1,6 @@
//************************************************************************
/*
- Servo.cpp - Interrupt driven Servo library for Arduino using 16 bit timers- Version 2
+ Servo.cpp - Interrupt driven Servo library for Arduino using 16 bit timers
Copyright (c) 2009 Michael Margolis. All right reserved.
Revision date: 08/18/2011(Michelle Yu)
@@ -20,13 +20,19 @@
*/
//************************************************************************
-/*
-
+/*
A servo is activated by creating an instance of the Servo class passing the desired pin to the attach() method.
The servos are pulsed in the background using the value most recently written using the write() method
Note that analogWrite of PWM on pins associated with the timer are disabled when the first servo is attached.
- Timers are seized as needed in groups of 8 servos - 16 servos use two timers, 32 servos will use four.
+ Timers are seized as needed in groups of 8 servos - 16 servos use two timers, 24 servos will use three.
+
+ For the PIC32, the three timers that are used are (in order):
+ Timer4 (for 1 through 8 servos)
+ Timer5 (for 9 through 16 servos)
+ Timer3 (for 17 through 24 servos)
+
+ Be careful that other libraries do not use any of the timers that you need for your servos.
The methods are:
@@ -53,6 +59,9 @@
//* Sep 1, 2011 <MLS> issue #112, changed assigment to compare in finISR
//* Sep 5, 2011 <GeneApperson> added include of plib.h to fix compile errors
//* introduced when plib.h was removed from HardwareSerial.h
+//* Sep 18, 2012 <BPS> Fixed math problem with refresh interval, and
+//* expanded nbr to 7 bits for pins above 63 (MAX32 has 83)
+//* And adjusted trim to 1 tick (measured and adjusted)
//************************************************************************
#include <plib.h>
@@ -65,16 +74,13 @@ extern "C"{
#define usToTicks(_us) (((_us)*5)/4) // converts microseconds to tick
#define ticksToUs(_ticks) ((((unsigned)(_ticks))*4)/5) // converts from ticks back to microseconds
-
-#define TRIM_DURATION 2 // compensation ticks to trim adjust for digitalWrite delays // 12 August 200
-
+#define TRIM_DURATION 1 // compensation ticks to trim adjust for digitalWrite delays // 12 August 200
static servo_t servos[MAX_SERVOS]; // static array of servo structures
int channel[3]; // channel for the current servo
uint8_t ServoCount = 0; // the total number of attached servos
-
#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
#define SERVO_INDEX(_timer,_channel) ((_timer*SERVOS_PER_TIMER) + _channel) // macro to access servo index by timer and channel
@@ -83,50 +89,60 @@ uint8_t ServoCount = 0; // the total number of attached servos
/************ static functions common to all instances ***********************/
//************************************************************************
-void handle_interrupts(int timer, volatile unsigned int *TMRn, volatile unsigned int *PR)
+// Note: PIC32 timers (TMRn) reset to zero when they match PRn.
+void handle_interrupts(int timer, volatile unsigned int *TMRn, volatile unsigned int *PRn)
{
-
-
+ static uint32_t AccumulatedTicks[3] = {0,0,0}; // Store the number of ticks since the first rising edge for this timer
+
+ // Test for invalid timer number
+ if (timer >= 3)
+ {
+ return;
+ }
+
+ // If this value is -1, then we have just finished with the time from the end of the last pulse
+ // and need to start with the first servo index on this timer again.
if ( channel[timer] < 0 )
{
- *TMRn = 0; // channel set to -1 indicated that refresh interval completed so reset the timer
+ AccumulatedTicks[timer] = 0; // Clear the accumulated time for this timer on first rising edge
}
else
{
+ // If this is not the first pulse, then set the old pin low
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
+ digitalWrite( SERVO(timer,channel[timer]).Pin.nbr, LOW); // pulse this channel low if activated
}
}
channel[timer]++; // increment to the next channel
+ // If we have not run out of channels (on this timer),
if ( SERVO_INDEX(timer,channel[timer]) < ServoCount && channel[timer] < SERVOS_PER_TIMER)
{
- *PR = *TMRn + SERVO(timer,channel[timer]).ticks;
+ // Then set the time we want to fire next (the width for this channel)
+ *PRn = SERVO(timer,channel[timer]).ticks;
+ // Set this channel's pin high if its active
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
+ digitalWrite( SERVO(timer,channel[timer]).Pin.nbr, HIGH); // its an active channel so pulse it high
}
+ AccumulatedTicks[timer] += *PRn; // Add the time we are about to spend on this channel
}
else
{
- *TMRn = channel[timer] * usToTicks(MAX_PULSE_WIDTH);
- // finished all channels so wait for the refresh period to expire before starting over
- if ( (unsigned)*TMRn < (usToTicks(REFRESH_INTERVAL) + 4) ) // allow a few ticks to ensure the next OCR1A not missed
+ // Otherwise, finished all channels so next fire needs to be at REFRESH_INTERVAL - AccumulatedTicks
+ if (AccumulatedTicks[timer] < (usToTicks(REFRESH_INTERVAL) - 4))
{
- *PR = (unsigned int)usToTicks(REFRESH_INTERVAL);
+ *PRn = (unsigned int)(usToTicks(REFRESH_INTERVAL)) - AccumulatedTicks[timer];
}
else
{
- *PR = *TMRn + 4; // at least REFRESH_INTERVAL has elapsed
+ *PRn = *TMRn + 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
}
}
-
-
-
//************************************************************************
static void finISR(int timer)
{
@@ -157,21 +173,24 @@ static boolean isTimerActive(int timer)
return false;
}
-
/****************** end of static functions ******************************/
Servo::Servo()
{
- if ( ServoCount < MAX_SERVOS)
+ if (ServoCount < MAX_SERVOS)
{
+ /// TODO: Really, we need to search through servos[] for the first one
+ /// that is not being used, rather than always use ServoCount as the
+ /// index. What happens if you create 24 servos, then destroy one
+ /// and create another. Right now that would fail, even though you
+ /// weren't actively using 24 servos.
this->servoIndex = ServoCount++; // assign a servo index to this instance
servos[this->servoIndex].ticks = usToTicks(DEFAULT_PULSE_WIDTH); // store default to neutral position
}
else
- this->servoIndex = INVALID_SERVO ; // too many servos
+ this->servoIndex = INVALID_SERVO ; // too many servos
}
-
//************************************************************************
uint8_t Servo::attach(int pin)
{
@@ -181,16 +200,9 @@ uint8_t Servo::attach(int pin)
//************************************************************************
uint8_t Servo::attach(int pin, int min, int max)
{
- if (this->servoIndex < MAX_SERVOS )
+ if (this->servoIndex < ServoCount)
{
- if (pin == 0 | pin == 1)
- {
- // disable UART
- U1MODE = 0x0;
-
- }
-
- pinMode( pin, OUTPUT) ; // set servo pin to output
+ pinMode(pin, OUTPUT); // set servo pin to output
servos[this->servoIndex].Pin.nbr = pin;
this->min = (MIN_PULSE_WIDTH - min)/4; // resolution of min/max is 4 uS
this->max = (MAX_PULSE_WIDTH - max)/4;
@@ -204,10 +216,13 @@ uint8_t Servo::attach(int pin, int min, int max)
return this->servoIndex;
}
+ else
+ {
+ // return bogus value if this->ServoIndex is invalid
+ return(INVALID_SERVO);
+ }
}
-
-
//************************************************************************
void Servo::detach()
{
@@ -248,12 +263,9 @@ void Servo::writeMicroseconds(int value)
value = value - TRIM_DURATION;
value = usToTicks(value); // convert to ticks after compensating for interrupt overhead
-
-
unsigned int status;
status = INTDisableInterrupts();
servos[channel].ticks = value;
-
INTRestoreInterrupts(status);
}
}
View
79 hardware/pic32/libraries/Servo/Servo.h
@@ -1,25 +1,24 @@
-/*
- Servo.h - Interrupt driven Servo library for Arduino using 16 bit timers- Version 2
- Copyright (c) 2009 Michael Margolis. All right reserved.
- Revision date: 08/18/2011(Michelle Yu)
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+/*
+ Servo.h - Interrupt driven Servo library for Arduino using 16 bit timers
+ Copyright (c) 2009 Michael Margolis. All right reserved.
+ Revision date: 08/18/2011(Michelle Yu)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
-
A servo is activated by creating an instance of the Servo class passing the desired pin to the attach() method.
The servos are pulsed in the background using the value most recently written using the write() method
@@ -41,8 +40,24 @@
readMicroseconds() - Gets the last written servo pulse width in microseconds. (was read_us() in first release)
attached() - Returns true if there is a servo attached.
detach() - Stops an attached servos from pulsing its i/o pin.
+
+ This library has been modified to support the PIC32 architecture.
+
+ NOTE: On 09/18/2012 the code to disable a UART on pins 0 and 1 when
+ assigning a servo to those pins was removed, since not all boards have
+ UARTs on pins 0 and 1. You must be careful to disable any other function
+ on a given pin before you start using a servo output on that pin. For
+ example, if you have the standard UART on pins 1 and 0 and you want to use
+ those pins for servo output, you would need to disable the UART first.
+ Example:
+ Serial.end();
+ Servo.attach(0);
+
+ Version history:
+ See Servo.cpp
*/
+
#ifndef Servo_h
#define Servo_h
@@ -53,33 +68,17 @@
#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
-
-
-#define Servo_VERSION 3 // software version of this library
-
-#define SERVOS_PER_TIMER 8 // the maximum number of servos controlled by one timer
-#define MAX_SERVOS 24
-
-
-#define MIN_PULSE_WIDTH 544 // the shortest pulse sent to a servo (us)
+#define Servo_VERSION 3 // software version of this library
+#define SERVOS_PER_TIMER 8 // the maximum number of servos controlled by one timer
+#define MAX_SERVOS 24 // Maximum number of servos this library can support at once
+#define MIN_PULSE_WIDTH 544 // the shortest pulse sent to a servo (us)
#define MAX_PULSE_WIDTH 2400 // the longest pulse sent to a servo (us)
#define DEFAULT_PULSE_WIDTH 1500 // default pulse width when servo is attached (us)
#define REFRESH_INTERVAL 20000 // minumim time to refresh servos in microseconds
-
#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 nbr :7 ; // a pin number from 0 to 127
uint8_t isActive :1 ; // true if this channel is enabled, pin not pulsed if false
} ServoPin_t ;
View
41 hardware/pic32/libraries/Servo/readme.mb
@@ -0,0 +1,41 @@
+# readme.mb : Readme file for chipKIT/MPIDE Servo library
+
+## Overview:
+
+The Servo library allows a sketch to output RC servo pulses on up to 24 of the I/O pins
+at a time. These servo pulses are all controlled by hardware timers and interrupts, so that
+once they are started, they continue to output pulses with no sketch code interaction.
+
+Use this library to control up to 24 RC servos at a time, using either degree (0 to 179)
+parameter or microsecond pulse durations (from 544us to 2400us).
+
+## Usage:
+
+See the Servo.cpp and Servo.h files for detailed usage information.
+
+## Operation:
+
+The way the library works is to keep a list of all possible servos. Each time you create
+a new Servo object and attach it to a pin, the next servo in the list is populated with
+the pin number, the duration (in uS) and which of three timers will control that servo.
+
+The three timers are dynamically turned on/off as needed to support the number of servos
+used, with up to 8 servos on each of the three timers. Each time the timer fires, it
+clears the current servo pin and set the next one in the list, then sets itself to fire
+again in the future the duration of the new servo high period. After all servos have fired,
+the timer then sets itself to fire such that the entire process repeats every 20ms or so.
+
+Even though timers are used, the actual pin setting and clearing is done in software in
+the timer's ISR. Thus these servos will have jitter based upon what other interrupts
+are enabled and running on the system at the time.
+
+## Notes:
+
+See Servo.cpp and Servo.h for more information on special precautions when using the
+library.
+
+## History:
+
+This library was adatped for the PIC32 architecture from the Arduino Servo library. See
+Servo.cpp for more history information
+
Please sign in to comment.
Something went wrong with that request. Please try again.