Remove digitalIOPerformance library as it is no longer used
This commit is contained in:
Josh Stewart
parent
746753a4da
commit
48c5350d63
|
|
@ -1,193 +0,0 @@
|
|||
# digitalIOPerformance.h
|
||||
|
||||
digitalIOPerformance.h is a single-file Arduino library (header file)
|
||||
that adds higher-performance digital I/O functions to Arduino
|
||||
programs.
|
||||
|
||||
# Quick Start
|
||||
|
||||
* Copy the "digitalIOPerformance" directory to your [Arduino libraries folder](http://arduino.cc/en/Guide/Libraries).
|
||||
|
||||
* Add _#include "digitalIOPerformance.h"_ near the top of your sketch.
|
||||
|
||||
* Done! When you recompile, performance of digitalRead/digitalWrite &
|
||||
pinMode should be substantially faster in most cases. However,
|
||||
functionality should be otherwise identical to the original Arduino
|
||||
functions.
|
||||
|
||||
* Your sketch's compiled size may also go down (depending on how much
|
||||
digital I/O you do.)
|
||||
|
||||
## What Becomes Faster?
|
||||
|
||||
Any digital I/O when the pin number is known at compile time:
|
||||
|
||||
const int led_pin = 13;
|
||||
digitalWrite(led_pin, HIGH); // <-- gets ~30x faster
|
||||
|
||||
#define RELAY_PIN 11
|
||||
digitalWrite(RELAY_PIN, x>2); // <-- also ~30x faster
|
||||
|
||||
Not the case where the pin number isn't known at compile time:
|
||||
|
||||
int my_pin = 4; // <-- note this is a variable, no 'const' marker!
|
||||
|
||||
void loop() {
|
||||
digitalWrite(my_pin, LOW); // <-- same speed as normal Arduino
|
||||
}
|
||||
|
||||
## Option: More performance, smaller compiled size, on PWM Enabled pins
|
||||
|
||||
The Arduino's digital I/O functions deal with the
|
||||
possibility that a pin is used for PWM output with
|
||||
[analogWrite()](http://arduino.cc/en/Tutorial/PWM), and then the same
|
||||
pin gets used again later for normal digital output with
|
||||
digitalWrite(). Something like this:
|
||||
|
||||
analogWrite(MY_PIN, 120);
|
||||
// ... do some stuff
|
||||
digitalWrite(MY_PIN, LOW);
|
||||
|
||||
If you never mix analogWrite and digitalRead/Write on the same pin, you can
|
||||
boost performance on PWM-enabled pins (making them equal with
|
||||
non-PWM-enabled pins) by adding a second line above the first:
|
||||
|
||||
#define DIGITALIO_NO_MIX_ANALOGWRITE
|
||||
#include "digitalIOPerformance.h
|
||||
|
||||
Digital read & write performance will be higher, and the compiled
|
||||
sketch size will be smaller.
|
||||
|
||||
... if you still want to mix analogWrite() and
|
||||
digitalRead/digitalWrite() on the same pin, but also use
|
||||
DIGITALIO_NO_MIX_ANALOGWRITE, then you can use the noAnalogWrite()
|
||||
function in between to turn off the PWM output:
|
||||
|
||||
analogWrite(MY_PIN, 120);
|
||||
// ... do some stuff
|
||||
noAnalogWrite(MY_PIN);
|
||||
digitalWrite(MY_PIN, LOW);
|
||||
|
||||
## Option: Last shreds of performance
|
||||
|
||||
Under some circumstances the Arduino digital functions have to protect
|
||||
against [interrupts](http://www.uchobby.com/index.php/2007/11/24/arduino-interrupts/) occuring while an I/O read or write is in progress. This can cause things to get out of sync if an I/O operation takes more than a single instruction to process ("interrupt unsafe".)
|
||||
|
||||
When using digitalIOPerformance, most writes only take one instruction anyway, so they are naturally "interrupt safe". However some cases have to be made "interrupt safe":
|
||||
|
||||
* Writing to certain pins on Arduino Mega models.
|
||||
|
||||
* Setting pinMode() to INPUT_PULLUP.
|
||||
|
||||
By default, "digitalIOPerformance" makes these cases interrupt safe,
|
||||
in order to keep them as safe as the built-in Arduino
|
||||
versions. However if your Arduino sketch doesn't use interrupts, or
|
||||
you don't care about interrupt safety for digital I/O, then you can
|
||||
add another line to get faster digital I/O on them:
|
||||
|
||||
#define DIGITALIO_NO_INTERRUPT_SAFETY
|
||||
#include "digitalIOPerformance.h
|
||||
|
||||
Only do this one if you're very sure you don't need interrupt safe
|
||||
digital reads & writes. If you're already using
|
||||
DIGITALIO_NO_MIX_ANALOGWRITE then the only real improvement is on an
|
||||
Arduino Mega, and even then only on some of the pins.
|
||||
|
||||
## Option: Disable automatic performance boost
|
||||
|
||||
If you don't want the library to automatically replace your
|
||||
digitalRead/digitalWrite/pinMode function calls, you can do that as
|
||||
well:
|
||||
|
||||
#define DIGITALIO_MANUAL
|
||||
#include "digitalIOPerformance.h
|
||||
|
||||
You can still use the functions in the library if you call them by
|
||||
their original names (given below.)
|
||||
|
||||
# Functions Defined
|
||||
|
||||
These functions are defined by the library:
|
||||
|
||||
## digitalWriteSafe / digitalReadSafe / pinModeSafe
|
||||
|
||||
These versions of digitalWrite/digitalRead & pinMode run faster
|
||||
than the built-in Arduino versions, if the pin number is known at
|
||||
compile time.
|
||||
|
||||
They are also just as safe as the built-in Arduino versions - they're
|
||||
interrupt safe, and they disable any previous analogWrite() calls.
|
||||
|
||||
When you include the library, these functions automatically replace
|
||||
the built-in digitalWrite & pinMode functions. If you don't want this
|
||||
to happen, define DIGITALIO_MANUAL before including (as shown above.)
|
||||
|
||||
|
||||
## digitalWriteFast / digitalReadFast / pinModeFast
|
||||
|
||||
These versions of digitalWrite/digitalRead & pinMode will usually
|
||||
compile down to a single port register instruction (as fast as is
|
||||
possible to be) if the pin number is known at compile time. If the pin
|
||||
number is a variable then they fall through to the slower Arduino
|
||||
version if the pin number is a variable.
|
||||
|
||||
You can have these functions automatically replace all Arduino
|
||||
digitalWrite/digitalRead & pinMode functions if you include the
|
||||
library thus:
|
||||
|
||||
#define DIGITALIO_NO_INTERRUPT_SAFETY
|
||||
#define DIGITALIO_NO_MIX_ANALOGWRITE
|
||||
#include "digitalIOPerformance.h
|
||||
|
||||
## noAnalogWrite
|
||||
|
||||
Using digitalWriteFast() will not automatically turn off a
|
||||
previous analogWrite() to that port, unlike Arduino's digitalWrite().
|
||||
|
||||
If you are mixing analogWrite() and digitalWriteFast() on a port, call
|
||||
this function after immediately before calling digitalWriteFast(), if
|
||||
you had previously called analogWrite().
|
||||
|
||||
The "safe" methods already call noAnalogWrite() any time you access a
|
||||
PWM-capable pin, unless you've defined DIGITALIO_NO_MIX_ANALOGWRITE.
|
||||
|
||||
|
||||
# Status
|
||||
|
||||
New, untested, hacky, work in progress. :)
|
||||
|
||||
Please raise an issue if this doesn't work with your Arduino install,
|
||||
or doesn't seem to inline properly (ie massively bloated code size
|
||||
instead of shrinking code size!)
|
||||
|
||||
Minimal testing done with Windows Arduino 1.0.3 (gcc 4.3) and my
|
||||
Ubuntu Arduino 1.0.3 (gcc 4.7.) Should work with any Arduino version
|
||||
above 1.0 (I think.)
|
||||
|
||||
# Known Shortcomings
|
||||
|
||||
* No ARM support, does nothing at all on the Arduino Due.
|
||||
|
||||
# Internal Workings
|
||||
|
||||
digitalIOPerformance.h is code generated automatically from an
|
||||
existing Arduino installation by the script generateDigitalIOHeader.py.
|
||||
|
||||
You shouldn't need to run the code generation script unless you have a
|
||||
newer/different Arduino version than the one it was last run against.
|
||||
|
||||
However, having code generation means it should be simple to update
|
||||
against future new boards like the Leonardo (assuming the file
|
||||
formats don't change much.)
|
||||
|
||||
# Thanks
|
||||
|
||||
Big thanks to the authors of digitalWriteFast - Paul Stoffregen, Bill
|
||||
Westfield, an John Raines. I wrote this instead of updating
|
||||
digitalWriteFast.h to support the Leonardo (code generation was more
|
||||
appealing than handwritten bit fiddles!)
|
||||
|
||||
Also thanks to Alastair D'Silva who told me a while ago about the
|
||||
trick of preprocessing pins_arduino.h to extract Arduino pin
|
||||
information, he uses this in the performance-oriented AVR library
|
||||
[MHVLib](http://www.makehackvoid.com/project/MHVLib).
|
||||
|
|
@ -1,70 +0,0 @@
|
|||
/* Arduino board:
|
||||
* %(id)s
|
||||
* %(name)s
|
||||
* MCU: %(build.mcu)s
|
||||
*/
|
||||
#if %(ifdef_clause)s
|
||||
#ifdef _DIGITALIO_MATCHED_BOARD
|
||||
#error "This header's Arduino configuration heuristics have matched multiple boards. The header may be out of date."
|
||||
#endif
|
||||
#define _DIGITALIO_MATCHED_BOARD
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline void pinModeFast(uint8_t pin, uint8_t mode) {
|
||||
if(!__builtin_constant_p(pin)) {
|
||||
pinMode(pin, mode);
|
||||
}
|
||||
%(pinmode_clause)s
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline void digitalWriteFast(uint8_t pin, uint8_t value) {
|
||||
if(!__builtin_constant_p(pin)) {
|
||||
digitalWrite(pin, value);
|
||||
}
|
||||
%(digitalwrite_clause)s
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline int digitalReadFast(uint8_t pin) {
|
||||
if(!__builtin_constant_p(pin)) {
|
||||
return digitalRead(pin);
|
||||
}
|
||||
%(digitalread_clause)s
|
||||
return LOW;
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline void noAnalogWrite(uint8_t pin) {
|
||||
if(!__builtin_constant_p(pin)) {
|
||||
return; // noAnalogWrite is taken care of by digitalWrite() for variables
|
||||
}
|
||||
%(timer_clause)s
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline bool _isPWMPin(uint8_t pin) {
|
||||
%(ispwm_clause)s
|
||||
return false;
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline bool _directionIsAtomic(uint8_t pin) {
|
||||
%(direction_clause)s
|
||||
return false;
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline bool _outputIsAtomic(uint8_t pin) {
|
||||
%(output_clause)s
|
||||
return false;
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline bool _inputIsAtomic(uint8_t pin) {
|
||||
%(input_clause)s
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
#ifndef _DIGITALIO_MATCHED_BOARD
|
||||
#error "This header's Arduino configuration heuristics couldn't match this board configuration. No fast I/O is available. The header may be out of date."
|
||||
#endif
|
||||
#undef _DIGITALIO_MATCHED_BOARD
|
||||
|
||||
#ifndef DIGITALIO_MANUAL
|
||||
#define digitalWrite digitalWriteSafe
|
||||
#define digitalRead digitalReadSafe
|
||||
#define pinMode pinModeSafe
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
@ -1,116 +0,0 @@
|
|||
/*
|
||||
*
|
||||
* Header for high performance Arduino Digital I/O
|
||||
*
|
||||
* Automatically generated from the Arduino library setup (boards.txt & pins_arduino.h)
|
||||
*
|
||||
* See the accompanying file README.md for documentation.
|
||||
*
|
||||
* ****
|
||||
*
|
||||
* This header is a derived work of the Arduino microcontroller libraries, which are
|
||||
* licensed under LGPL. Although as a header file it is not bound by the same usage
|
||||
* clauses as the library itself (see "3. Object Code Incorporating Material from
|
||||
* Library Header Files.)"
|
||||
*
|
||||
* Note that although the code generated functions below here look horrific,
|
||||
* they're written to inline only very small subsets of themselves at compile
|
||||
* time (they generate single port-register instructions when the parameters
|
||||
* are constant.)
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#ifdef __AVR__
|
||||
#ifndef _DIGITALIO_PERFORMANCE
|
||||
#define _DIGITALIO_PERFORMANCE
|
||||
|
||||
#include "Arduino.h"
|
||||
#include <util/atomic.h>
|
||||
|
||||
// Forward declarations for per-Arduino-board functions:
|
||||
inline static void pinModeFast(uint8_t pin, uint8_t mode);
|
||||
inline static void digitalWriteFast(uint8_t pin, uint8_t value);
|
||||
inline static int digitalReadFast(uint8_t pin);
|
||||
inline static void noAnalogWrite(uint8_t pin);
|
||||
|
||||
// These few per-board functions are designed for internal use, but
|
||||
// you can call them yourself if you want.
|
||||
inline static bool _isPWMPin(uint8_t pin);
|
||||
inline static bool _directionIsAtomic(uint8_t pin);
|
||||
inline static bool _outputIsAtomic(uint8_t pin);
|
||||
inline static bool _inputIsAtomic(uint8_t pin);
|
||||
|
||||
#ifdef DIGITALIO_NO_INTERRUPT_SAFETY
|
||||
#define DIGITALIO_NO_INTERRUPT_SAFETY 1
|
||||
#else
|
||||
#define DIGITALIO_NO_INTERRUPT_SAFETY 0
|
||||
#endif
|
||||
|
||||
#ifdef DIGITALIO_NO_MIX_ANALOGWRITE
|
||||
#define DIGITALIO_NO_MIX_ANALOGWRITE 1
|
||||
#else
|
||||
#define DIGITALIO_NO_MIX_ANALOGWRITE 0
|
||||
#endif
|
||||
|
||||
// All the variables & conditionals in these functions should evaluate at
|
||||
// compile time not run time...
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline void pinModeSafe(uint8_t pin, uint8_t mode) {
|
||||
if(!__builtin_constant_p(pin)) {
|
||||
pinMode(pin, mode);
|
||||
}
|
||||
else {
|
||||
if((mode == INPUT || mode == INPUT_PULLUP) && !DIGITALIO_NO_MIX_ANALOGWRITE)
|
||||
noAnalogWrite(pin);
|
||||
|
||||
const bool write_is_atomic = DIGITALIO_NO_INTERRUPT_SAFETY
|
||||
|| (__builtin_constant_p(mode)
|
||||
&& mode == OUTPUT
|
||||
&& _directionIsAtomic(pin));
|
||||
if(write_is_atomic) {
|
||||
pinModeFast(pin, mode);
|
||||
}
|
||||
else {
|
||||
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
|
||||
{
|
||||
pinModeFast(pin, mode);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline void digitalWriteSafe(uint8_t pin, uint8_t value) {
|
||||
if(!__builtin_constant_p(pin)) {
|
||||
digitalWrite(pin, value);
|
||||
}
|
||||
else {
|
||||
if(!DIGITALIO_NO_MIX_ANALOGWRITE)
|
||||
noAnalogWrite(pin);
|
||||
|
||||
if(DIGITALIO_NO_INTERRUPT_SAFETY || _outputIsAtomic(pin)) {
|
||||
digitalWriteFast(pin, value);
|
||||
}
|
||||
else {
|
||||
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
|
||||
{
|
||||
digitalWriteFast(pin, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
static inline int digitalReadSafe(uint8_t pin) {
|
||||
if(!__builtin_constant_p(pin)) {
|
||||
return digitalRead(pin);
|
||||
}
|
||||
else {
|
||||
if(!DIGITALIO_NO_MIX_ANALOGWRITE)
|
||||
noAnalogWrite(pin);
|
||||
return digitalReadFast(pin);
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,309 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
"""
|
||||
Code generation script to build digitalIOPerformance.h from the Arduino
|
||||
boards.txt & pins_arduino.h files.
|
||||
|
||||
You shouldn't need to rerun this unless you have a new version of
|
||||
Arduino installed, or you're using different boards to the default
|
||||
installation.
|
||||
|
||||
See the README file for more details.
|
||||
|
||||
Copyright (c) 2013 Angus Gratton. Script licensed under the GNU Lesser
|
||||
General Public License, version 2 or above.
|
||||
|
||||
"""
|
||||
|
||||
# TODO: command line options
|
||||
ARDUINO_PATH="/Applications/Arduino.app/Contents/Resources/Java/"
|
||||
|
||||
import os, re, subprocess
|
||||
|
||||
def main():
|
||||
boards = extract_boards()
|
||||
for board in boards:
|
||||
add_variant_macros(board)
|
||||
find_unambiguous_macros(boards)
|
||||
identifying_keys = find_unique_macro_keys(boards)
|
||||
boards = merge_matching_boards(boards, identifying_keys)
|
||||
for board in boards:
|
||||
extract_portnames_pins(board)
|
||||
with open("digitalIOPerformance.h", "w") as output:
|
||||
generate_header_file(boards, identifying_keys, output)
|
||||
|
||||
def extract_boards():
|
||||
""" Parse the Arduino boards file and return a list of all the boards,
|
||||
with each board as a dictionary containing all their board-specific
|
||||
key-value pairs
|
||||
"""
|
||||
with open(os.path.join(ARDUINO_PATH, "hardware/arduino/boards.txt")) as board_contents:
|
||||
boards = dict()
|
||||
|
||||
RE_BOARDENTRY = re.compile(r"^([A-Za-z][^=]+)=(.+)$", re.MULTILINE)
|
||||
|
||||
for full_key,value in re.findall(RE_BOARDENTRY, board_contents.read()):
|
||||
board = full_key.split(".")[0]
|
||||
key = ".".join(full_key.split(".")[1:])
|
||||
if not board in boards:
|
||||
boards[board] = { "id" : board }
|
||||
boards[board][key] = value
|
||||
|
||||
return list(boards.values())
|
||||
|
||||
def run_preprocessor(board, additional_args=[]):
|
||||
"""
|
||||
Run the C preprocessor over a particular board, and return
|
||||
the contents of the processed file as a string
|
||||
"""
|
||||
source_path = board["pin_path"]
|
||||
args = ["/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/avr-gcc", "-DARDUINO_MAIN", "-E",
|
||||
"-mmcu=%s" % board["build.mcu"],
|
||||
"-DF_CPU=%s" % board["build.f_cpu"] ]
|
||||
if "build.vid" in board:
|
||||
args += [ "-DUSB_VID=%s" % board["build.vid" ] ]
|
||||
if "build.pid" in board:
|
||||
args += [ "-DUSB_PID=%s" % board["build.pid" ] ]
|
||||
print args + additional_args + [ source_path ]
|
||||
proc = subprocess.Popen(args + additional_args + [ source_path ],stdout=subprocess.PIPE)
|
||||
proc.wait()
|
||||
if proc.returncode != 0:
|
||||
raise Error("Failed to run preprocessor")
|
||||
return proc.stdout.read()
|
||||
|
||||
def add_variant_macros(board):
|
||||
"""
|
||||
Run the pin_arduinos.h header for this board through the preprocessor,
|
||||
extract all defined macros and attach them to the board dict under key
|
||||
'macros'
|
||||
"""
|
||||
print os.path.join(ARDUINO_PATH, "hardware/arduino/variants/%s/pins_arduino.h" % (board["build.variant"]))
|
||||
board["pin_path"] = os.path.join(ARDUINO_PATH, "hardware/arduino/variants/%s/pins_arduino.h" % (board["build.variant"]))
|
||||
macros = run_preprocessor(board, ["-dM"])
|
||||
macros = [ re.sub(r"^#define ", "", macro) for macro in macros.split("\n") ]
|
||||
macros = [ tuple(macro.split(" ", 1)) for macro in macros if " " in macro ]
|
||||
board["macros"] = dict(macros)
|
||||
|
||||
def find_unambiguous_macros(boards):
|
||||
"""
|
||||
Trim the macros defined against any of the boards, to leave only those with
|
||||
only numeric values (anything else is too tricky, especially with
|
||||
token representation ambiguities.)
|
||||
|
||||
Modifies the board dict in-place.
|
||||
"""
|
||||
ambiguous_macros = set()
|
||||
# build list of ambiguous macros
|
||||
for board in boards:
|
||||
for key,value in board["macros"].items():
|
||||
if not re.match(r"^-?0?x?[\dA-Fa-f]+L?$", value.strip()):
|
||||
ambiguous_macros.add(key)
|
||||
# trim the ambiguous macros from any of the boards
|
||||
for board in boards:
|
||||
for ambiguous in ambiguous_macros:
|
||||
if ambiguous in board["macros"]:
|
||||
del board["macros"][ambiguous]
|
||||
|
||||
|
||||
def find_unique_macro_keys(boards):
|
||||
"""
|
||||
Go through each board and find a small subset of unique macro
|
||||
values that distinguish each board from the others.
|
||||
|
||||
This allows us to generate a header file that can automatically
|
||||
determine which board profile it's being compiled against, at compile
|
||||
time.
|
||||
|
||||
Returns a set of macro names.
|
||||
"""
|
||||
identifying_keys = set()
|
||||
for board in boards:
|
||||
duplicates = list( dup for dup in boards if dup != board )
|
||||
for dup in duplicates:
|
||||
# skip anything that's already unique as per existing keys
|
||||
identified = False
|
||||
for key in identifying_keys:
|
||||
identified = identified or board["macros"].get(key,"") != dup["macros"].get(key, "")
|
||||
if identified:
|
||||
continue
|
||||
|
||||
# find something unique about this duplicate
|
||||
uniques = set(board["macros"].items()) ^ set(dup["macros"].items())
|
||||
uniques = [ key for key,value in uniques ]
|
||||
# find the least selective key in the uniques
|
||||
def selectiveness(key):
|
||||
return len([d for d in duplicates if ( d["macros"].get(key, "") == board["macros"].get(key, ""))])
|
||||
uniques = sorted(uniques, key=selectiveness)
|
||||
if len(uniques) > 0:
|
||||
identifying_keys.add(uniques[0])
|
||||
|
||||
return identifying_keys
|
||||
|
||||
def merge_matching_boards(boards, identifying_keys):
|
||||
"""
|
||||
Go through each board and merge together any that we can't unambiguously
|
||||
identify by using the macros defined in identifying_keys.
|
||||
|
||||
We assume any matching boards will have matching 'variants' defined, otherwise
|
||||
we throw an error.
|
||||
|
||||
Returns a new list of boards, with an ambiguously defined ones merged together.
|
||||
"""
|
||||
def key(board):
|
||||
return str([ board["macros"].get(key,"") for key in identifying_keys ])
|
||||
|
||||
# Merge together any boards with identical keys (making composite names & ids)
|
||||
unique_boards = []
|
||||
for board in boards:
|
||||
found = False
|
||||
for unique in unique_boards:
|
||||
if key(unique) == key(board):
|
||||
if board["build.variant"] != unique["build.variant"]:
|
||||
raise RuntimeError("Ambiguous boards %s / %s have matching variant! Can't distinguish reliably between them." % (board["id"], unique["id"]))
|
||||
unique["id"] += " | " + board["id"]
|
||||
unique["name"] += " | " + board["name"]
|
||||
found = True
|
||||
if not found:
|
||||
unique_boards += [ board ]
|
||||
return unique_boards
|
||||
|
||||
|
||||
def extract_portnames_pins(board):
|
||||
"""
|
||||
Run the preprocessor over this boards' pin header file to pull
|
||||
out port names and bitmasks.
|
||||
"""
|
||||
def extract_array(array_name):
|
||||
""" Match a multiline C array with the given name (pretty clumsy.) """
|
||||
content = re.search(array_name + ".+?\{(.+?)}", output, re.MULTILINE|re.DOTALL).group(1)
|
||||
return [ e.strip() for e in content.split(",") if len(e.strip()) ]
|
||||
|
||||
output = run_preprocessor(board)
|
||||
board["ports"] = extract_array("digital_pin_to_port_PGM")
|
||||
# strip P prefix, ie PD becomes D
|
||||
board["ports"] = [ e[1] if e[0] == "P" else None for e in board["ports"] ]
|
||||
|
||||
board["bitmasks"] = extract_array("digital_pin_to_bit_mask_PGM")
|
||||
|
||||
pin_to_timer = extract_array("digital_pin_to_timer_PGM")
|
||||
board["timers"] = [ p if p != "NOT_ON_TIMER" else None for p in pin_to_timer ]
|
||||
|
||||
# do some sanity checks on the data we extracted
|
||||
if len(board["ports"]) != len(board["bitmasks"]):
|
||||
raise RuntimeError("Number of ports in %s doesn't match bitmask count - %d vs %d" % (board["id"], len(board["ports"]), len(board["bitmasks"])))
|
||||
if len(board["ports"]) != int(board["macros"]["NUM_DIGITAL_PINS"]):
|
||||
raise RuntimeError("Number of ports in %s doesn't match number of digital pins reported in header" % (board["id"], len(board["ports"]), board["macros"]["NUM_DIGITAL_PINS"]))
|
||||
|
||||
DIGITALWRITE_TEMPLATE = """
|
||||
else if(pin == %(number)s && value) PORT%(port)s |= %(bitmask)s;
|
||||
else if(pin == %(number)s && !value) PORT%(port)s &= ~%(bitmask)s;
|
||||
""".lstrip("\n")
|
||||
|
||||
PINMODE_TEMPLATE = """
|
||||
else if(pin == %(number)s && mode == INPUT) {
|
||||
DDR%(port)s &= ~%(bitmask)s;
|
||||
PORT%(port)s &= ~%(bitmask)s;
|
||||
} else if(pin == %(number)s && mode == INPUT_PULLUP) {
|
||||
DDR%(port)s &= ~%(bitmask)s;
|
||||
PORT%(port)s |= %(bitmask)s;
|
||||
} else if(pin == %(number)s) DDR%(port)s |= %(bitmask)s;
|
||||
""".lstrip("\n")
|
||||
|
||||
DIGITALREAD_TEMPLATE = """
|
||||
else if(pin == %(number)s) return PIN%(port)s & %(bitmask)s ? HIGH : LOW;
|
||||
""".lstrip("\n")
|
||||
|
||||
TIMER_TEMPLATE = """
|
||||
else if(pin == %(number)s) %(timer_reg)s &= ~_BV(%(timer_bit)s);
|
||||
""".lstrip("\n")
|
||||
|
||||
ISPWM_TEMPLATE = """
|
||||
if(pin == %(number)s)
|
||||
return true;
|
||||
""".lstrip("\n")
|
||||
|
||||
PORT_TEST_TEMPLATE = """
|
||||
if(pin == %(number)s)
|
||||
return _SFR_IO_REG_P(%(port)s);
|
||||
""".lstrip("\n")
|
||||
|
||||
# Lookup table from the timer specifications given in pins_arduino.h
|
||||
# to the actual timer register bits
|
||||
#
|
||||
# This is equivalent of the case statement in wiring_digital.c, so if that
|
||||
# ever changes this needs to change too. :(
|
||||
TIMER_LOOKUP = {
|
||||
"TIMER1A": ("TCCR1A", "COM1A1"),
|
||||
"TIMER1B": ("TCCR1A", "COM1B1"),
|
||||
"TIMER2": ("TCCR2", "COM21"),
|
||||
"TIMER0A": ("TCCR0A", "COM0A1"),
|
||||
"TIMER0B": ("TCCR0A", "COM0B1"),
|
||||
"TIMER2A": ("TCCR2A", "COM2A1"),
|
||||
"TIMER2B": ("TCCR2A", "COM2B1"),
|
||||
"TIMER3A": ("TCCR3A", "COM3A1"),
|
||||
"TIMER3B": ("TCCR3A", "COM3B1"),
|
||||
"TIMER3C": ("TCCR3A", "COM3C1"),
|
||||
"TIMER4A": ("TCCR4A", "COM4A1"),
|
||||
"TIMER4B": ("TCCR4A", "COM4B1"),
|
||||
"TIMER4C": ("TCCR4A", "COM4C1"),
|
||||
"TIMER4D": ("TCCR4C", "COM4D1"),
|
||||
"TIMER5A": ("TCCR5A", "COM5A1"),
|
||||
"TIMER5B": ("TCCR5A", "COM5B1"),
|
||||
"TIMER5C": ("TCCR5A", "COM5C1"),
|
||||
}
|
||||
|
||||
def generate_header_file(boards, identifying_keys, output):
|
||||
"""
|
||||
Write a header file with fast inlined methods for all the board types
|
||||
"""
|
||||
with open("components/board_template.cpp") as template:
|
||||
BOARD_TEMPLATE = template.read()
|
||||
with open("components/header.cpp") as header:
|
||||
output.write(header.read())
|
||||
for board in boards:
|
||||
# Work out the macro conditional
|
||||
ifdef_clause = []
|
||||
for key in identifying_keys:
|
||||
# all the +0 nonsense here is to detect defined-but-empty macros
|
||||
# (Arduino-mk inserts them)
|
||||
if key in board["macros"]:
|
||||
ifdef_clause.append("defined(%(key)s) && (%(key)s+0) == %(value)s" %
|
||||
{"key": key, "value": board["macros"][key]})
|
||||
else:
|
||||
ifdef_clause.append("(!defined(%s) || !(%s+0))" % (key,key))
|
||||
ifdef_clause = " && ".join(ifdef_clause)
|
||||
|
||||
# Build up the macro conditionals
|
||||
digitalwrite_clause = ""
|
||||
digitalread_clause = ""
|
||||
pinmode_clause = ""
|
||||
timer_clause = ""
|
||||
ispwm_clause = ""
|
||||
direction_clause = ""
|
||||
output_clause = ""
|
||||
input_clause = ""
|
||||
for number,port,bitmask,timer in zip(range(len(board["ports"])),
|
||||
board["ports"],
|
||||
board["bitmasks"],
|
||||
board["timers"]):
|
||||
if port is not None:
|
||||
digitalwrite_clause += DIGITALWRITE_TEMPLATE % locals()
|
||||
digitalread_clause += DIGITALREAD_TEMPLATE % locals()
|
||||
pinmode_clause += PINMODE_TEMPLATE % locals()
|
||||
if timer is not None:
|
||||
timer_reg,timer_bit = TIMER_LOOKUP[timer]
|
||||
timer_clause += TIMER_TEMPLATE % locals()
|
||||
ispwm_clause += ISPWM_TEMPLATE % locals()
|
||||
direction_clause += PORT_TEST_TEMPLATE % {"number":number,
|
||||
"port":"DDR"+port}
|
||||
output_clause += PORT_TEST_TEMPLATE % {"number":number,
|
||||
"port":"PORT"+port}
|
||||
input_clause += PORT_TEST_TEMPLATE % {"number":number,
|
||||
"port":"PIN"+port}
|
||||
|
||||
output.write(BOARD_TEMPLATE % dict(locals(), **board))
|
||||
with open("components/footer.cpp") as footer:
|
||||
output.write(footer.read())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Loading…
Reference in New Issue