arduino/esp8266
1
0
Fork 0
mirror of https://github.com/esp8266/Arduino.git synced 2025-07-27 18:02:17 +03:00
Code Activity

Timer0 and Servo library support

Browse Source 
This exposes the Timer0
This provides a Servo library support compatible with Arduino Servo
library but only supports the two timers the esp8266 has available
This commit is contained in:
Makuna
2015-05-29 13:30:15 -07:00
parent bca0997046
commit 3c3bc0f523
9 changed files with 727 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
libraries/Servo/examples/Sweep/Sweep.ino Normal file
View File

@ -0,0 +1,39 @@
/* Sweep
by BARRAGAN <http://barraganstudio.com>
This example code is in the public domain.
modified 28 May 2015
by Michael C. Miller
modified 8 Nov 2013
by Scott Fitzgerald
http://arduino.cc/en/Tutorial/Sweep
*/
#include <Servo.h>
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
void setup()
{
myservo.attach(2); // attaches the servo on GIO2 to the servo object
}
void loop()
{
int pos;
for(pos = 0; pos <= 180; pos += 1) // goes from 0 degrees to 180 degrees
{ // in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
for(pos = 180; pos>=0; pos-=1) // goes from 180 degrees to 0 degrees
{
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
}

24
libraries/Servo/keywords.txt Normal file
View File

@ -0,0 +1,24 @@
#######################################
# Syntax Coloring Map Servo
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
Servo KEYWORD1 Servo
#######################################
# Methods and Functions (KEYWORD2)
#######################################
attach KEYWORD2
detach KEYWORD2
write KEYWORD2
read KEYWORD2
attached KEYWORD2
writeMicroseconds KEYWORD2
readMicroseconds KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################

9
libraries/Servo/library.properties Normal file
View File

@ -0,0 +1,9 @@
name=Servo
version=1.0.2
author=Michael C. Miller
maintainer=GitHub/esp8266/arduino
sentence=Allows Esp8266 boards to control a variety of servo motors.
paragraph=This library can control a great number of servos.<br />It makes careful use of timers: the library can control 12 servos using only 1 timer.<br />
category=Device Control
url=http://arduino.cc/en/Reference/Servo
architectures=esp8266

93
libraries/Servo/src/Servo.h Normal file
View File

@ -0,0 +1,93 @@
/*
Servo.h - Interrupt driven Servo library for Esp8266 using timers
Copyright (c) 2015 Michael C. Miller. All right reserved.
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.
//
// This library uses time0 and timer1.
// Note that timer0 may be repurposed when the first servo is attached.
//
// Timers are seized as needed in groups of 12 servos - 24 servos use two
// timers, there are only two timers for the esp8266 so the support stops here
// The sequence used to sieze timers is defined in timers.h
//
// The methods are:
//
// Servo - Class for manipulating servo motors connected to Arduino pins.
//
// attach(pin ) - Attaches a servo motor to an i/o pin.
// attach(pin, min, max ) - Attaches to a pin setting min and max values in microseconds
// default min is 544, max is 2400
//
// write() - Sets the servo angle in degrees. (invalid angle that is valid as pulse in microseconds is treated as microseconds)
// writeMicroseconds() - Sets the servo pulse width in microseconds
// read() - Gets the last written servo pulse width as an angle between 0 and 180.
// 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.
#ifndef Servo_h
#define Servo_h
#include <Arduino.h>
// the following are in us (microseconds)
//
#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
// NOTE: to maintain a strict refresh interval the user needs to not exceede 8 servos
#define SERVOS_PER_TIMER 12 // the maximum number of servos controlled by one timer
#define MAX_SERVOS (ServoTimerSequence_COUNT * SERVOS_PER_TIMER)
#if defined(ESP8266)
#include "esp8266/ServoTimers.h"
#else
#error "This library only supports esp8266 boards."
#endif
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
uint16_t _minUs;
uint16_t _maxUs;
};
#endif

249
libraries/Servo/src/esp8266/Servo.cpp Normal file
View File

@ -0,0 +1,249 @@
/*
Copyright (c) 2015 Michael C. Miller. All right reserved.
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
*/
#if defined(ESP8266)
#include <Arduino.h>
#include <Servo.h>
#define INVALID_SERVO 255 // flag indicating an invalid servo index
const uint32_t c_CycleCompensation = 4; // compensation us to trim adjust for digitalWrite delays
struct ServoInfo {
uint8_t pin : 6; // a pin number from 0 to 63
uint8_t isActive : 1; // true if this channel is enabled, pin not pulsed if false
};
struct ServoState {
ServoInfo info;
volatile uint16_t usPulse;
};
#if !defined (SERVO_EXCLUDE_TIMER0)
ServoTimer0 s_servoTimer0;
#endif
#if !defined (SERVO_EXCLUDE_TIMER1)
ServoTimer1 s_servoTimer1;
#endif
static ServoState s_servos[MAX_SERVOS]; // static array of servo structures
static uint8_t s_servoCount = 0; // the total number of attached s_servos
// inconvenience macros
#define SERVO_INDEX_TO_TIMER(servoIndex) ((ServoTimerSequence)(servoIndex / SERVOS_PER_TIMER)) // returns the timer controlling this servo
#define SERVO_INDEX(timerId, channel) ((timerId * SERVOS_PER_TIMER) + channel) // macro to access servo index by timer and channel
//------------------------------------------------------------------------------
// Interrupt handler template method that takes a class that implements
// a standard set of methods for the timer abstraction
//------------------------------------------------------------------------------
template <class T> void Servo_Handler(T* timer)
{
noInterrupts();
uint8_t servoIndex;
// clear interrupt
timer->ResetInterrupt();
if (timer->isEndOfCycle()) {
timer->StartCycle();
}
else {
servoIndex = SERVO_INDEX(timer->timerId(), timer->getCurrentChannel());
if (servoIndex < s_servoCount && s_servos[servoIndex].info.isActive) {
// pulse this channel low if activated
digitalWrite(s_servos[servoIndex].info.pin, LOW);
}
timer->nextChannel();
}
servoIndex = SERVO_INDEX(timer->timerId(), timer->getCurrentChannel());
if (servoIndex < s_servoCount && timer->getCurrentChannel() < SERVOS_PER_TIMER) {
timer->SetPulseCompare(timer->usToTicks(s_servos[servoIndex].usPulse) - c_CycleCompensation);
if (s_servos[servoIndex].info.isActive) { // check if activated
digitalWrite(s_servos[servoIndex].info.pin, HIGH); // its an active channel so pulse it high
}
}
else {
// finished all channels so wait for the refresh period to expire before starting over
// allow a few ticks to ensure the next match is not missed
uint32_t refreshCompare = timer->usToTicks(REFRESH_INTERVAL);
if ((timer->GetCycleCount() + c_CycleCompensation * 2) < refreshCompare) {
timer->SetCycleCompare(refreshCompare - c_CycleCompensation);
}
else {
// at least REFRESH_INTERVAL has elapsed
timer->SetCycleCompare(timer->GetCycleCount() + c_CycleCompensation * 2);
}
timer->setEndOfCycle();
}
interrupts();
}
static void initISR(ServoTimerSequence timerId)
{
#if !defined (SERVO_EXCLUDE_TIMER0)
if (timerId == ServoTimerSequence_Timer0)
s_servoTimer0.InitInterrupt([]() {Servo_Handler<ServoTimer0>(&s_servoTimer0); });
#endif
#if !defined (SERVO_EXCLUDE_TIMER1)
if (timerId == ServoTimerSequence_Timer1)
s_servoTimer1.InitInterrupt([]() {Servo_Handler<ServoTimer1>(&s_servoTimer1); });
#endif
}
static void finISR(ServoTimerSequence timerId)
{
#if !defined (SERVO_EXCLUDE_TIMER0)
if (timerId == ServoTimerSequence_Timer0)
s_servoTimer0.StopInterrupt();
#endif
#if !defined (SERVO_EXCLUDE_TIMER1)
if (timerId == ServoTimerSequence_Timer1)
s_servoTimer1.StopInterrupt();
#endif
}
// returns true if any servo is active on this timer
static boolean isTimerActive(ServoTimerSequence timerId)
{
for (uint8_t channel = 0; channel < SERVOS_PER_TIMER; channel++) {
if (s_servos[SERVO_INDEX(timerId, channel)].info.isActive) {
return true;
}
}
return false;
}
//-------------------------------------------------------------------
// Servo class methods
Servo::Servo()
{
if (s_servoCount < MAX_SERVOS) {
// assign a servo index to this instance
_servoIndex = s_servoCount++;
// store default values
s_servos[_servoIndex].usPulse = DEFAULT_PULSE_WIDTH;
}
else {
_servoIndex = INVALID_SERVO; // too many servos
}
}
uint8_t Servo::attach(int pin)
{
return attach(pin, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
}
uint8_t Servo::attach(int pin, int minUs, int maxUs)
{
ServoTimerSequence timerId;
Serial.print("_servoIndex ");
Serial.println(_servoIndex);
if (_servoIndex < MAX_SERVOS) {
pinMode(pin, OUTPUT); // set servo pin to output
digitalWrite(pin, LOW);
s_servos[_servoIndex].info.pin = pin;
// keep the min and max within 200-3000 us, these are extreme
// ranges and should support extreme servos while maintaining
// reasonable ranges
_maxUs = max(250, min(3000, maxUs));
_minUs = max(200, min(_maxUs, minUs));
// initialize the timerId if it has not already been initialized
timerId = SERVO_INDEX_TO_TIMER(_servoIndex);
if (!isTimerActive(timerId)) {
initISR(timerId);
}
s_servos[_servoIndex].info.isActive = true; // this must be set after the check for isTimerActive
}
return _servoIndex;
}
void Servo::detach()
{
ServoTimerSequence timerId;
s_servos[_servoIndex].info.isActive = false;
timerId = SERVO_INDEX_TO_TIMER(_servoIndex);
if (!isTimerActive(timerId)) {
finISR(timerId);
}
}
void Servo::write(int value)
{
// treat values less than 544 as angles in degrees (valid values in microseconds are handled as microseconds)
if (value < MIN_PULSE_WIDTH) {
// assumed to be 0-180 degrees servo
value = max(0, min(180, value));
value = map(value, 0, 180, _minUs, _maxUs);
}
writeMicroseconds(value);
}
void Servo::writeMicroseconds(int value)
{
// ensure channel is valid
if ((_servoIndex < MAX_SERVOS)) {
// ensure pulse width is valid
value = max(_minUs, min(_maxUs, value));
s_servos[_servoIndex].usPulse = value;
}
}
int Servo::read() // return the value as degrees
{
return map(readMicroseconds(), _minUs, _maxUs, 0, 180);
}
int Servo::readMicroseconds()
{
unsigned int pulsewidth;
if (_servoIndex != INVALID_SERVO) {
pulsewidth = s_servos[_servoIndex].usPulse;
}
else {
pulsewidth = 0;
}
return pulsewidth;
}
bool Servo::attached()
{
return s_servos[_servoIndex].info.isActive;
}
#endif

227
libraries/Servo/src/esp8266/ServoTimers.h Normal file
View File

@ -0,0 +1,227 @@
/*
Copyright (c) 2015 Michael C. Miller. All right reserved.
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
*/
//
// Defines for timer abstractions used with Servo library
//
// ServoTimerSequence enumerates the sequence that the timers should be allocated
// ServoTimerSequence_COUNT indicates how many timers are available.
//
enum ServoTimerSequence {
#if !defined (SERVO_EXCLUDE_TIMER0)
ServoTimerSequence_Timer0,
#endif
#if !defined (SERVO_EXCLUDE_TIMER1)
ServoTimerSequence_Timer1,
#endif
ServoTimerSequence_COUNT
};
#if !defined (SERVO_EXCLUDE_TIMER0)
struct ServoTimer0
{
public:
ServoTimer0()
{
setEndOfCycle();
}
uint32_t usToTicks(uint32_t us) const
{
return (clockCyclesPerMicrosecond() * us); // converts microseconds to tick
}
uint32_t ticksToUs(uint32_t ticks) const
{
return (ticks / clockCyclesPerMicrosecond()); // converts from ticks back to microseconds
}
void InitInterrupt(timercallback handler)
{
timer0_isr_init();
timer0_attachInterrupt(handler);
}
void ResetInterrupt() {}; // timer0 doesn't have a clear interrupt
void StopInterrupt()
{
timer0_detachInterrupt();
}
void SetPulseCompare(uint32_t value)
{
timer0_write(ESP.getCycleCount() + value);
}
void SetCycleCompare(uint32_t value)
{
timer0_write(_cycleStart + value);
}
uint32_t GetCycleCount() const
{
return ESP.getCycleCount() - _cycleStart;
}
void StartCycle()
{
_cycleStart = ESP.getCycleCount();
_currentChannel = 0;
}
int8_t getCurrentChannel() const
{
return _currentChannel;
}
void nextChannel()
{
_currentChannel++;
}
void setEndOfCycle()
{
_currentChannel = -1;
}
bool isEndOfCycle() const
{
return (_currentChannel == -1);
}
ServoTimerSequence timerId() const
{
return ServoTimerSequence_Timer0;
}
private:
volatile uint32_t _cycleStart;
volatile int8_t _currentChannel;
};
#endif
#if !defined (SERVO_EXCLUDE_TIMER1)
struct ServoTimer1
{
public:
ServoTimer1()
{
setEndOfCycle();
}
uint32_t usToTicks(uint32_t us) const
{
return (clockCyclesPerMicrosecond() / 16 * us); // converts microseconds to tick
}
uint32_t ticksToUs(uint32_t ticks) const
{
return (ticks / clockCyclesPerMicrosecond() * 16); // converts from ticks back to microseconds
}
void InitInterrupt(timercallback handler)
{
timer1_isr_init();
timer1_attachInterrupt(handler);
timer1_enable(TIM_DIV16, TIM_EDGE, TIM_SINGLE);
timer1_write(usToTicks(REFRESH_INTERVAL));
}
void ResetInterrupt() {}; // timer1 doesn't have a clear interrupt
void StopInterrupt()
{
timer1_detachInterrupt();
}
void SetPulseCompare(uint32_t value)
{
_cycleTicks += value;
timer1_write(value);
}
void SetCycleCompare(uint32_t value)
{
if (value <= _cycleTicks)
{
value = 1;
}
else
{
value -= _cycleTicks;
}
timer1_write(value);
}
uint32_t GetCycleCount() const
{
return _cycleTicks;
}
void StartCycle()
{
_cycleTicks = 0;
_currentChannel = 0;
}
int8_t getCurrentChannel() const
{
return _currentChannel;
}
void nextChannel()
{
_currentChannel++;
}
void setEndOfCycle()
{
_currentChannel = -1;
}
bool isEndOfCycle() const
{
return (_currentChannel == -1);
}
ServoTimerSequence timerId() const
{
return ServoTimerSequence_Timer1;
}
private:
volatile uint32_t _cycleTicks;
volatile int8_t _currentChannel;
};
#endif