Merge pull request #755 from dhylands/teensy-core

Add teensy core files and use same toolchain as stmhal

teensy/Makefile

@@ -6,14 +6,7 @@ QSTR_DEFS = qstrdefsport.h
 # include py core make definitions
 include ../py/py.mk
 
-ifeq ($(ARDUINO),)
-$(error Please define ARDUINO (where TeensyDuino is installed))
-endif
-TOOLS_PATH = $(ARDUINO)/hardware/tools
-COMPILER_PATH = $(TOOLS_PATH)/arm-none-eabi/bin
-CORE_PATH = $(ARDUINO)/hardware/teensy/cores/teensy3
-
-CROSS_COMPILE = $(COMPILER_PATH)/arm-none-eabi-
+CROSS_COMPILE = arm-none-eabi-
 
 CFLAGS_TEENSY = -DF_CPU=96000000 -DUSB_SERIAL -D__MK20DX256__
 CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -mcpu=cortex-m4 -fsingle-precision-constant -Wdouble-promotion $(CFLAGS_TEENSY)
@@ -22,13 +15,26 @@ INC =  -I.
 INC += -I$(PY_SRC)
 INC += -I../stmhal
 INC += -I$(BUILD)
-INC += -I$(CORE_PATH)
+INC += -Icore
 
 CFLAGS = $(INC) -Wall -ansi -std=gnu99 -nostdlib $(CFLAGS_CORTEX_M4)
 LDFLAGS = -nostdlib -T mk20dx256.ld
-LIBS  = -L $(COMPILER_PATH)/../arm-none-eabi/lib/thumb2 -lm
-LIBS += -L $(COMPILER_PATH)/../arm-none-eabi/lib/thumb2 -lc
-LIBS += -L $(COMPILER_PATH)/../lib/gcc/arm-none-eabi/4.7.2/thumb2 -lgcc
+
+LIBGCC_FILE_NAME = $(shell $(CC) -print-libgcc-file-name)
+LIBM_FILE_NAME   = $(shell $(CC) -print-file-name=libm.a)
+LIBC_FILE_NAME   = $(shell $(CC) -print-file-name=libc.a)
+
+#$(info %%%%% LIBGCC_FILE_NAME = $(LIBGCC_FILE_NAME))
+#$(info %%%%% LIBM_FILE_NAME = $(LIBM_FILE_NAME))
+#$(info %%%%% LIBC_FILE_NAME = $(LIBC_FILE_NAME))
+
+#$(info %%%%% dirname LIBGCC_FILE_NAME = $(dir $(LIBGCC_FILE_NAME)))
+#$(info %%%%% dirname LIBM_FILE_NAME = $(dir $(LIBM_FILE_NAME)))
+#$(info %%%%% dirname LIBC_FILE_NAME = $(dir $(LIBC_FILE_NAME)))
+
+LIBS  = -L $(dir $(LIBM_FILE_NAME)) -lm
+LIBS += -L $(dir $(LIBC_FILE_NAME)) -lc
+LIBS += -L $(dir $(LIBGCC_FILE_NAME)) -lgcc
 
 #Debugging/Optimization
 ifdef DEBUG
@@ -67,7 +73,7 @@ STM_SRC_S = $(addprefix stmhal/,\
 	gchelper.s \
 	)
 
-SRC_TEENSY = \
+SRC_TEENSY = $(addprefix core/,\
 	mk20dx128.c \
 	pins_teensy.c \
 	analog.c \
@@ -76,6 +82,7 @@ SRC_TEENSY = \
 	usb_mem.c \
 	usb_serial.c \
 	yield.c \
+	)
 
 OBJ = $(PY_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o) $(STM_SRC_C:.c=.o) $(STM_SRC_S:.s=.o) $(SRC_TEENSY:.c=.o))
 OBJ += $(BUILD)/pins_gen.o
@@ -83,6 +90,18 @@ OBJ += $(BUILD)/pins_gen.o
 all: hex
 hex: $(BUILD)/micropython-mz.hex
 
+ifeq ($(ARDUINO),)
+post_compile: $(BUILD)/micropython-mz.hex
+	$(ECHO) "Please define ARDUINO (where TeensyDuino is installed)"
+	exit 1
+
+reboot:
+	$(ECHO) "Please define ARDUINO (where TeensyDuino is installed)"
+	exit 1
+
+else
+TOOLS_PATH = $(ARDUINO)/hardware/tools
+
 post_compile: $(BUILD)/micropython-mz.hex
 	$(ECHO) "Preparing $@ for upload"
 	$(Q)$(TOOLS_PATH)/teensy_post_compile -file="$(basename $(<F))" -path="$(<D)" -tools="$(TOOLS_PATH)"
@@ -90,8 +109,10 @@ post_compile: $(BUILD)/micropython-mz.hex
 reboot:
 	$(ECHO) "REBOOT"
 	-$(Q)$(TOOLS_PATH)/teensy_reboot
+endif
 
-upload: post_compile reboot
+.PHONY: deploy
+deploy: post_compile reboot
 
 $(BUILD)/micropython.elf: $(OBJ)
 	$(ECHO) "LINK $@"
@@ -110,9 +131,6 @@ $(BUILD)/%.hex: $(BUILD)/%.elf
 	$(ECHO) "HEX $<"
 	$(Q)$(OBJCOPY) -O ihex -R .eeprom "$<" "$@"
 
-$(BUILD)/%.o: $(CORE_PATH)/%.c
-	$(call compile_c)
-
 MAKE_PINS = make-pins.py
 BOARD_PINS = teensy-pins.csv
 AF_FILE = mk20dx256-af.csv

teensy/core/Arduino.h

+//#include "WProgram.h"
+#include "core_pins.h"
+#include "pins_arduino.h"

teensy/core/HardwareSerial.h

+/* Teensyduino Core Library
+ * http://www.pjrc.com/teensy/
+ * Copyright (c) 2013 PJRC.COM, LLC.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * 1. The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 2. If the Software is incorporated into a build system that allows
+ * selection among a list of target devices, then similar target
+ * devices manufactured by PJRC.COM must be included in the list of
+ * target devices and selectable in the same manner.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef HardwareSerial_h
+#define HardwareSerial_h
+
+#include "mk20dx128.h"
+#include <inttypes.h>
+
+// uncomment to enable 9 bit formats
+//#define SERIAL_9BIT_SUPPORT
+
+
+#define SERIAL_7E1 0x02
+#define SERIAL_7O1 0x03
+#define SERIAL_8N1 0x00
+#define SERIAL_8N2 0x04
+#define SERIAL_8E1 0x06
+#define SERIAL_8O1 0x07
+#define SERIAL_7E1_RXINV 0x12
+#define SERIAL_7O1_RXINV 0x13
+#define SERIAL_8N1_RXINV 0x10
+#define SERIAL_8N2_RXINV 0x14
+#define SERIAL_8E1_RXINV 0x16
+#define SERIAL_8O1_RXINV 0x17
+#define SERIAL_7E1_TXINV 0x22
+#define SERIAL_7O1_TXINV 0x23
+#define SERIAL_8N1_TXINV 0x20
+#define SERIAL_8N2_TXINV 0x24
+#define SERIAL_8E1_TXINV 0x26
+#define SERIAL_8O1_TXINV 0x27
+#define SERIAL_7E1_RXINV_TXINV 0x32
+#define SERIAL_7O1_RXINV_TXINV 0x33
+#define SERIAL_8N1_RXINV_TXINV 0x30
+#define SERIAL_8N2_RXINV_TXINV 0x34
+#define SERIAL_8E1_RXINV_TXINV 0x36
+#define SERIAL_8O1_RXINV_TXINV 0x37
+#ifdef SERIAL_9BIT_SUPPORT
+#define SERIAL_9N1 0x84
+#define SERIAL_9E1 0x8E
+#define SERIAL_9O1 0x8F
+#define SERIAL_9N1_RXINV 0x94
+#define SERIAL_9E1_RXINV 0x9E
+#define SERIAL_9O1_RXINV 0x9F
+#define SERIAL_9N1_TXINV 0xA4
+#define SERIAL_9E1_TXINV 0xAE
+#define SERIAL_9O1_TXINV 0xAF
+#define SERIAL_9N1_RXINV_TXINV 0xB4
+#define SERIAL_9E1_RXINV_TXINV 0xBE
+#define SERIAL_9O1_RXINV_TXINV 0xBF
+#endif
+// bit0: parity, 0=even, 1=odd
+// bit1: parity, 0=disable, 1=enable
+// bit2: mode, 1=9bit, 0=8bit
+// bit3: mode10: 1=10bit, 0=8bit
+// bit4: rxinv, 0=normal, 1=inverted
+// bit5: txinv, 0=normal, 1=inverted
+// bit6: unused
+// bit7: actual data goes into 9th bit
+
+
+#define BAUD2DIV(baud)  (((F_CPU * 2) + ((baud) >> 1)) / (baud))
+#define BAUD2DIV3(baud) (((F_BUS * 2) + ((baud) >> 1)) / (baud))
+
+// C language implementation
+//
+#ifdef __cplusplus
+extern "C" {
+#endif
+void serial_begin(uint32_t divisor);
+void serial_format(uint32_t format);
+void serial_end(void);
+void serial_set_transmit_pin(uint8_t pin);
+void serial_putchar(uint32_t c);
+void serial_write(const void *buf, unsigned int count);
+void serial_flush(void);
+int serial_available(void);
+int serial_getchar(void);
+int serial_peek(void);
+void serial_clear(void);
+void serial_print(const char *p);
+void serial_phex(uint32_t n);
+void serial_phex16(uint32_t n);
+void serial_phex32(uint32_t n);
+
+void serial2_begin(uint32_t divisor);
+void serial2_format(uint32_t format);
+void serial2_end(void);
+void serial2_putchar(uint32_t c);
+void serial2_write(const void *buf, unsigned int count);
+void serial2_flush(void);
+int serial2_available(void);
+int serial2_getchar(void);
+int serial2_peek(void);
+void serial2_clear(void);
+
+void serial3_begin(uint32_t divisor);
+void serial3_format(uint32_t format);
+void serial3_end(void);
+void serial3_putchar(uint32_t c);
+void serial3_write(const void *buf, unsigned int count);
+void serial3_flush(void);
+int serial3_available(void);
+int serial3_getchar(void);
+int serial3_peek(void);
+void serial3_clear(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+// C++ interface
+//
+#ifdef __cplusplus
+#include "Stream.h"
+class HardwareSerial : public Stream
+{
+public:
+	virtual void begin(uint32_t baud) { serial_begin(BAUD2DIV(baud)); }
+	virtual void begin(uint32_t baud, uint32_t format) {
+					  serial_begin(BAUD2DIV(baud));
+					  serial_format(format); }
+	virtual void end(void)		{ serial_end(); }
+	virtual void transmitterEnable(uint8_t pin) { serial_set_transmit_pin(pin); }
+	virtual int available(void)     { return serial_available(); }
+	virtual int peek(void)          { return serial_peek(); }
+	virtual int read(void)          { return serial_getchar(); }
+	virtual void flush(void)        { serial_flush(); }
+	virtual void clear(void)	{ serial_clear(); }
+	virtual size_t write(uint8_t c) { serial_putchar(c); return 1; }
+	virtual size_t write(unsigned long n)   { return write((uint8_t)n); }
+	virtual size_t write(long n)            { return write((uint8_t)n); }
+	virtual size_t write(unsigned int n)    { return write((uint8_t)n); }
+	virtual size_t write(int n)             { return write((uint8_t)n); }
+	virtual size_t write(const uint8_t *buffer, size_t size)
+					{ serial_write(buffer, size); return size; }
+        virtual size_t write(const char *str)	{ size_t len = strlen(str);
+					  serial_write((const uint8_t *)str, len);
+					  return len; }
+	virtual size_t write9bit(uint32_t c)	{ serial_putchar(c); return 1; }
+};
+extern HardwareSerial Serial1;
+
+class HardwareSerial2 : public HardwareSerial
+{
+public:
+	virtual void begin(uint32_t baud) { serial2_begin(BAUD2DIV(baud)); }
+	virtual void begin(uint32_t baud, uint32_t format) {
+					  serial2_begin(BAUD2DIV(baud));
+					  serial2_format(format); }
+	virtual void end(void)		{ serial2_end(); }
+	virtual int available(void)     { return serial2_available(); }
+	virtual int peek(void)          { return serial2_peek(); }
+	virtual int read(void)          { return serial2_getchar(); }
+	virtual void flush(void)        { serial2_flush(); }
+	virtual void clear(void)	{ serial2_clear(); }
+	virtual size_t write(uint8_t c) { serial2_putchar(c); return 1; }
+	virtual size_t write(unsigned long n)   { return write((uint8_t)n); }
+	virtual size_t write(long n)            { return write((uint8_t)n); }
+	virtual size_t write(unsigned int n)    { return write((uint8_t)n); }
+	virtual size_t write(int n)             { return write((uint8_t)n); }
+	virtual size_t write(const uint8_t *buffer, size_t size)
+					{ serial2_write(buffer, size); return size; }
+        virtual size_t write(const char *str)	{ size_t len = strlen(str);
+					  serial2_write((const uint8_t *)str, len);
+					  return len; }
+	virtual size_t write9bit(uint32_t c)	{ serial2_putchar(c); return 1; }
+};
+extern HardwareSerial2 Serial2;
+
+class HardwareSerial3 : public HardwareSerial
+{
+public:
+	virtual void begin(uint32_t baud) { serial3_begin(BAUD2DIV3(baud)); }
+	virtual void begin(uint32_t baud, uint32_t format) {
+					  serial3_begin(BAUD2DIV3(baud));
+					  serial3_format(format); }
+	virtual void end(void)          { serial3_end(); }
+	virtual int available(void)     { return serial3_available(); }
+	virtual int peek(void)          { return serial3_peek(); }
+	virtual int read(void)          { return serial3_getchar(); }
+	virtual void flush(void)        { serial3_flush(); }
+	virtual void clear(void)	{ serial3_clear(); }
+	virtual size_t write(uint8_t c) { serial3_putchar(c); return 1; }
+	virtual size_t write(unsigned long n)   { return write((uint8_t)n); }
+	virtual size_t write(long n)            { return write((uint8_t)n); }
+	virtual size_t write(unsigned int n)    { return write((uint8_t)n); }
+	virtual size_t write(int n)             { return write((uint8_t)n); }
+	virtual size_t write(const uint8_t *buffer, size_t size)
+					{ serial3_write(buffer, size); return size; }
+        virtual size_t write(const char *str)	{ size_t len = strlen(str);
+					  serial3_write((const uint8_t *)str, len);
+					  return len; }
+	virtual size_t write9bit(uint32_t c)	{ serial3_putchar(c); return 1; }
+};
+extern HardwareSerial3 Serial3;
+
+#endif
+#endif

teensy/core/analog.c

+/* Teensyduino Core Library
+ * http://www.pjrc.com/teensy/
+ * Copyright (c) 2013 PJRC.COM, LLC.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * 1. The above copyright notice and this permission notice shall be 
+ * included in all copies or substantial portions of the Software.
+ *
+ * 2. If the Software is incorporated into a build system that allows 
+ * selection among a list of target devices, then similar target
+ * devices manufactured by PJRC.COM must be included in the list of
+ * target devices and selectable in the same manner.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "core_pins.h"
+//#include "HardwareSerial.h"
+
+static uint8_t calibrating;
+static uint8_t analog_right_shift = 0;
+static uint8_t analog_config_bits = 10;
+static uint8_t analog_num_average = 4;
+static uint8_t analog_reference_internal = 0;
+
+// the alternate clock is connected to OSCERCLK (16 MHz).
+// datasheet says ADC clock should be 2 to 12 MHz for 16 bit mode
+// datasheet says ADC clock should be 1 to 18 MHz for 8-12 bit mode
+
+#if F_BUS == 60000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 7.5 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 15 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 15 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 15 MHz
+#elif F_BUS == 56000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 7 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 14 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 14 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 14 MHz
+#elif F_BUS == 48000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 12 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 12 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 12 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 24 MHz
+#elif F_BUS == 40000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 10 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 10 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 10 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 20 MHz
+#elif F_BUS == 36000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 9 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 18 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 18 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 18 MHz
+#elif F_BUS == 24000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(0) // 12 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(0) // 12 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(0) // 12 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 24 MHz
+#elif F_BUS == 16000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 16 MHz
+#elif F_BUS == 8000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz
+#elif F_BUS == 4000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 4 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 4 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 4 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 4 MHz
+#elif F_BUS == 2000000
+  #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 2 MHz
+  #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 2 MHz
+  #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 2 MHz
+  #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 2 MHz
+#else
+#error "F_BUS must be 60, 56, 48, 40, 36, 24, 4 or 2 MHz"
+#endif
+
+void analog_init(void)
+{
+	uint32_t num;
+
+	VREF_TRM = 0x60;
+	VREF_SC = 0xE1;		// enable 1.2 volt ref
+
+	if (analog_config_bits == 8) {
+		ADC0_CFG1 = ADC_CFG1_8BIT + ADC_CFG1_MODE(0);
+		ADC0_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(3);
+		#if defined(__MK20DX256__)
+		ADC1_CFG1 = ADC_CFG1_8BIT + ADC_CFG1_MODE(0);
+		ADC1_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(3);
+		#endif
+	} else if (analog_config_bits == 10) {
+		ADC0_CFG1 = ADC_CFG1_10BIT + ADC_CFG1_MODE(2) + ADC_CFG1_ADLSMP;
+		ADC0_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(3);
+		#if defined(__MK20DX256__)
+		ADC1_CFG1 = ADC_CFG1_10BIT + ADC_CFG1_MODE(2) + ADC_CFG1_ADLSMP;
+		ADC1_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(3);
+		#endif
+	} else if (analog_config_bits == 12) {
+		ADC0_CFG1 = ADC_CFG1_12BIT + ADC_CFG1_MODE(1) + ADC_CFG1_ADLSMP;
+		ADC0_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(2);
+		#if defined(__MK20DX256__)
+		ADC1_CFG1 = ADC_CFG1_12BIT + ADC_CFG1_MODE(1) + ADC_CFG1_ADLSMP;
+		ADC1_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(2);
+		#endif
+	} else {
+		ADC0_CFG1 = ADC_CFG1_16BIT + ADC_CFG1_MODE(3) + ADC_CFG1_ADLSMP;
+		ADC0_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(2);
+		#if defined(__MK20DX256__)
+		ADC1_CFG1 = ADC_CFG1_16BIT + ADC_CFG1_MODE(3) + ADC_CFG1_ADLSMP;
+		ADC1_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(2);
+		#endif
+	}
+
+	if (analog_reference_internal) {
+		ADC0_SC2 = ADC_SC2_REFSEL(1); // 1.2V ref
+		#if defined(__MK20DX256__)
+		ADC1_SC2 = ADC_SC2_REFSEL(1); // 1.2V ref
+		#endif
+	} else {
+		ADC0_SC2 = ADC_SC2_REFSEL(0); // vcc/ext ref
+		#if defined(__MK20DX256__)
+		ADC1_SC2 = ADC_SC2_REFSEL(0); // vcc/ext ref
+		#endif
+	}
+
+	num = analog_num_average;
+	if (num <= 1) {
+		ADC0_SC3 = ADC_SC3_CAL;  // begin cal
+		#if defined(__MK20DX256__)
+		ADC1_SC3 = ADC_SC3_CAL;  // begin cal
+		#endif
+	} else if (num <= 4) {
+		ADC0_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(0);
+		#if defined(__MK20DX256__)
+		ADC1_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(0);
+		#endif
+	} else if (num <= 8) {
+		ADC0_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(1);
+		#if defined(__MK20DX256__)
+		ADC1_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(1);
+		#endif
+	} else if (num <= 16) {
+		ADC0_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(2);
+		#if defined(__MK20DX256__)
+		ADC1_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(2);
+		#endif
+	} else {
+		ADC0_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(3);
+		#if defined(__MK20DX256__)
+		ADC1_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(3);
+		#endif
+	}
+	calibrating = 1;
+}
+
+static void wait_for_cal(void)
+{
+	uint16_t sum;
+
+	//serial_print("wait_for_cal\n");
+#if defined(__MK20DX128__)
+	while (ADC0_SC3 & ADC_SC3_CAL) {
+		// wait
+	}
+#elif defined(__MK20DX256__)
+	while ((ADC0_SC3 & ADC_SC3_CAL) || (ADC1_SC3 & ADC_SC3_CAL)) {
+		// wait
+	}
+#endif
+	__disable_irq();
+	if (calibrating) {
+		//serial_print("\n");
+		sum = ADC0_CLPS + ADC0_CLP4 + ADC0_CLP3 + ADC0_CLP2 + ADC0_CLP1 + ADC0_CLP0;
+		sum = (sum / 2) | 0x8000;
+		ADC0_PG = sum;
+		//serial_print("ADC0_PG = ");
+		//serial_phex16(sum);
+		//serial_print("\n");
+		sum = ADC0_CLMS + ADC0_CLM4 + ADC0_CLM3 + ADC0_CLM2 + ADC0_CLM1 + ADC0_CLM0;
+		sum = (sum / 2) | 0x8000;
+		ADC0_MG = sum;
+		//serial_print("ADC0_MG = ");
+		//serial_phex16(sum);
+		//serial_print("\n");
+#if defined(__MK20DX256__)
+		sum = ADC1_CLPS + ADC1_CLP4 + ADC1_CLP3 + ADC1_CLP2 + ADC1_CLP1 + ADC1_CLP0;
+		sum = (sum / 2) | 0x8000;
+		ADC1_PG = sum;
+		sum = ADC1_CLMS + ADC1_CLM4 + ADC1_CLM3 + ADC1_CLM2 + ADC1_CLM1 + ADC1_CLM0;
+		sum = (sum / 2) | 0x8000;
+		ADC1_MG = sum;
+#endif
+		calibrating = 0;
+	}
+	__enable_irq();
+}
+
+// ADCx_SC2[REFSEL] bit selects the voltage reference sources for ADC.
+//   VREFH/VREFL - connected as the primary reference option
+//   1.2 V VREF_OUT - connected as the VALT reference option
+
+
+#define DEFAULT         0
+#define INTERNAL        2
+#define INTERNAL1V2     2
+#define INTERNAL1V1     2
+#define EXTERNAL        0
+
+void analogReference(uint8_t type)
+{
+	if (type) {
+		// internal reference requested
+		if (!analog_reference_internal) {
+			analog_reference_internal = 1;
+			if (calibrating) {
+				ADC0_SC3 = 0; // cancel cal
+#if defined(__MK20DX256__)
+				ADC1_SC3 = 0; // cancel cal
+#endif
+			}
+			analog_init();
+		}
+	} else {
+		// vcc or external reference requested
+		if (analog_reference_internal) {
+			analog_reference_internal = 0;
+			if (calibrating) {
+				ADC0_SC3 = 0; // cancel cal
+#if defined(__MK20DX256__)
+				ADC1_SC3 = 0; // cancel cal
+#endif
+			}
+			analog_init();
+		}
+	}
+}
+
+
+void analogReadRes(unsigned int bits)
+{
+	unsigned int config;
+
+	if (bits >= 13) {
+		if (bits > 16) bits = 16;
+		config = 16;
+	} else if (bits >= 11) {
+		config = 12;
+	} else if (bits >= 9) {
+		config = 10;
+	} else {
+		config = 8;
+	}
+	analog_right_shift = config - bits;
+	if (config != analog_config_bits) {
+		analog_config_bits = config;
+		if (calibrating) ADC0_SC3 = 0; // cancel cal
+		analog_init();
+	}
+}
+
+void analogReadAveraging(unsigned int num)
+{
+
+	if (calibrating) wait_for_cal();
+	if (num <= 1) {
+		num = 0;
+		ADC0_SC3 = 0;
+	} else if (num <= 4) {
+		num = 4;
+		ADC0_SC3 = ADC_SC3_AVGE + ADC_SC3_AVGS(0);
+	} else if (num <= 8) {
+		num = 8;
+		ADC0_SC3 = ADC_SC3_AVGE + ADC_SC3_AVGS(1);
+	} else if (num <= 16) {
+		num = 16;
+		ADC0_SC3 = ADC_SC3_AVGE + ADC_SC3_AVGS(2);
+	} else {
+		num = 32;
+		ADC0_SC3 = ADC_SC3_AVGE + ADC_SC3_AVGS(3);
+	}
+	analog_num_average = num;
+}
+
+// The SC1A register is used for both software and hardware trigger modes of operation.
+
+#if defined(__MK20DX128__)
+static const uint8_t channel2sc1a[] = {
+	5, 14, 8, 9, 13, 12, 6, 7, 15, 4,
+	0, 19, 3, 21, 26, 22, 23
+};
+#elif defined(__MK20DX256__)
+static const uint8_t channel2sc1a[] = {
+	5, 14, 8, 9, 13, 12, 6, 7, 15, 4,
+	0, 19, 3, 19+128, 26, 18+128, 23,
+	5+192, 5+128, 4+128, 6+128, 7+128, 4+192
+// A15  26   E1   ADC1_SE5a  5+64
+// A16  27   C9   ADC1_SE5b  5
+// A17  28   C8   ADC1_SE4b  4
+// A18  29   C10  ADC1_SE6b  6
+// A19  30   C11  ADC1_SE7b  7
+// A20  31   E0   ADC1_SE4a  4+64
+};
+#endif
+
+
+
+// TODO: perhaps this should store the NVIC priority, so it works recursively?
+static volatile uint8_t analogReadBusyADC0 = 0;
+#if defined(__MK20DX256__)
+static volatile uint8_t analogReadBusyADC1 = 0;
+#endif
+
+int analogRead(uint8_t pin)
+{
+	int result;
+	uint8_t index, channel;
+
+	//serial_phex(pin);
+	//serial_print(" ");
+
+	if (pin <= 13) {
+		index = pin;      // 0-13 refer to A0-A13
+	} else if (pin <= 23) {
+		index = pin - 14; // 14-23 are A0-A9
+#if defined(__MK20DX256__)
+	} else if (pin >= 26 && pin <= 31) {
+		index = pin - 9;  // 26-31 are A15-A20
+#endif
+	} else if (pin >= 34 && pin <= 40) {
+		index = pin - 24;  // 34-37 are A10-A13, 38 is temp sensor,
+			    // 39 is vref, 40 is unused (A14 on Teensy 3.1)
+	} else {
+		return 0;   // all others are invalid
+	}
+
+	//serial_phex(index);
+	//serial_print(" ");
+
+	channel = channel2sc1a[index];
+	//serial_phex(channel);
+	//serial_print(" ");
+
+	//serial_print("analogRead");
+	//return 0;
+	if (calibrating) wait_for_cal();
+	//pin = 5; // PTD1/SE5b, pin 14, analog 0
+
+#if defined(__MK20DX256__)
+	if (channel & 0x80) goto beginADC1;
+#endif
+
+	__disable_irq();
+startADC0:
+	//serial_print("startADC0\n");
+	ADC0_SC1A = channel;
+	analogReadBusyADC0 = 1;
+	__enable_irq();
+	while (1) {
+		__disable_irq();
+		if ((ADC0_SC1A & ADC_SC1_COCO)) {
+			result = ADC0_RA;
+			analogReadBusyADC0 = 0;
+			__enable_irq();
+			result >>= analog_right_shift;
+			return result;
+		}
+		// detect if analogRead was used from an interrupt
+		// if so, our analogRead got canceled, so it must
+		// be restarted.
+		if (!analogReadBusyADC0) goto startADC0;
+		__enable_irq();
+		yield();
+	}
+
+#if defined(__MK20DX256__)
+beginADC1:
+	__disable_irq();
+startADC1:
+	//serial_print("startADC0\n");
+	// ADC1_CFG2[MUXSEL] bit selects between ADCx_SEn channels a and b.
+	if (channel & 0x40) {
+		ADC1_CFG2 &= ~ADC_CFG2_MUXSEL;
+	} else {
+		ADC1_CFG2 |= ADC_CFG2_MUXSEL;
+	}
+	ADC1_SC1A = channel & 0x3F;
+	analogReadBusyADC1 = 1;
+	__enable_irq();
+	while (1) {
+		__disable_irq();
+		if ((ADC1_SC1A & ADC_SC1_COCO)) {
+			result = ADC1_RA;
+			analogReadBusyADC1 = 0;
+			__enable_irq();
+			result >>= analog_right_shift;
+			return result;
+		}
+		// detect if analogRead was used from an interrupt
+		// if so, our analogRead got canceled, so it must
+		// be restarted.
+		if (!analogReadBusyADC1) goto startADC1;
+		__enable_irq();
+		yield();
+	}
+#endif
+}
+
+
+
+void analogWriteDAC0(int val)
+{
+#if defined(__MK20DX256__)
+	SIM_SCGC2 |= SIM_SCGC2_DAC0;
+	if (analog_reference_internal) {
+		DAC0_C0 = DAC_C0_DACEN;  // 1.2V ref is DACREF_1
+	} else {
+		DAC0_C0 = DAC_C0_DACEN | DAC_C0_DACRFS; // 3.3V VDDA is DACREF_2
+	}
+	if (val < 0) val = 0;  // TODO: saturate instruction?
+	else if (val > 4095) val = 4095;
+	*(int16_t *)&(DAC0_DAT0L) = val;
+#endif
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

teensy/core/avr_functions.h

+/* Teensyduino Core Library
+ * http://www.pjrc.com/teensy/
+ * Copyright (c) 2013 PJRC.COM, LLC.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * 1. The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 2. If the Software is incorporated into a build system that allows
+ * selection among a list of target devices, then similar target
+ * devices manufactured by PJRC.COM must be included in the list of
+ * target devices and selectable in the same manner.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _avr_functions_h_
+#define _avr_functions_h_
+
+#include <inttypes.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void eeprom_initialize(void);
+uint8_t eeprom_read_byte(const uint8_t *addr) __attribute__ ((pure));
+uint16_t eeprom_read_word(const uint16_t *addr) __attribute__ ((pure));
+uint32_t eeprom_read_dword(const uint32_t *addr) __attribute__ ((pure));
+void eeprom_read_block(void *buf, const void *addr, uint32_t len);
+void eeprom_write_byte(uint8_t *addr, uint8_t value);
+void eeprom_write_word(uint16_t *addr, uint16_t value);
+void eeprom_write_dword(uint32_t *addr, uint32_t value);
+void eeprom_write_block(const void *buf, void *addr, uint32_t len);
+int eeprom_is_ready(void);
+#define eeprom_busy_wait() do {} while (!eeprom_is_ready())
+
+static inline float eeprom_read_float(const float *addr) __attribute__((pure, always_inline, unused));
+static inline float eeprom_read_float(const float *addr)
+{
+	union {float f; uint32_t u32;} u;
+	u.u32 = eeprom_read_dword((const uint32_t *)addr);
+	return u.f;
+}
+static inline void eeprom_write_float(float *addr, float value) __attribute__((always_inline, unused));
+static inline void eeprom_write_float(float *addr, float value)
+{
+	union {float f; uint32_t u32;} u;
+	u.f = value;
+	eeprom_write_dword((uint32_t *)addr, u.u32);
+}
+static inline void eeprom_update_byte(uint8_t *addr, uint8_t value) __attribute__((always_inline, unused));
+static inline void eeprom_update_byte(uint8_t *addr, uint8_t value)
+{
+	eeprom_write_byte(addr, value);
+}
+static inline void eeprom_update_word(uint16_t *addr, uint16_t value) __attribute__((always_inline, unused));
+static inline void eeprom_update_word(uint16_t *addr, uint16_t value)
+{
+	eeprom_write_word(addr, value);
+}
+static inline void eeprom_update_dword(uint32_t *addr, uint32_t value) __attribute__((always_inline, unused));
+static inline void eeprom_update_dword(uint32_t *addr, uint32_t value)
+{
+	eeprom_write_dword(addr, value);
+}
+static inline void eeprom_update_float(float *addr, float value) __attribute__((always_inline, unused));
+static inline void eeprom_update_float(float *addr, float value)
+{
+	union {float f; uint32_t u32;} u;
+	u.f = value;
+	eeprom_write_dword((uint32_t *)addr, u.u32);
+}
+static inline void eeprom_update_block(const void *buf, void *addr, uint32_t len) __attribute__((always_inline, unused));
+static inline void eeprom_update_block(const void *buf, void *addr, uint32_t len)
+{
+	eeprom_write_block(buf, addr, len);
+}
+
+
+char * ultoa(unsigned long val, char *buf, int radix);
+char * ltoa(long val, char *buf, int radix);
+static inline char * utoa(unsigned int val, char *buf, int radix) __attribute__((always_inline, unused));
+static inline char * utoa(unsigned int val, char *buf, int radix) { return ultoa(val, buf, radix); }
+static inline char * itoa(int val, char *buf, int radix) __attribute__((always_inline, unused));
+static inline char * itoa(int val, char *buf, int radix) { return ltoa(val, buf, radix); }
+char * dtostrf(float val, int width, unsigned int precision, char *buf);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif

teensy/core/pins_arduino.h

+/* Teensyduino Core Library
+ * http://www.pjrc.com/teensy/
+ * Copyright (c) 2013 PJRC.COM, LLC.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * 1. The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 2. If the Software is incorporated into a build system that allows
+ * selection among a list of target devices, then similar target
+ * devices manufactured by PJRC.COM must be included in the list of
+ * target devices and selectable in the same manner.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef pins_macros_for_arduino_compatibility_h
+#define pins_macros_for_arduino_compatibility_h
+
+#include <stdint.h>
+
+const static uint8_t A0 = 14;
+const static uint8_t A1 = 15;
+const static uint8_t A2 = 16;
+const static uint8_t A3 = 17;
+const static uint8_t A4 = 18;
+const static uint8_t A5 = 19;
+const static uint8_t A6 = 20;
+const static uint8_t A7 = 21;
+const static uint8_t A8 = 22;
+const static uint8_t A9 = 23;
+const static uint8_t A10 = 34;
+const static uint8_t A11 = 35;
+const static uint8_t A12 = 36;
+const static uint8_t A13 = 37;
+const static uint8_t A14 = 40;
+
+const static uint8_t A15 = 26;
+const static uint8_t A16 = 27;
+const static uint8_t A17 = 28;
+const static uint8_t A18 = 29;
+const static uint8_t A19 = 30;
+const static uint8_t A20 = 31;
+
+const static uint8_t SS = 10;
+const static uint8_t MOSI = 11;
+const static uint8_t MISO = 12;
+const static uint8_t SCK = 13;
+const static uint8_t LED_BUILTIN = 13;
+const static uint8_t SDA = 18;
+const static uint8_t SCL = 19;
+
+
+#define NUM_DIGITAL_PINS 34
+#define NUM_ANALOG_INPUTS 14
+
+#define analogInputToDigitalPin(p) (((p) < 10) ? (p) + 14 : -1)
+#define digitalPinHasPWM(p) (((p) >= 3 && (p) <= 6) || (p) == 9 || (p) == 10 || ((p) >= 20 && (p) <= 23))
+
+#define NOT_AN_INTERRUPT -1
+#define digitalPinToInterrupt(p)  ((p) < NUM_DIGITAL_PINS ? (p) : -1)
+
+
+struct digital_pin_bitband_and_config_table_struct {
+        volatile uint32_t *reg;
+        volatile uint32_t *config;
+};
+extern const struct digital_pin_bitband_and_config_table_struct digital_pin_to_info_PGM[];
+
+// compatibility macros
+#define digitalPinToPort(pin) (pin)
+#define digitalPinToBitMask(pin) (1)
+#define portOutputRegister(pin) ((volatile uint8_t *)(digital_pin_to_info_PGM[(pin)].reg + 0))
+#define portSetRegister(pin)    ((volatile uint8_t *)(digital_pin_to_info_PGM[(pin)].reg + 32))
+#define portClearRegister(pin)  ((volatile uint8_t *)(digital_pin_to_info_PGM[(pin)].reg + 64))
+#define portToggleRegister(pin) ((volatile uint8_t *)(digital_pin_to_info_PGM[(pin)].reg + 96))
+#define portInputRegister(pin)  ((volatile uint8_t *)(digital_pin_to_info_PGM[(pin)].reg + 128))
+#define portModeRegister(pin)   ((volatile uint8_t *)(digital_pin_to_info_PGM[(pin)].reg + 160))
+#define portConfigRegister(pin) ((volatile uint32_t *)(digital_pin_to_info_PGM[(pin)].config))
+
+
+#define digitalPinToPortReg(pin) (portOutputRegister(pin))
+#define digitalPinToBit(pin) (1)
+
+
+#define NOT_ON_TIMER 0
+static inline uint8_t digitalPinToTimer(uint8_t) __attribute__((always_inline, unused));
+static inline uint8_t digitalPinToTimer(uint8_t pin)
+{
+	if (pin >= 3 && pin <= 6) return pin - 2;
+	if (pin >= 9 && pin <= 10) return pin - 4;
+	if (pin >= 20 && pin <= 23) return pin - 13;
+	return NOT_ON_TIMER;
+}
+
+
+
+
+#endif

teensy/core/usb_mem.h

+/* Teensyduino Core Library
+ * http://www.pjrc.com/teensy/
+ * Copyright (c) 2013 PJRC.COM, LLC.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * 1. The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 2. If the Software is incorporated into a build system that allows
+ * selection among a list of target devices, then similar target
+ * devices manufactured by PJRC.COM must be included in the list of
+ * target devices and selectable in the same manner.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _usb_mem_h_
+#define _usb_mem_h_
+
+#include <stdint.h>
+
+typedef struct usb_packet_struct {
+	uint16_t len;
+	uint16_t index;
+	struct usb_packet_struct *next;
+	uint8_t buf[64];
+} usb_packet_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+usb_packet_t * usb_malloc(void);
+void usb_free(usb_packet_t *p);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

teensy/core/yield.c

+/* Teensyduino Core Library
+ * http://www.pjrc.com/teensy/
+ * Copyright (c) 2013 PJRC.COM, LLC.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * 1. The above copyright notice and this permission notice shall be 
+ * included in all copies or substantial portions of the Software.
+ *
+ * 2. If the Software is incorporated into a build system that allows 
+ * selection among a list of target devices, then similar target
+ * devices manufactured by PJRC.COM must be included in the list of
+ * target devices and selectable in the same manner.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+void yield(void) __attribute__ ((weak));
+void yield(void) {};