3 #pragma GCC diagnostic push 4 #pragma GCC diagnostic ignored "-Wall" 5 #pragma GCC diagnostic ignored "-Wextra" 8 #define EBOARD_VERSION "3.1m" 9 #define VALUE_TO_STRING(x) #x 12 #define PREPROCESS_DEBUG 1 14 #define VALUE(x) VALUE_TO_STRING(x) 15 #ifndef PREPROCESS_DEBUG 16 #define PREPROCESS_DEBUG 0 18 #define PPERFORM_PRAGMA(str) _Pragma(#str) 19 #if PREPROCESS_DEBUG == 1 20 #define DEBUG_MSG(str) PPERFORM_PRAGMA(message ("" #str)) 21 #define MACRO_MSG(mac,str) PPERFORM_PRAGMA(message("You set " #mac " to " VALUE(mac) ": " #str)) 23 #define DEBUG_MSG(str) ; 24 #define MACRO_MSG(mac,str) ; 26 DEBUG_MSG(
"If you do not want any preprocessing information from this eBoard-Header set PREPROCESS_DEBUG to 0");
27 DEBUG_MSG(
"You are using eBoard-header v3.1m written by EagleoutIce");
32 #ifndef EBOARD_HEADER_GUARD 33 #define EBOARD_HEADER_GUARD 35 DEBUG_MSG(
"Documentation macro SET => Full doc features enabled");
38 #define EBOARD_I2C 0x1 40 #define EBOARD_LCD 0x1 42 #define EBOARD_SHIFT_REGISTER 0x1 44 #define EBOARD_BLUETOOTH 0x1 48 #define __AVR_ATmega2560__ 50 #define __AVR_ATmega328P__ 52 #define EBOARD_NEO 0x1 58 #include <avr/pgmspace.h> 62 #ifndef EBOARD_GUESSPATH 63 DEBUG_MSG(
"You are using Guesspath! Necessary libraries for eBoard will be included automatically");
65 #define EBOARD_GUESSPATH 0x1 67 DEBUG_MSG(
"You are not using Guesspath! Necessary libraries for eBoard have to be included manually");
69 #if defined(ARDUINO) //general platform-check [No tab] 71 #define main eVirtual_main //main has a different meaning^^ 72 #if ARDUINO >= 100 //this could be only Arduino.h but this snippet is portable :D 77 #if not ( defined(__AVR_ATmega2560__) || defined(__AVR_ATmega328P__)) 78 #error "This library was build for ARDUINO UNO R3 Aand ARDUINO MEGA 2560!" 80 #if defined(__AVR_ATmega2560__) 81 DEBUG_MSG(
"Building for Arduino Mega with ATmega2560");
83 #define PIN_MAX 0x32 //53 pins to address - 4 !!53 is SS 85 DEBUG_MSG(
"Building for Arduino Uno or Nano with ATmega328P");
86 #define PIN_MAX 0xA // 13 Pins to address - 4 !!10 is SS 89 #include <avr/interrupt.h> 90 #if EBOARD_I2C > 0x0 && EBOARD_GUESSPATH > 0x0 91 DEBUG_MSG(
"You enabled I²C feature"s);
96 #define TWI_FREQ 100000L 98 # ifndef TWI_BUFFER_LENGTH 99 #define TWI_BUFFER_LENGTH 32 108 #include <avr/interrupt.h> 109 #include <compat/twi.h> 111 #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) 114 #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) 116 #include "pins_arduino.h" 117 static volatile uint8_t twi_state;
118 static volatile uint8_t twi_slarw;
119 static volatile uint8_t twi_sendStop;
120 static volatile uint8_t twi_inRepStart;
121 static void (*twi_onSlaveTransmit)(void);
122 static void (*twi_onSlaveReceive)(uint8_t*, int);
123 static uint8_t twi_masterBuffer[TWI_BUFFER_LENGTH];
124 static volatile uint8_t twi_masterBufferIndex;
125 static volatile uint8_t twi_masterBufferLength;
126 static uint8_t twi_txBuffer[TWI_BUFFER_LENGTH];
127 static volatile uint8_t twi_txBufferIndex;
128 static volatile uint8_t twi_txBufferLength;
129 static uint8_t twi_rxBuffer[TWI_BUFFER_LENGTH];
130 static volatile uint8_t twi_rxBufferIndex;
131 static volatile uint8_t twi_error;
132 void twi_init(
void) {
133 twi_state = TWI_READY;
135 twi_inRepStart =
false;
136 digitalWrite(SDA, 1);
137 digitalWrite(SCL, 1);
140 TWBR = ((F_CPU / TWI_FREQ) - 16) / 2;
141 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA);
143 inline void twi_setAddress(uint8_t address) {
146 uint8_t twi_readFrom(uint8_t address, uint8_t* data, uint8_t length, uint8_t sendStop) {
148 if(TWI_BUFFER_LENGTH < length)
return 0;
149 while(TWI_READY != twi_state)
continue;
151 twi_sendStop = sendStop;
153 twi_masterBufferIndex = 0;
154 twi_masterBufferLength = length-1;
156 twi_slarw |= address << 1;
157 if (
true == twi_inRepStart) {
158 twi_inRepStart =
false;
160 TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE);
163 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTA);
164 while(TWI_MRX == twi_state)
continue;
165 if (twi_masterBufferIndex < length)
166 length = twi_masterBufferIndex;
167 for(i = 0; i < length; ++i) data[i] = twi_masterBuffer[i];
170 uint8_t twi_writeTo(uint8_t address, uint8_t* data, uint8_t length, uint8_t wait, uint8_t sendStop) {
172 if(TWI_BUFFER_LENGTH < length)
return 1;
173 while(TWI_READY != twi_state)
continue;
175 twi_sendStop = sendStop;
177 twi_masterBufferIndex = 0;
178 twi_masterBufferLength = length;
179 for(i = 0; i < length; ++i) twi_masterBuffer[i] = data[i];
180 twi_slarw = TW_WRITE;
181 twi_slarw |= address << 1;
182 if (
true == twi_inRepStart) {
183 twi_inRepStart =
false;
185 TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE);
188 TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE) | _BV(TWSTA);
189 while(wait && (TWI_MTX == twi_state))
continue;
190 if (twi_error == 0xFF)
return 0;
191 else if (twi_error == TW_MT_SLA_NACK)
return 2;
192 else if (twi_error == TW_MT_DATA_NACK)
return 3;
195 uint8_t twi_transmit(
const uint8_t* data, uint8_t length) {
197 if(TWI_BUFFER_LENGTH < length)
return 1;
198 if(TWI_STX != twi_state)
return 2;
199 twi_txBufferLength = length;
200 for(i = 0; i < length; ++i) twi_txBuffer[i] = data[i];
203 void twi_attachSlaveRxEvent(
void (*
function)(uint8_t*,
int) ) {
204 twi_onSlaveReceive =
function;
206 void twi_attachSlaveTxEvent(
void (*
function)(
void) ) {
207 twi_onSlaveTransmit =
function;
209 void twi_reply(uint8_t ack) {
211 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA);
213 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT);
216 void twi_stop(
void) {
217 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTO);
218 while(TWCR & _BV(TWSTO))
continue;
219 twi_state = TWI_READY;
221 void twi_releaseBus(
void){
222 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT);
223 twi_state = TWI_READY;
234 if(twi_masterBufferIndex < twi_masterBufferLength){
235 TWDR = twi_masterBuffer[twi_masterBufferIndex++];
238 if (twi_sendStop) twi_stop();
240 twi_inRepStart =
true;
241 TWCR = _BV(TWINT) | _BV(TWSTA)| _BV(TWEN) ;
242 twi_state = TWI_READY;
247 twi_error = TW_MT_SLA_NACK;
250 case TW_MT_DATA_NACK:
251 twi_error = TW_MT_DATA_NACK;
255 twi_error = TW_MT_ARB_LOST;
259 twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
261 if(twi_masterBufferIndex < twi_masterBufferLength) twi_reply(1);
264 case TW_MR_DATA_NACK:
265 twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
266 if (twi_sendStop) twi_stop();
268 twi_inRepStart =
true;
269 TWCR = _BV(TWINT) | _BV(TWSTA)| _BV(TWEN) ;
270 twi_state = TWI_READY;
277 case TW_SR_GCALL_ACK:
278 case TW_SR_ARB_LOST_SLA_ACK:
279 case TW_SR_ARB_LOST_GCALL_ACK:
281 twi_rxBufferIndex = 0;
285 case TW_SR_GCALL_DATA_ACK:
286 if(twi_rxBufferIndex < TWI_BUFFER_LENGTH){
287 twi_rxBuffer[twi_rxBufferIndex++] = TWDR;
292 if(twi_rxBufferIndex < TWI_BUFFER_LENGTH) twi_rxBuffer[twi_rxBufferIndex] =
'\0';
294 twi_onSlaveReceive(twi_rxBuffer, twi_rxBufferIndex);
295 twi_rxBufferIndex = 0;
298 case TW_SR_DATA_NACK:
299 case TW_SR_GCALL_DATA_NACK:
303 case TW_ST_ARB_LOST_SLA_ACK:
305 twi_txBufferIndex = 0;
306 twi_txBufferLength = 0;
307 twi_onSlaveTransmit();
308 if(0 == twi_txBufferLength){
309 twi_txBufferLength = 1;
310 twi_txBuffer[0] = 0x00;
313 TWDR = twi_txBuffer[twi_txBufferIndex++];
314 if(twi_txBufferIndex < twi_txBufferLength) twi_reply(1);
317 case TW_ST_DATA_NACK:
318 case TW_ST_LAST_DATA:
320 twi_state = TWI_READY;
325 twi_error = TW_BUS_ERROR;
331 #include <inttypes.h> 333 #define BUFFER_LENGTH 32 336 class TwoWire :
public Stream {
368 void begin(uint8_t address);
370 inline void begin(
int address);
380 inline uint8_t
requestFrom(uint8_t address, uint8_t quantity);
382 uint8_t
requestFrom(uint8_t address , uint8_t quantity, uint8_t sendStop);
384 inline uint8_t
requestFrom(
int address,
int quantity);
386 inline uint8_t
requestFrom(
int address,
int quantity,
int sendStop);
388 virtual size_t write(uint8_t data);
390 virtual size_t write(
const uint8_t *data,
size_t quantity);
394 virtual int read(
void);
396 virtual int peek(
void);
400 void onRequest(
void (*
function)(
void) );
408 #include <inttypes.h> 431 twi_setAddress(address);
437 begin((uint8_t)address);
443 uint8_t
read = twi_readFrom(address,
rxBuffer, quantity, sendStop);
449 return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)
true);
452 return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)
true);
455 return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)sendStop);
486 twi_transmit(&data, 1);
492 for(
size_t i = 0; i < quantity; ++i) {
496 twi_transmit(data, quantity);
525 for(uint8_t i = 0; i < numBytes; ++i) {
548 DEBUG_MSG(
"You disabled I²C");
551 #ifndef EBOARD_USE_SPI 552 #define EBOARD_USE_SPI 0x1 554 #if EBOARD_USE_SPI > 0x0 555 DEBUG_MSG(
"You enabled SPI");
557 #define _SPI_H_INCLUDED 560 #define SPI_CLOCK_DIV4 0x00 562 #define SPI_CLOCK_DIV16 0x01 564 #define SPI_CLOCK_DIV64 0x02 566 #define SPI_CLOCK_DIV128 0x03 568 #define SPI_CLOCK_DIV2 0x04 570 #define SPI_CLOCK_DIV8 0x05 572 #define SPI_CLOCK_DIV32 0x06 574 #define SPI_MODE0 0x00 576 #define SPI_MODE1 0x04 578 #define SPI_MODE2 0x08 580 #define SPI_MODE3 0x0C 582 #define SPI_MODE_MASK 0x0C 584 #define SPI_CLOCK_MASK 0x03 586 #define SPI_2XCLOCK_MASK 0x01 591 inline static byte
transfer(byte _data);
597 static void begin(
void);
599 inline static void end(
void);
611 while (!(SPSR & _BV(SPIF)));
617 digitalWrite(SS, HIGH);
621 pinMode(SCK, OUTPUT);
622 pinMode(MOSI, OUTPUT);
626 if(bitOrder == LSBFIRST) SPCR |= _BV(DORD);
627 else SPCR &= ~(_BV(DORD));
637 DEBUG_MSG(
"You disabled SPI");
639 #if (EBOARD_I2C > 0x0) && (EBOARD_LCD > 0x0) 640 #include <avr/pgmspace.h> 641 DEBUG_MSG(
"You enabled LCD");
644 static bool STOP =
false;
647 DEBUG_MSG(
"You defined IGNORE_SIZE: byte will be used");
650 DEBUG_MSG(
"You did not define IGNORE_SIZE: int will be used");
654 #ifndef EBOARD_DEBUG_MODE 655 #define EBOARD_DEBUG_MODE 0x1 657 #if EBOARD_DEBUG_MODE > 0x0 664 #define EBOARD_NANO 0x0 666 #if EBOARD_NANO > 0x0 || defined(DOC) 667 #ifndef EBOARD_NANO_STEER 669 #define EBOARD_NANO_STEER 12 671 #ifndef EBOARD_NANO_MAIN 673 #define EBOARD_NANO_MAIN 13 675 MACRO_MSG(
EBOARD_NANO,
"Using Arduino NANO environment [e.g. remove SoccerBoard]");
676 #if PREPROCESS_DEBUG > 0x1 677 #pragma message("Using " VALUE(EBOARD_NANO_STEER) " as data pin for STEERING MOTOR") 678 #pragma message("Using " VALUE(EBOARD_NANO_MAIN) " as data pin for MAIN (Driving) MOTOR") 681 MACRO_MSG(
EBOARD_NANO,
"Using Arduino UNO/MEGA environment");
684 #ifndef EBOARD_CHECK_PINS 685 #define EBOARD_CHECK_PINS 0x1 687 #if EBOARD_CHECK_PINS > 0x0 692 #ifndef EBOARD_SHIFT_REGISTER 694 #define EBOARD_SHIFT_REGISTER 0x0 696 #if EBOARD_SHIFT_REGISTER > 0x0 702 #ifndef EBOARD_CHECK_PINS_PWM 703 #define EBOARD_CHECK_PINS_PWM 0x1 705 #if EBOARD_CHECK_PINS_PWM > 0x0 711 #ifndef EBOARD_DEBUG_SPEED 712 #define EBOARD_DEBUG_SPEED 9600 714 #if PREPROCESS_DEBUG > 0x0 715 #pragma message("Set Debugging speed to " VALUE(EBOARD_DEBUG_SPEED)) 718 #ifndef EBOARD_SPI_SERVO_MAX 719 #define EBOARD_SPI_SERVO_MAX 2 721 #if PREPROCESS_DEBUG > 0x0 722 #pragma message("Set amount of used Servos to " VALUE(EBOARD_SPI_SERVO_MAX)) 725 #ifndef EBOARD_USE_UTILITY 726 #define EBOARD_USE_UTILITY 0x1 728 #if EBOARD_USE_UTILITY > 0x0 734 #define EBOARD_COPY_AND_PASTE 0x1 736 #ifndef EBOARD_PWM_SPE 737 #define EBOARD_PWM_SPE 1 739 #if PREPROCESS_DEBUG > 0x0 740 #pragma message("Set PWM interval to " VALUE(EBOARD_PWM_SPE) "s") 744 #define EBOARD_I2C 0x0 //disabled by default 746 #ifndef EBOARD_BLUETOOTH 748 #define EBOARD_BLUETOOTH 0x0 750 #if EBOARD_BLUETOOTH > 0x0 757 #define EBOARD_CLAMP 0x1 759 #if EBOARD_CLAMP > 0x0 760 MACRO_MSG(
EBOARD_CLAMP,
"Motor Range is set to [0;1023]");
762 MACRO_MSG(
EBOARD_CLAMP,
"Motor Range is set to [-300;300]");
766 #define EBOARD_NEO 0x0 769 MACRO_MSG(
EBOARD_NEO,
"Adafruit Neo-Pixel support enabled");
771 MACRO_MSG(
EBOARD_NEO,
"Adafruit Neo-Pixel support disabled");
774 #ifndef EBOARD_USE_RESET 775 #define EBOARD_USE_RESET 0x1 777 #if EBOARD_USE_RESET > 0x0 784 #ifndef PIN_BLUETOOTH_STATE 785 #if defined(__AVR_ATmega2560__) 786 #define PIN_BLUETOOTH_STATE 0x13 // 19 788 #define PIN_BLUETOOTH_STATE 0x2 792 #ifndef PIN_BLUETOOTH_RX 793 #if defined(__AVR_ATmega2560__) 794 #define PIN_BLUETOOTH_RX 0x13 // 19 796 #define PIN_BLUETOOTH_RX 0x2 800 #ifndef PIN_BLUETOOTH_TX 801 #if defined(__AVR_ATmega2560__) 802 #define PIN_BLUETOOTH_TX 0x12 // 18 804 #define PIN_BLUETOOTH_TX 0x3 808 #ifndef PIN_MOTOR_DIR 809 #define PIN_MOTOR_DIR 0x4 812 #ifndef PIN_MOTOR_SPE 813 #define PIN_MOTOR_SPE 0x5 816 #ifndef PIN_SHIFT_CLK 817 #define PIN_SHIFT_CLK 0x6 820 #ifndef PIN_SHIFT_DAT 821 #define PIN_SHIFT_DAT 0x7 824 #ifndef PIN_SHIFT_LAT 825 #define PIN_SHIFT_LAT 0x8 835 #if (EBOARD_BLUETOOTH > 0x0) && defined(__AVR_ATmega328P__) 836 #if EBOARD_GUESSPATH > 0x0 838 #define _SS_MAX_RX_BUFF 64 // RX buffer size 840 #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) 883 void setTX(uint8_t transmitPin);
885 void setRX(uint8_t receivePin);
887 static inline void tunedDelay(uint16_t delay);
891 SoftwareSerial(uint8_t receivePin, uint8_t transmitPin,
bool inverse_logic =
false);
895 void begin(
long speed);
899 inline void end(
void);
907 virtual size_t write(uint8_t byte);
909 virtual int read(
void);
913 virtual void flush(
void);
930 #if EBOARD_DEBUG_MODE > 0x0 932 #define _DEBUG_PIN1 11 933 #define _DEBUG_PIN2 13 935 typedef struct _DELAY_TABLE {
937 unsigned short rx_delay_centering;
938 unsigned short rx_delay_intrabit;
939 unsigned short rx_delay_stopbit;
940 unsigned short tx_delay;
942 #if F_CPU == 16000000 943 static const DELAY_TABLE PROGMEM table[] = {
945 { 115200, 1, 17, 17, 12, },
946 { 57600, 10, 37, 37, 33, },
947 { 38400, 25, 57, 57, 54, },
948 { 31250, 31, 70, 70, 68, },
949 { 28800, 34, 77, 77, 74, },
950 { 19200, 54, 117, 117, 114, },
951 { 14400, 74, 156, 156, 153, },
952 { 9600, 114, 236, 236, 233, },
953 { 4800, 233, 474, 474, 471, },
954 { 2400, 471, 950, 950, 947, },
955 { 1200, 947, 1902, 1902, 1899, },
956 { 600, 1902, 3804, 3804, 3800, },
957 { 300, 3804, 7617, 7617, 7614, },
959 const int XMIT_START_ADJUSTMENT = 5;
960 #elif F_CPU == 8000000 961 static const DELAY_TABLE table[] PROGMEM = {
963 { 115200, 1, 5, 5, 3, },
964 { 57600, 1, 15, 15, 13, },
965 { 38400, 2, 25, 26, 23, },
966 { 31250, 7, 32, 33, 29, },
967 { 28800, 11, 35, 35, 32, },
968 { 19200, 20, 55, 55, 52, },
969 { 14400, 30, 75, 75, 72, },
970 { 9600, 50, 114, 114, 112, },
971 { 4800, 110, 233, 233, 230, },
972 { 2400, 229, 472, 472, 469, },
973 { 1200, 467, 948, 948, 945, },
974 { 600, 948, 1895, 1895, 1890, },
975 { 300, 1895, 3805, 3805, 3802, },
977 const int XMIT_START_ADJUSTMENT = 4;
978 #elif F_CPU == 20000000 979 static const DELAY_TABLE PROGMEM table[] = {
981 { 115200, 3, 21, 21, 18, },
982 { 57600, 20, 43, 43, 41, },
983 { 38400, 37, 73, 73, 70, },
984 { 31250, 45, 89, 89, 88, },
985 { 28800, 46, 98, 98, 95, },
986 { 19200, 71, 148, 148, 145, },
987 { 14400, 96, 197, 197, 194, },
988 { 9600, 146, 297, 297, 294, },
989 { 4800, 296, 595, 595, 592, },
990 { 2400, 592, 1189, 1189, 1186, },
991 { 1200, 1187, 2379, 2379, 2376, },
992 { 600, 2379, 4759, 4759, 4755, },
993 { 300, 4759, 9523, 9523, 9520, },
995 const int XMIT_START_ADJUSTMENT = 6;
997 #error This version of SoftwareSerial supports only 20, 16 and 8MHz processors 1003 #if EBOARD_DEBUG_MODE > 0x0 1004 inline void DebugPulse(uint8_t pin, uint8_t count) {
1006 volatile uint8_t *pport = portOutputRegister(digitalPinToPort(pin));
1007 uint8_t val = *pport;
1010 *pport = val | digitalPinToBitMask(pin);
1018 asm volatile(
"sbiw %0, 0x01 \n\t" 1020 "cpi %A0, 0xFF \n\t" 1023 :
"+r" (delay),
"+a" (tmp)
1031 uint8_t oldSREG = SREG;
1041 #if GCC_VERSION < 40302 1057 #if EBOARD_DEBUG_MODE > 0x0 1058 DebugPulse(_DEBUG_PIN2, 1);
1061 for (uint8_t i=0x1; i; i <<= 1)
1064 #if EBOARD_DEBUG_MODE > 0x0 1065 DebugPulse(_DEBUG_PIN2, 1);
1075 #if EBOARD_DEBUG_MODE > 0x0 1076 DebugPulse(_DEBUG_PIN2, 1);
1085 #if EBOARD_DEBUG_MODE > 0x0 1086 #if _DEBUG // for scope: pulse pin as overflow indictator 1087 DebugPulse(_DEBUG_PIN1, 1);
1093 #if GCC_VERSION < 40302 1107 if (pin_state == LOW)
1120 #if defined(PCINT0_vect) 1125 #if defined(PCINT1_vect) 1130 #if defined(PCINT2_vect) 1135 #if defined(PCINT3_vect) 1141 _rx_delay_centering(0),
1142 _rx_delay_intrabit(0),
1143 _rx_delay_stopbit(0),
1145 _buffer_overflow(false),
1146 _inverse_logic(inverse_logic) {
1150 SoftwareSerial::~SoftwareSerial() {
1154 pinMode(tx, OUTPUT);
1155 digitalWrite(tx, HIGH);
1157 uint8_t port = digitalPinToPort(tx);
1163 digitalWrite(rx, HIGH);
1166 uint8_t port = digitalPinToPort(rx);
1171 for (
unsigned i=0; i<
sizeof(table)/
sizeof(table[0]); ++i) {
1172 long baud = pgm_read_dword(&table[i].baud);
1173 if (baud == speed) {
1177 _tx_delay = pgm_read_word(&table[i].tx_delay);
1189 pinMode(_DEBUG_PIN1, OUTPUT);
1190 pinMode(_DEBUG_PIN2, OUTPUT);
1217 uint8_t oldSREG = SREG;
1222 for (byte mask = 0x01; mask; mask <<= 1) {
1232 for (byte mask = 0x01; mask; mask <<= 1) {
1248 uint8_t oldSREG = SREG;
1265 #if EBOARD_DEBUG_MODE > 0x0 1267 #define __ASSERT_USE_STDERR 1270 void __assert (
const char *__func,
const char *__file,
optVAL_t __lineno,
const char *__sexp);
1272 void __assert (
const char *__func,
const char *__file,
optVAL_t __lineno,
const char *__sexp){
1273 Serial.print(
"Error with: "); Serial.print(__func);
1274 Serial.print(
" in "); Serial.print(__file);
1275 Serial.print(
" >>");
1276 Serial.println(__sexp);
1277 if(strcmp(__func,
"checkIdx")==0){
1278 Serial.println(
" This happens if an out of bounds exception");
1279 Serial.println(
" has occured. Following pins shouldn't be used:");
1282 Serial.println(
" : Used for Bluetooth communication");
1283 Serial.print(
" D");Serial.print(
PIN_MOTOR_DIR);Serial.print(
"&");
1285 Serial.println(
" : Used for main motor control");
1286 #if EBOARD_USE_SPI > 0x0 1287 Serial.print(
" D10-13");
1288 Serial.println(
": Used for smart-servo-shield");
1290 }
else if (strcmp(__func,
"readPin")==0){
1291 Serial.println(
"You've tried to access an analogPin that isn't present on the board you're currently working on!");
1302 #if EBOARD_DEBUG_MODE > 0x0 1303 assert(idx>=0x0 && idx <
PIN_MAX);
1308 #if EBOARD_COPY_AND_PASTE > 0x0 1309 #if EBOARD_CHECK_PINS_PWM > 0x0 1315 for (count = 0; x; count++)
1321 #if EBOARD_CHECK_PINS > 0x0 1323 #if defined(__AVR_ATmega328P__) && not defined(__AVR_ATmega2560__) 1325 #elif defined(__AVR_ATmega2560__) 1329 #if defined(__AVR_ATmega328P__) && not defined(__AVR_ATmega2560__) 1331 #elif defined(__AVR_ATmega2560__) 1339 return (mode == OUTPUT)? ((
pin_out & (1<<idx))>0x0):((
pin_in & (1<<idx))>0x0);
1347 #if EBOARD_CHECK_PINS > 0x0 1362 #if EBOARD_BLUETOOTH > 0x0 1364 inline char readVal(
char oF =
'.');
1368 template <
typename T>
1369 inline void writeVal(
const T& val);
1374 #if (EBOARD_BLUETOOTH > 0x0) && (((PIN_BLUETOOTH_RX==0x13) && (PIN_BLUETOOTH_TX==0x12)) && defined(__AVR_ATmega2560__)) 1380 inline char readVal(
char oF) {
1381 #if (EBOARD_BLUETOOTH > 0x0) && (((PIN_BLUETOOTH_RX==0x13) && (PIN_BLUETOOTH_TX==0x12)) && defined(__AVR_ATmega2560__)) 1382 return ((Serial1.available())?(Serial1.read()):(oF));
1387 template<
typename T>
1388 inline void writeVal(
const T& val){
1389 #if (EBOARD_BLUETOOTH > 0x0) && (((PIN_BLUETOOTH_RX==0x13) && (PIN_BLUETOOTH_TX==0x12)) && defined(__AVR_ATmega2560__)) 1396 #if PIN_BLUETOOTH_RX != PIN_BLUETOOTH_STATE 1404 #if EBOARD_SHIFT_REGISTER > 0x0 1432 val = min(val,0xFF); val = max(0x0,val);
1436 extern void rept_task(
void);
1437 DEBUG_MSG(
"You defined REPT_TASK: you have to define rept_task(void)!");
1439 DEBUG_MSG(
"You did not define REPT_TASK: rept_task(void) will not have any effect");
1446 #if EBOARD_SHIFT_REGISTER > 0x0 1453 #if EBOARD_CHECK_PINS > 0x0 1457 #if EBOARD_COPY_AND_PASTE > 0x0 1460 pinMode(idx,OUTPUT);
1462 digitalWrite(idx,val);
1469 #if EBOARD_CHECK_PINS > 0x0 1471 #if defined (__AVR_ATmega2560__) 1472 else if (idx<0||idx>0xF){
1474 else if (idx<0||idx>0x7){
1476 #if EBOARD_DEBUG_MODE > 0x0 1483 #if EBOARD_COPY_AND_PASTE > 0x0 1488 return((dig)? digitalRead(idx) : analogRead(idx));
1491 #if EBOARD_USE_SPI > 0x0 && (EBOARD_NANO == 0x0) 1496 #if defined(__AVR_ATmega2560__) 1497 ServoCds55(
int CS=53);
1499 ServoCds55(
int CS=10);
1502 void WritePos(
int ID,
int Pos);
1503 void write(
int ID,
int Pos);
1504 inline void setVelocity(
int velocity);
1505 inline void setPoslimit(
int posLimit);
1506 void rotate(
int ID,
int velocity);
1507 void SetServoLimit(
int ID,
int upperLimit);
1508 void SetMotormode(
int ID,
int velocity);
1509 void SetID(
int ID,
int newID);
1511 byte sendWait (
const byte what);
1513 int upperLimit_temp;
1516 ServoCds55::ServoCds55 (
int CS):cs(CS) {
1517 velocity_temp = 150;
1518 upperLimit_temp = 300;
1520 void ServoCds55::begin() {
1522 digitalWrite(cs,HIGH);
1526 byte ServoCds55::sendWait (
const byte what) {
1528 delayMicroseconds (20);
1531 void ServoCds55::setVelocity(
int velocity){
1532 velocity_temp = velocity;
1534 void ServoCds55::setPoslimit(
int posLimit){
1535 upperLimit_temp = posLimit;
1537 void ServoCds55::write(
int ID,
int Pos){
1538 SetServoLimit(ID,upperLimit_temp);
1541 void ServoCds55::rotate(
int ID,
int velocity){
1542 SetServoLimit(ID,0);
1544 SetMotormode(ID,velocity);
1546 void ServoCds55::WritePos(
int ID,
int Pos){
1547 int PosB = (Pos>>8 & 0xff);
1548 int PosS = (Pos & 0xff);
1549 int velocityB = (velocity_temp>>8 & 0xff);
1550 int velocityS = (velocity_temp & 0xff);
1551 digitalWrite(cs, LOW);
1552 sendWait (
'p'); sendWait (ID);
1553 sendWait (PosB); sendWait (PosS);
1554 sendWait (velocityB); sendWait (velocityS);
1555 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1556 digitalWrite(cs, HIGH);
1559 void ServoCds55::SetServoLimit(
int ID,
int upperLimit_temp){
1560 int upperLimitB = (upperLimit_temp>>8 & 0xff);
1561 int upperLimitS = (upperLimit_temp & 0xff);
1562 digitalWrite(cs, LOW);
1563 sendWait (
's'); sendWait (ID);
1564 sendWait (upperLimitB); sendWait (upperLimitS);
1565 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1566 digitalWrite(cs, HIGH);
1569 void ServoCds55::SetMotormode(
int ID,
int velocity){
1570 int velocityB = (velocity>>8 & 0xff);
1571 int velocityS = (velocity & 0xff);
1572 digitalWrite(cs, LOW);
1573 sendWait (
'm'); sendWait (ID);
1574 sendWait (velocityB); sendWait (velocityS);
1575 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1576 digitalWrite(cs, HIGH);
1579 void ServoCds55::SetID(
int ID,
int newID){
1580 digitalWrite(cs, LOW);
1581 sendWait (
'i'); sendWait (ID);
1583 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1584 digitalWrite(cs, HIGH);
1587 void ServoCds55::Reset(
int ID){
1588 digitalWrite(cs, LOW);
1589 sendWait (
'r'); sendWait (ID);
1590 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1591 digitalWrite(cs, HIGH);
1598 #if EBOARD_COPY_AND_PASTE > 0x0 && EBOARD_NANO == 0 1604 #if EBOARD_USE_UTILITY > 0x0 or defined(__AVR_ATmega2560__) //won't shrink space... just speed things up 1606 inline void led(
int idx,
bool state);
1608 inline void ledOn(
int idx);
1610 inline void ledOff(
int idx);
1616 #if EBOARD_USE_UTILITY > 0x0 1623 inline void motor(uint8_t
id,int16_t val);
1637 inline void sleep(uint16_t t);
1639 inline void msleep(uint16_t t);
1645 inline void reset(
void);
1649 #if defined(__AVR_ATmega2560__) 1655 #elif EBOARD_USE_UTILITY > 0x0 1662 #if EBOARD_USE_UTILITY > 0x0 1668 else if(
id>0&&
id<3&&(val>-0 && val < 1024)) {
_servoHandler.write((
id-1),(val *600/1023 - 300));}
1672 #if EBOARD_USE_RESET > 0x0 1673 wdt_enable(WDTO_15MS);
1687 #define DIGITAL_IN 0x0 1689 #define DIGITAL_IN_INV 0x1 1691 #define DIGITAL_IN_PULLUP 0x2 1693 #define DIGITAL_IN_PULLUP_INV 0x3 1695 #define DIGITAL_OUT 0x4 1697 #define DIGITAL_OUT_INV 0x5 1699 #define DIGITAL_OUT_LOW 0x6 1701 #define DIGITAL_OUT_HIGH 0x7 1703 #define ANALOG_IN_8_BIT 0x8 1705 #define ANALOG_IN_10_BIT 0x9 1707 #define ANALOG_IN_MEAN_8_BIT 0xA 1709 #define ANALOG_IN_MEAN_10_BIT 0xB 1711 #define COUNTER_8_BIT 0xC 1713 #define COUNTER_16_BIT 0xD 1715 #define COUNTER_RISE_8_BIT 0xE 1717 #define COUNTER_RISE_16_BIT 0xF 1719 #define PWM_SLOW 0x8 1721 #define PWM_FAST 0x9 1723 #define FREQ_LOW 0xA 1725 #define FREQ_HIGH 0xB 1727 #define COUNTER_B_DIR 0xC 1729 #define COUNTER_B_DIR_PULLUP 0xD 1731 #define COUNTER_MEAN_8_BIT 0xE 1733 #define COUNTER_MEAN_16_BIT 0xF 1738 #if EBOARD_USE_UTILITY > 0x0 1740 inline void read(
void);
1747 inline void write(
void);
1758 this->
A=0x0;this->
B=0x0;this->
C=0x0;
1760 #if EBOARD_USE_UTILITY > 0x0 1780 #if EBOARD_USE_UTILITY > 0x0 1792 inline void ledOff(
void);
1794 inline void ledOn(
void);
1821 #if EBOARD_USE_UTILITY > 0x0 1833 #if EBOARD_CLAMP > 0x0 1834 if(pos>1023 || speed > 1023)
return;
1836 speed = speed*600/1023 - 300;
1837 pos = pos *600/1023 - 300;
1839 if(pos>300 || speed > 300)
return;
1855 #if EBOARD_USE_UTILITY > 0x0 1866 inline void action(
void);
1878 #if EBOARD_USE_UTILITY > 0x0 1901 #if EBOARD_BLUETOOTH > 0x0 1913 inline void write(
const char*
const val);
1923 #if EBOARD_I2C > 0x0 1933 for (byte i = 1; (i < 255 && !
STOP); i++) {
1937 if(count < ret_len) ret[count] = i;
1963 #if EBOARD_LCD > 0x0 1965 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
1966 {0x00,0x00,0x5F,0x00,0x00,0x00,0x00,0x00},
1967 {0x00,0x00,0x07,0x00,0x07,0x00,0x00,0x00},
1968 {0x00,0x14,0x7F,0x14,0x7F,0x14,0x00,0x00},
1969 {0x00,0x24,0x2A,0x7F,0x2A,0x12,0x00,0x00},
1970 {0x00,0x23,0x13,0x08,0x64,0x62,0x00,0x00},
1971 {0x00,0x36,0x49,0x55,0x22,0x50,0x00,0x00},
1972 {0x00,0x00,0x05,0x03,0x00,0x00,0x00,0x00},
1973 {0x00,0x1C,0x22,0x41,0x00,0x00,0x00,0x00},
1974 {0x00,0x41,0x22,0x1C,0x00,0x00,0x00,0x00},
1975 {0x00,0x08,0x2A,0x1C,0x2A,0x08,0x00,0x00},
1976 {0x00,0x08,0x08,0x3E,0x08,0x08,0x00,0x00},
1977 {0x00,0xA0,0x60,0x00,0x00,0x00,0x00,0x00},
1978 {0x00,0x08,0x08,0x08,0x08,0x08,0x00,0x00},
1979 {0x00,0x60,0x60,0x00,0x00,0x00,0x00,0x00},
1980 {0x00,0x20,0x10,0x08,0x04,0x02,0x00,0x00},
1981 {0x00,0x3E,0x51,0x49,0x45,0x3E,0x00,0x00},
1982 {0x00,0x00,0x42,0x7F,0x40,0x00,0x00,0x00},
1983 {0x00,0x62,0x51,0x49,0x49,0x46,0x00,0x00},
1984 {0x00,0x22,0x41,0x49,0x49,0x36,0x00,0x00},
1985 {0x00,0x18,0x14,0x12,0x7F,0x10,0x00,0x00},
1986 {0x00,0x27,0x45,0x45,0x45,0x39,0x00,0x00},
1987 {0x00,0x3C,0x4A,0x49,0x49,0x30,0x00,0x00},
1988 {0x00,0x01,0x71,0x09,0x05,0x03,0x00,0x00},
1989 {0x00,0x36,0x49,0x49,0x49,0x36,0x00,0x00},
1990 {0x00,0x06,0x49,0x49,0x29,0x1E,0x00,0x00},
1991 {0x00,0x00,0x36,0x36,0x00,0x00,0x00,0x00},
1992 {0x00,0x00,0xAC,0x6C,0x00,0x00,0x00,0x00},
1993 {0x00,0x08,0x14,0x22,0x41,0x00,0x00,0x00},
1994 {0x00,0x14,0x14,0x14,0x14,0x14,0x00,0x00},
1995 {0x00,0x41,0x22,0x14,0x08,0x00,0x00,0x00},
1996 {0x00,0x02,0x01,0x51,0x09,0x06,0x00,0x00},
1997 {0x00,0x32,0x49,0x79,0x41,0x3E,0x00,0x00},
1998 {0x00,0x7E,0x09,0x09,0x09,0x7E,0x00,0x00},
1999 {0x00,0x7F,0x49,0x49,0x49,0x36,0x00,0x00},
2000 {0x00,0x3E,0x41,0x41,0x41,0x22,0x00,0x00},
2001 {0x00,0x7F,0x41,0x41,0x22,0x1C,0x00,0x00},
2002 {0x00,0x7F,0x49,0x49,0x49,0x41,0x00,0x00},
2003 {0x00,0x7F,0x09,0x09,0x09,0x01,0x00,0x00},
2004 {0x00,0x3E,0x41,0x41,0x51,0x72,0x00,0x00},
2005 {0x00,0x7F,0x08,0x08,0x08,0x7F,0x00,0x00},
2006 {0x00,0x41,0x7F,0x41,0x00,0x00,0x00,0x00},
2007 {0x00,0x20,0x40,0x41,0x3F,0x01,0x00,0x00},
2008 {0x00,0x7F,0x08,0x14,0x22,0x41,0x00,0x00},
2009 {0x00,0x7F,0x40,0x40,0x40,0x40,0x00,0x00},
2010 {0x00,0x7F,0x02,0x0C,0x02,0x7F,0x00,0x00},
2011 {0x00,0x7F,0x04,0x08,0x10,0x7F,0x00,0x00},
2012 {0x00,0x3E,0x41,0x41,0x41,0x3E,0x00,0x00},
2013 {0x00,0x7F,0x09,0x09,0x09,0x06,0x00,0x00},
2014 {0x00,0x3E,0x41,0x51,0x21,0x5E,0x00,0x00},
2015 {0x00,0x7F,0x09,0x19,0x29,0x46,0x00,0x00},
2016 {0x00,0x26,0x49,0x49,0x49,0x32,0x00,0x00},
2017 {0x00,0x01,0x01,0x7F,0x01,0x01,0x00,0x00},
2018 {0x00,0x3F,0x40,0x40,0x40,0x3F,0x00,0x00},
2019 {0x00,0x1F,0x20,0x40,0x20,0x1F,0x00,0x00},
2020 {0x00,0x3F,0x40,0x38,0x40,0x3F,0x00,0x00},
2021 {0x00,0x63,0x14,0x08,0x14,0x63,0x00,0x00},
2022 {0x00,0x03,0x04,0x78,0x04,0x03,0x00,0x00},
2023 {0x00,0x61,0x51,0x49,0x45,0x43,0x00,0x00},
2024 {0x00,0x7F,0x41,0x41,0x00,0x00,0x00,0x00},
2025 {0x00,0x02,0x04,0x08,0x10,0x20,0x00,0x00},
2026 {0x00,0x41,0x41,0x7F,0x00,0x00,0x00,0x00},
2027 {0x00,0x04,0x02,0x01,0x02,0x04,0x00,0x00},
2028 {0x00,0x80,0x80,0x80,0x80,0x80,0x00,0x00},
2029 {0x00,0x01,0x02,0x04,0x00,0x00,0x00,0x00},
2030 {0x00,0x20,0x54,0x54,0x54,0x78,0x00,0x00},
2031 {0x00,0x7F,0x48,0x44,0x44,0x38,0x00,0x00},
2032 {0x00,0x38,0x44,0x44,0x28,0x00,0x00,0x00},
2033 {0x00,0x38,0x44,0x44,0x48,0x7F,0x00,0x00},
2034 {0x00,0x38,0x54,0x54,0x54,0x18,0x00,0x00},
2035 {0x00,0x08,0x7E,0x09,0x02,0x00,0x00,0x00},
2036 {0x00,0x18,0xA4,0xA4,0xA4,0x7C,0x00,0x00},
2037 {0x00,0x7F,0x08,0x04,0x04,0x78,0x00,0x00},
2038 {0x00,0x00,0x7D,0x00,0x00,0x00,0x00,0x00},
2039 {0x00,0x80,0x84,0x7D,0x00,0x00,0x00,0x00},
2040 {0x00,0x7F,0x10,0x28,0x44,0x00,0x00,0x00},
2041 {0x00,0x41,0x7F,0x40,0x00,0x00,0x00,0x00},
2042 {0x00,0x7C,0x04,0x18,0x04,0x78,0x00,0x00},
2043 {0x00,0x7C,0x08,0x04,0x7C,0x00,0x00,0x00},
2044 {0x00,0x38,0x44,0x44,0x38,0x00,0x00,0x00},
2045 {0x00,0xFC,0x24,0x24,0x18,0x00,0x00,0x00},
2046 {0x00,0x18,0x24,0x24,0xFC,0x00,0x00,0x00},
2047 {0x00,0x00,0x7C,0x08,0x04,0x00,0x00,0x00},
2048 {0x00,0x48,0x54,0x54,0x24,0x00,0x00,0x00},
2049 {0x00,0x04,0x7F,0x44,0x00,0x00,0x00,0x00},
2050 {0x00,0x3C,0x40,0x40,0x7C,0x00,0x00,0x00},
2051 {0x00,0x1C,0x20,0x40,0x20,0x1C,0x00,0x00},
2052 {0x00,0x3C,0x40,0x30,0x40,0x3C,0x00,0x00},
2053 {0x00,0x44,0x28,0x10,0x28,0x44,0x00,0x00},
2054 {0x00,0x1C,0xA0,0xA0,0x7C,0x00,0x00,0x00},
2055 {0x00,0x44,0x64,0x54,0x4C,0x44,0x00,0x00},
2056 {0x00,0x08,0x36,0x41,0x00,0x00,0x00,0x00},
2057 {0x00,0x00,0x7F,0x00,0x00,0x00,0x00,0x00},
2058 {0x00,0x41,0x36,0x08,0x00,0x00,0x00,0x00},
2059 {0x00,0x02,0x01,0x01,0x02,0x01,0x00,0x00},
2060 {0x00,0x02,0x05,0x05,0x02,0x00,0x00,0x00}
2065 #define LCD_COMMAND_MODE 0x80 2067 #define LCD_DATA_MODE 0x40 2069 #define LCD_COMMAND_DISPLAY_OFF 0xAE 2071 #define LCD_COMMAND_DISPLAY_ON 0xAF 2073 #define LCD_COMMAND_BLACK_BACKGROUND 0xA6 2075 #define LCD_COMMAND_WHITE_BACKGROUND 0xA7 2077 #define LCD_COMMAND_SET_BRIGHTNESS 0x81 2079 #define LCD_PAGE_ADDRESSING 0x02 2081 #define LCD_HORIZONTAL_ADDRESSING 0x00 2084 #define LCD_COMMAND_CHARGE_PUMP_SETTING 0x8d 2086 #define LCD_COMMAND_CHARGE_PUMP_ENABLE 0x14 2089 #define LCD_WIDTH 128 2093 #define LCD_HEIGHT 64 2097 #if EBOARD_NANO == 0 2106 inline bool clear(
void);
2108 inline void print(
const char* data);
2110 inline void print(
int data);
2120 inline bool reset(
void);
2123 inline bool init(
void);
2125 inline void drawBitmap(
const unsigned char *bitmap, byte posX, byte posY, byte hiX, byte hiY);
2129 inline bool setCursor(byte posX = 0x0, byte posY = 0x0);
2152 #if EBOARD_NANO == 0x0 2167 return this->
init();
2171 for(byte i = 0; i < 8; i++){
2174 for (byte j = 0; j < 128; j++)
2194 if(data[i] < 32 || data[i] > 127){ i++;
continue;}
2195 for (byte j = 0; j < 8; j++){
2202 char buffer[11] =
"";
2203 itoa(data,buffer,10);
2204 this->
print(line,col,buffer);
2213 return this->
clear();
2229 return this->
clear();
2231 inline void LCD::drawBitmap(
const unsigned char *bitmap, byte posX, byte posY, byte hiX, byte hiY){
2235 for(
int i = 0x0; i < (hiX * 8 * hiY); i++){
2236 this->
s1Dat(pgm_read_byte(&bitmap[i]));
2237 if(++col == (hiX * 8)) {
2250 this->
s2Cmd((0x00 + (8 *posX & 0x0F)),(0x10 + ((8 * posX >> 4) & 0x0F)));
2251 this->
pX = posX; this->
pY = posY;
2252 return this->
s1Cmd(0xB0 + posY);
2256 this->
s2Cmd(0x81,val);
2284 #if EBOARD_NEO > 0x0 2289 #define EBOARD_NEO_RGB ((0 << 6) | (0 << 4) | (1 << 2) | (2)) 2291 #define EBOARD_NEO_RBG ((0 << 6) | (0 << 4) | (2 << 2) | (1)) 2293 #define EBOARD_NEO_GRB ((1 << 6) | (1 << 4) | (0 << 2) | (2)) 2295 #define EBOARD_NEO_GBR ((2 << 6) | (2 << 4) | (0 << 2) | (1)) 2297 #define EBOARD_NEO_BRG ((1 << 6) | (1 << 4) | (2 << 2) | (0)) 2299 #define EBOARD_NEO_BGR ((2 << 6) | (2 << 4) | (1 << 2) | (0)) 2303 #define EBOARD_NEO_WRGB ((0 << 6) | (1 << 4) | (2 << 2) | (3)) 2305 #define EBOARD_NEO_WRBG ((0 << 6) | (1 << 4) | (3 << 2) | (2)) 2307 #define EBOARD_NEO_WGRB ((0 << 6) | (2 << 4) | (1 << 2) | (3)) 2309 #define EBOARD_NEO_WGBR ((0 << 6) | (3 << 4) | (1 << 2) | (2)) 2311 #define EBOARD_NEO_WBRG ((0 << 6) | (2 << 4) | (3 << 2) | (1)) 2313 #define EBOARD_NEO_WBGR ((0 << 6) | (3 << 4) | (2 << 2) | (1)) 2315 #define EBOARD_NEO_RWGB ((1 << 6) | (0 << 4) | (2 << 2) | (3)) 2317 #define EBOARD_NEO_RWBG ((1 << 6) | (0 << 4) | (3 << 2) | (2)) 2319 #define EBOARD_NEO_RGWB ((2 << 6) | (0 << 4) | (1 << 2) | (3)) 2321 #define EBOARD_NEO_RGBW ((3 << 6) | (0 << 4) | (1 << 2) | (2)) 2323 #define EBOARD_NEO_RBWG ((2 << 6) | (0 << 4) | (3 << 2) | (1)) 2325 #define EBOARD_NEO_RBGW ((3 << 6) | (0 << 4) | (2 << 2) | (1)) 2327 #define EBOARD_NEO_GWRB ((1 << 6) | (2 << 4) | (0 << 2) | (3)) 2329 #define EBOARD_NEO_GWBR ((1 << 6) | (3 << 4) | (0 << 2) | (2)) 2331 #define EBOARD_NEO_GRWB ((2 << 6) | (1 << 4) | (0 << 2) | (3)) 2333 #define EBOARD_NEO_GRBW ((3 << 6) | (1 << 4) | (0 << 2) | (2)) 2335 #define EBOARD_NEO_GBWR ((2 << 6) | (3 << 4) | (0 << 2) | (1)) 2337 #define EBOARD_NEO_GBRW ((3 << 6) | (2 << 4) | (0 << 2) | (1)) 2339 #define EBOARD_NEO_BWRG ((1 << 6) | (2 << 4) | (3 << 2) | (0)) 2341 #define EBOARD_NEO_BWGR ((1 << 6) | (3 << 4) | (2 << 2) | (0)) 2343 #define EBOARD_NEO_BRWG ((2 << 6) | (1 << 4) | (3 << 2) | (0)) 2345 #define EBOARD_NEO_BRGW ((3 << 6) | (1 << 4) | (2 << 2) | (0)) 2347 #define EBOARD_NEO_BGWR ((2 << 6) | (3 << 4) | (1 << 2) | (0)) 2349 #define EBOARD_NEO_BGRW ((3 << 6) | (2 << 4) | (1 << 2) | (0)) 2351 #define EBOARD_NEO_800KHZ 0x0000 2353 #define EBOARD_NEO_400KHZ 0x0100 2370 void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);
2372 void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w);
2388 uint8_t
sine8(uint8_t x)
const;
2390 uint8_t
gamma8(uint8_t x)
const;
2392 inline int8_t
getPin(
void);
2396 static inline uint32_t
Color(uint8_t r, uint8_t g, uint8_t b);
2398 static inline uint32_t
Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w);
2422 #ifdef __AVR__ //not needed (rem?) 2424 volatile uint8_t *
port;
2431 begun(false), brightness(0),
pixels(NULL), endTime(0) {
2439 begun(false), numLEDs(0), numBytes(0), pin(-1), brightness(0),
pixels(NULL),
2441 {aOffset[0]=1;aOffset[1]=0;aOffset[2]=2;aOffset[3]=1;}
2444 if(
pin >= 0) pinMode(
pin, INPUT);
2448 pinMode(
pin, OUTPUT);
2449 digitalWrite(
pin, LOW);
2475 #if defined(ESP8266) 2477 extern "C" void ICACHE_RAM_ATTR espShow(
2478 uint8_t pin, uint8_t *
pixels, uint32_t numBytes, uint8_t type);
2479 #elif defined(ESP32) 2480 extern "C" void espShow(
2481 uint8_t pin, uint8_t *
pixels, uint32_t numBytes, uint8_t type);
2495 #if (F_CPU >= 7400000UL) && (F_CPU <= 9500000UL) 2497 volatile uint8_t n1, n2 = 0;
2499 #if defined(PORTB) || defined(PORTC) || defined(PORTF) 2500 if(
port == &PORTD) {
2505 if(b & 0x80) n1 = hi;
2509 "out %[port] , %[hi]" "\n\t" 2510 "mov %[n2] , %[lo]" "\n\t" 2511 "out %[port] , %[n1]" "\n\t" 2513 "sbrc %[byte] , 6" "\n\t" 2514 "mov %[n2] , %[hi]" "\n\t" 2515 "out %[port] , %[lo]" "\n\t" 2518 "out %[port] , %[hi]" "\n\t" 2519 "mov %[n1] , %[lo]" "\n\t" 2520 "out %[port] , %[n2]" "\n\t" 2522 "sbrc %[byte] , 5" "\n\t" 2523 "mov %[n1] , %[hi]" "\n\t" 2524 "out %[port] , %[lo]" "\n\t" 2527 "out %[port] , %[hi]" "\n\t" 2528 "mov %[n2] , %[lo]" "\n\t" 2529 "out %[port] , %[n1]" "\n\t" 2531 "sbrc %[byte] , 4" "\n\t" 2532 "mov %[n2] , %[hi]" "\n\t" 2533 "out %[port] , %[lo]" "\n\t" 2536 "out %[port] , %[hi]" "\n\t" 2537 "mov %[n1] , %[lo]" "\n\t" 2538 "out %[port] , %[n2]" "\n\t" 2540 "sbrc %[byte] , 3" "\n\t" 2541 "mov %[n1] , %[hi]" "\n\t" 2542 "out %[port] , %[lo]" "\n\t" 2545 "out %[port] , %[hi]" "\n\t" 2546 "mov %[n2] , %[lo]" "\n\t" 2547 "out %[port] , %[n1]" "\n\t" 2549 "sbrc %[byte] , 2" "\n\t" 2550 "mov %[n2] , %[hi]" "\n\t" 2551 "out %[port] , %[lo]" "\n\t" 2554 "out %[port] , %[hi]" "\n\t" 2555 "mov %[n1] , %[lo]" "\n\t" 2556 "out %[port] , %[n2]" "\n\t" 2558 "sbrc %[byte] , 1" "\n\t" 2559 "mov %[n1] , %[hi]" "\n\t" 2560 "out %[port] , %[lo]" "\n\t" 2563 "out %[port] , %[hi]" "\n\t" 2564 "mov %[n2] , %[lo]" "\n\t" 2565 "out %[port] , %[n1]" "\n\t" 2567 "sbrc %[byte] , 0" "\n\t" 2568 "mov %[n2] , %[hi]" "\n\t" 2569 "out %[port] , %[lo]" "\n\t" 2570 "sbiw %[count], 1" "\n\t" 2572 "out %[port] , %[hi]" "\n\t" 2573 "mov %[n1] , %[lo]" "\n\t" 2574 "out %[port] , %[n2]" "\n\t" 2575 "ld %[byte] , %a[ptr]+" "\n\t" 2576 "sbrc %[byte] , 7" "\n\t" 2577 "mov %[n1] , %[hi]" "\n\t" 2578 "out %[port] , %[lo]" "\n\t" 2584 : [
port]
"I" (_SFR_IO_ADDR(PORTD)),
2588 #if defined(PORTB) || defined(PORTC) || defined(PORTF) 2593 #if defined(PORTD) || defined(PORTC) || defined(PORTF) 2594 if(
port == &PORTB) {
2595 #endif // defined(PORTD/C/F) 2599 if(b & 0x80) n1 = hi;
2602 "out %[port] , %[hi]" "\n\t" 2603 "mov %[n2] , %[lo]" "\n\t" 2604 "out %[port] , %[n1]" "\n\t" 2606 "sbrc %[byte] , 6" "\n\t" 2607 "mov %[n2] , %[hi]" "\n\t" 2608 "out %[port] , %[lo]" "\n\t" 2610 "out %[port] , %[hi]" "\n\t" 2611 "mov %[n1] , %[lo]" "\n\t" 2612 "out %[port] , %[n2]" "\n\t" 2614 "sbrc %[byte] , 5" "\n\t" 2615 "mov %[n1] , %[hi]" "\n\t" 2616 "out %[port] , %[lo]" "\n\t" 2618 "out %[port] , %[hi]" "\n\t" 2619 "mov %[n2] , %[lo]" "\n\t" 2620 "out %[port] , %[n1]" "\n\t" 2622 "sbrc %[byte] , 4" "\n\t" 2623 "mov %[n2] , %[hi]" "\n\t" 2624 "out %[port] , %[lo]" "\n\t" 2626 "out %[port] , %[hi]" "\n\t" 2627 "mov %[n1] , %[lo]" "\n\t" 2628 "out %[port] , %[n2]" "\n\t" 2630 "sbrc %[byte] , 3" "\n\t" 2631 "mov %[n1] , %[hi]" "\n\t" 2632 "out %[port] , %[lo]" "\n\t" 2634 "out %[port] , %[hi]" "\n\t" 2635 "mov %[n2] , %[lo]" "\n\t" 2636 "out %[port] , %[n1]" "\n\t" 2638 "sbrc %[byte] , 2" "\n\t" 2639 "mov %[n2] , %[hi]" "\n\t" 2640 "out %[port] , %[lo]" "\n\t" 2642 "out %[port] , %[hi]" "\n\t" 2643 "mov %[n1] , %[lo]" "\n\t" 2644 "out %[port] , %[n2]" "\n\t" 2646 "sbrc %[byte] , 1" "\n\t" 2647 "mov %[n1] , %[hi]" "\n\t" 2648 "out %[port] , %[lo]" "\n\t" 2650 "out %[port] , %[hi]" "\n\t" 2651 "mov %[n2] , %[lo]" "\n\t" 2652 "out %[port] , %[n1]" "\n\t" 2654 "sbrc %[byte] , 0" "\n\t" 2655 "mov %[n2] , %[hi]" "\n\t" 2656 "out %[port] , %[lo]" "\n\t" 2657 "sbiw %[count], 1" "\n\t" 2658 "out %[port] , %[hi]" "\n\t" 2659 "mov %[n1] , %[lo]" "\n\t" 2660 "out %[port] , %[n2]" "\n\t" 2661 "ld %[byte] , %a[ptr]+" "\n\t" 2662 "sbrc %[byte] , 7" "\n\t" 2663 "mov %[n1] , %[hi]" "\n\t" 2664 "out %[port] , %[lo]" "\n\t" 2666 : [byte]
"+r" (b), [n1]
"+r" (n1), [n2]
"+r" (n2), [count]
"+w" (i)
2667 : [
port]
"I" (_SFR_IO_ADDR(PORTB)), [ptr]
"e" (ptr), [hi]
"r" (hi),
2669 #if defined(PORTD) || defined(PORTC) || defined(PORTF) 2672 #if defined(PORTC) || defined(PORTF) 2677 #if defined(PORTD) || defined(PORTB) || defined(PORTF) 2678 if(
port == &PORTC) {
2683 if(b & 0x80) n1 = hi;
2686 "out %[port] , %[hi]" "\n\t" 2687 "mov %[n2] , %[lo]" "\n\t" 2688 "out %[port] , %[n1]" "\n\t" 2690 "sbrc %[byte] , 6" "\n\t" 2691 "mov %[n2] , %[hi]" "\n\t" 2692 "out %[port] , %[lo]" "\n\t" 2694 "out %[port] , %[hi]" "\n\t" 2695 "mov %[n1] , %[lo]" "\n\t" 2696 "out %[port] , %[n2]" "\n\t" 2698 "sbrc %[byte] , 5" "\n\t" 2699 "mov %[n1] , %[hi]" "\n\t" 2700 "out %[port] , %[lo]" "\n\t" 2702 "out %[port] , %[hi]" "\n\t" 2703 "mov %[n2] , %[lo]" "\n\t" 2704 "out %[port] , %[n1]" "\n\t" 2706 "sbrc %[byte] , 4" "\n\t" 2707 "mov %[n2] , %[hi]" "\n\t" 2708 "out %[port] , %[lo]" "\n\t" 2710 "out %[port] , %[hi]" "\n\t" 2711 "mov %[n1] , %[lo]" "\n\t" 2712 "out %[port] , %[n2]" "\n\t" 2714 "sbrc %[byte] , 3" "\n\t" 2715 "mov %[n1] , %[hi]" "\n\t" 2716 "out %[port] , %[lo]" "\n\t" 2718 "out %[port] , %[hi]" "\n\t" 2719 "mov %[n2] , %[lo]" "\n\t" 2720 "out %[port] , %[n1]" "\n\t" 2722 "sbrc %[byte] , 2" "\n\t" 2723 "mov %[n2] , %[hi]" "\n\t" 2724 "out %[port] , %[lo]" "\n\t" 2726 "out %[port] , %[hi]" "\n\t" 2727 "mov %[n1] , %[lo]" "\n\t" 2728 "out %[port] , %[n2]" "\n\t" 2730 "sbrc %[byte] , 1" "\n\t" 2731 "mov %[n1] , %[hi]" "\n\t" 2732 "out %[port] , %[lo]" "\n\t" 2734 "out %[port] , %[hi]" "\n\t" 2735 "mov %[n2] , %[lo]" "\n\t" 2736 "out %[port] , %[n1]" "\n\t" 2738 "sbrc %[byte] , 0" "\n\t" 2739 "mov %[n2] , %[hi]" "\n\t" 2740 "out %[port] , %[lo]" "\n\t" 2741 "sbiw %[count], 1" "\n\t" 2742 "out %[port] , %[hi]" "\n\t" 2743 "mov %[n1] , %[lo]" "\n\t" 2744 "out %[port] , %[n2]" "\n\t" 2745 "ld %[byte] , %a[ptr]+" "\n\t" 2746 "sbrc %[byte] , 7" "\n\t" 2747 "mov %[n1] , %[hi]" "\n\t" 2748 "out %[port] , %[lo]" "\n\t" 2750 : [byte]
"+r" (b), [n1]
"+r" (n1), [n2]
"+r" (n2), [count]
"+w" (i)
2751 : [
port]
"I" (_SFR_IO_ADDR(PORTC)), [ptr]
"e" (ptr), [hi]
"r" (hi),
2753 #if defined(PORTD) || defined(PORTB) || defined(PORTF) 2761 #if defined(PORTD) || defined(PORTB) || defined(PORTC) 2762 if(
port == &PORTF) {
2763 #endif // defined(PORTD/B/C) 2767 if(b & 0x80) n1 = hi;
2770 "out %[port] , %[hi]" "\n\t" 2771 "mov %[n2] , %[lo]" "\n\t" 2772 "out %[port] , %[n1]" "\n\t" 2774 "sbrc %[byte] , 6" "\n\t" 2775 "mov %[n2] , %[hi]" "\n\t" 2776 "out %[port] , %[lo]" "\n\t" 2778 "out %[port] , %[hi]" "\n\t" 2779 "mov %[n1] , %[lo]" "\n\t" 2780 "out %[port] , %[n2]" "\n\t" 2782 "sbrc %[byte] , 5" "\n\t" 2783 "mov %[n1] , %[hi]" "\n\t" 2784 "out %[port] , %[lo]" "\n\t" 2786 "out %[port] , %[hi]" "\n\t" 2787 "mov %[n2] , %[lo]" "\n\t" 2788 "out %[port] , %[n1]" "\n\t" 2790 "sbrc %[byte] , 4" "\n\t" 2791 "mov %[n2] , %[hi]" "\n\t" 2792 "out %[port] , %[lo]" "\n\t" 2794 "out %[port] , %[hi]" "\n\t" 2795 "mov %[n1] , %[lo]" "\n\t" 2796 "out %[port] , %[n2]" "\n\t" 2798 "sbrc %[byte] , 3" "\n\t" 2799 "mov %[n1] , %[hi]" "\n\t" 2800 "out %[port] , %[lo]" "\n\t" 2802 "out %[port] , %[hi]" "\n\t" 2803 "mov %[n2] , %[lo]" "\n\t" 2804 "out %[port] , %[n1]" "\n\t" 2806 "sbrc %[byte] , 2" "\n\t" 2807 "mov %[n2] , %[hi]" "\n\t" 2808 "out %[port] , %[lo]" "\n\t" 2810 "out %[port] , %[hi]" "\n\t" 2811 "mov %[n1] , %[lo]" "\n\t" 2812 "out %[port] , %[n2]" "\n\t" 2814 "sbrc %[byte] , 1" "\n\t" 2815 "mov %[n1] , %[hi]" "\n\t" 2816 "out %[port] , %[lo]" "\n\t" 2818 "out %[port] , %[hi]" "\n\t" 2819 "mov %[n2] , %[lo]" "\n\t" 2820 "out %[port] , %[n1]" "\n\t" 2822 "sbrc %[byte] , 0" "\n\t" 2823 "mov %[n2] , %[hi]" "\n\t" 2824 "out %[port] , %[lo]" "\n\t" 2825 "sbiw %[count], 1" "\n\t" 2826 "out %[port] , %[hi]" "\n\t" 2827 "mov %[n1] , %[lo]" "\n\t" 2828 "out %[port] , %[n2]" "\n\t" 2829 "ld %[byte] , %a[ptr]+" "\n\t" 2830 "sbrc %[byte] , 7" "\n\t" 2831 "mov %[n1] , %[hi]" "\n\t" 2832 "out %[port] , %[lo]" "\n\t" 2834 : [byte]
"+r" (b), [n1]
"+r" (n1), [n2]
"+r" (n2), [count]
"+w" (i)
2835 : [
port]
"I" (_SFR_IO_ADDR(PORTF)), [ptr]
"e" (ptr), [hi]
"r" (hi),
2837 #if defined(PORTD) || defined(PORTB) || defined(PORTC) 2839 #endif // defined(PORTD/B/C) 2840 #endif // defined(PORTF) 2842 volatile uint8_t next, bit;
2849 "st %a[port], %[hi]" "\n\t" 2850 "sbrc %[byte] , 7" "\n\t" 2851 "mov %[next], %[hi]" "\n\t" 2852 "st %a[port], %[next]" "\n\t" 2853 "mov %[next] , %[lo]" "\n\t" 2855 "breq nextbyte20" "\n\t" 2856 "rol %[byte]" "\n\t" 2857 "st %a[port], %[lo]" "\n\t" 2861 "rjmp head20" "\n\t" 2862 "nextbyte20:" "\n\t" 2863 "st %a[port], %[lo]" "\n\t" 2865 "ldi %[bit] , 8" "\n\t" 2866 "ld %[byte] , %a[ptr]+" "\n\t" 2867 "sbiw %[count], 1" "\n\t" 2878 #elif (F_CPU >= 11100000UL) && (F_CPU <= 14300000UL) 2880 volatile uint8_t next;
2883 #if defined(PORTB) || defined(PORTC) || defined(PORTF) 2884 if(
port == &PORTD) {
2889 if(b & 0x80) next = hi;
2892 "out %[port], %[hi]" "\n\t" 2893 "rcall bitTimeD" "\n\t" 2894 "out %[port], %[hi]" "\n\t" 2895 "rcall bitTimeD" "\n\t" 2896 "out %[port], %[hi]" "\n\t" 2897 "rcall bitTimeD" "\n\t" 2898 "out %[port], %[hi]" "\n\t" 2899 "rcall bitTimeD" "\n\t" 2900 "out %[port], %[hi]" "\n\t" 2901 "rcall bitTimeD" "\n\t" 2902 "out %[port], %[hi]" "\n\t" 2903 "rcall bitTimeD" "\n\t" 2904 "out %[port], %[hi]" "\n\t" 2905 "rcall bitTimeD" "\n\t" 2907 "out %[port] , %[hi]" "\n\t" 2909 "ld %[byte] , %a[ptr]+" "\n\t" 2910 "out %[port] , %[next]" "\n\t" 2911 "mov %[next] , %[lo]" "\n\t" 2912 "sbrc %[byte] , 7" "\n\t" 2913 "mov %[next] , %[hi]" "\n\t" 2915 "out %[port] , %[lo]" "\n\t" 2916 "sbiw %[count], 1" "\n\t" 2920 "out %[port], %[next]" "\n\t" 2921 "mov %[next], %[lo]" "\n\t" 2922 "rol %[byte]" "\n\t" 2923 "sbrc %[byte], 7" "\n\t" 2924 "mov %[next], %[hi]" "\n\t" 2926 "out %[port], %[lo]" "\n\t" 2932 : [
port]
"I" (_SFR_IO_ADDR(PORTD)),
2936 #if defined(PORTB) || defined(PORTC) || defined(PORTF) 2941 #if defined(PORTD) || defined(PORTC) || defined(PORTF) 2942 if(
port == &PORTB) {
2947 if(b & 0x80) next = hi;
2950 "out %[port], %[hi]" "\n\t" 2951 "rcall bitTimeB" "\n\t" 2952 "out %[port], %[hi]" "\n\t" 2953 "rcall bitTimeB" "\n\t" 2954 "out %[port], %[hi]" "\n\t" 2955 "rcall bitTimeB" "\n\t" 2956 "out %[port], %[hi]" "\n\t" 2957 "rcall bitTimeB" "\n\t" 2958 "out %[port], %[hi]" "\n\t" 2959 "rcall bitTimeB" "\n\t" 2960 "out %[port], %[hi]" "\n\t" 2961 "rcall bitTimeB" "\n\t" 2962 "out %[port], %[hi]" "\n\t" 2963 "rcall bitTimeB" "\n\t" 2964 "out %[port] , %[hi]" "\n\t" 2966 "ld %[byte] , %a[ptr]+" "\n\t" 2967 "out %[port] , %[next]" "\n\t" 2968 "mov %[next] , %[lo]" "\n\t" 2969 "sbrc %[byte] , 7" "\n\t" 2970 "mov %[next] , %[hi]" "\n\t" 2972 "out %[port] , %[lo]" "\n\t" 2973 "sbiw %[count], 1" "\n\t" 2977 "out %[port], %[next]" "\n\t" 2978 "mov %[next], %[lo]" "\n\t" 2979 "rol %[byte]" "\n\t" 2980 "sbrc %[byte], 7" "\n\t" 2981 "mov %[next], %[hi]" "\n\t" 2983 "out %[port], %[lo]" "\n\t" 2986 : [byte]
"+r" (b), [next]
"+r" (next), [count]
"+w" (i)
2987 : [
port]
"I" (_SFR_IO_ADDR(PORTB)), [ptr]
"e" (ptr), [hi]
"r" (hi),
2989 #if defined(PORTD) || defined(PORTC) || defined(PORTF) 2992 #if defined(PORTC) || defined(PORTF) 2997 #if defined(PORTD) || defined(PORTB) || defined(PORTF) 2998 if(
port == &PORTC) {
3003 if(b & 0x80) next = hi;
3006 "out %[port], %[hi]" "\n\t" 3007 "rcall bitTimeC" "\n\t" 3008 "out %[port], %[hi]" "\n\t" 3009 "rcall bitTimeC" "\n\t" 3010 "out %[port], %[hi]" "\n\t" 3011 "rcall bitTimeC" "\n\t" 3012 "out %[port], %[hi]" "\n\t" 3013 "rcall bitTimeC" "\n\t" 3014 "out %[port], %[hi]" "\n\t" 3015 "rcall bitTimeC" "\n\t" 3016 "out %[port], %[hi]" "\n\t" 3017 "rcall bitTimeC" "\n\t" 3018 "out %[port], %[hi]" "\n\t" 3019 "rcall bitTimeC" "\n\t" 3020 "out %[port] , %[hi]" "\n\t" 3022 "ld %[byte] , %a[ptr]+" "\n\t" 3023 "out %[port] , %[next]" "\n\t" 3024 "mov %[next] , %[lo]" "\n\t" 3025 "sbrc %[byte] , 7" "\n\t" 3026 "mov %[next] , %[hi]" "\n\t" 3028 "out %[port] , %[lo]" "\n\t" 3029 "sbiw %[count], 1" "\n\t" 3033 "out %[port], %[next]" "\n\t" 3034 "mov %[next], %[lo]" "\n\t" 3035 "rol %[byte]" "\n\t" 3036 "sbrc %[byte], 7" "\n\t" 3037 "mov %[next], %[hi]" "\n\t" 3039 "out %[port], %[lo]" "\n\t" 3042 : [byte]
"+r" (b), [next]
"+r" (next), [count]
"+w" (i)
3043 : [
port]
"I" (_SFR_IO_ADDR(PORTC)), [ptr]
"e" (ptr), [hi]
"r" (hi),
3045 #if defined(PORTD) || defined(PORTB) || defined(PORTF) 3053 #if defined(PORTD) || defined(PORTB) || defined(PORTC) 3054 if(
port == &PORTF) {
3059 if(b & 0x80) next = hi;
3062 "out %[port], %[hi]" "\n\t" 3063 "rcall bitTimeC" "\n\t" 3064 "out %[port], %[hi]" "\n\t" 3065 "rcall bitTimeC" "\n\t" 3066 "out %[port], %[hi]" "\n\t" 3067 "rcall bitTimeC" "\n\t" 3068 "out %[port], %[hi]" "\n\t" 3069 "rcall bitTimeC" "\n\t" 3070 "out %[port], %[hi]" "\n\t" 3071 "rcall bitTimeC" "\n\t" 3072 "out %[port], %[hi]" "\n\t" 3073 "rcall bitTimeC" "\n\t" 3074 "out %[port], %[hi]" "\n\t" 3075 "rcall bitTimeC" "\n\t" 3076 "out %[port] , %[hi]" "\n\t" 3078 "ld %[byte] , %a[ptr]+" "\n\t" 3079 "out %[port] , %[next]" "\n\t" 3080 "mov %[next] , %[lo]" "\n\t" 3081 "sbrc %[byte] , 7" "\n\t" 3082 "mov %[next] , %[hi]" "\n\t" 3084 "out %[port] , %[lo]" "\n\t" 3085 "sbiw %[count], 1" "\n\t" 3089 "out %[port], %[next]" "\n\t" 3090 "mov %[next], %[lo]" "\n\t" 3091 "rol %[byte]" "\n\t" 3092 "sbrc %[byte], 7" "\n\t" 3093 "mov %[next], %[hi]" "\n\t" 3095 "out %[port], %[lo]" "\n\t" 3098 : [byte]
"+r" (b), [next]
"+r" (next), [count]
"+w" (i)
3099 : [
port]
"I" (_SFR_IO_ADDR(PORTF)), [ptr]
"e" (ptr), [hi]
"r" (hi),
3101 #if defined(PORTD) || defined(PORTB) || defined(PORTC) 3106 volatile uint8_t next, bit;
3113 "st %a[port], %[hi]" "\n\t" 3114 "sbrc %[byte] , 7" "\n\t" 3115 "mov %[next], %[hi]" "\n\t" 3117 "st %a[port], %[next]" "\n\t" 3122 "st %a[port], %[lo]" "\n\t" 3125 "breq nextbyte30" "\n\t" 3126 "rol %[byte]" "\n\t" 3130 "rjmp head30" "\n\t" 3131 "nextbyte30:" "\n\t" 3133 "ldi %[bit] , 8" "\n\t" 3134 "ld %[byte] , %a[ptr]+" "\n\t" 3135 "sbiw %[count], 1" "\n\t" 3146 #elif (F_CPU >= 15400000UL) && (F_CPU <= 19000000L) 3148 volatile uint8_t next, bit;
3155 "st %a[port], %[hi]" "\n\t" 3156 "sbrc %[byte], 7" "\n\t" 3157 "mov %[next], %[hi]" "\n\t" 3159 "st %a[port], %[next]" "\n\t" 3160 "mov %[next] , %[lo]" "\n\t" 3161 "breq nextbyte20" "\n\t" 3162 "rol %[byte]" "\n\t" 3165 "st %a[port], %[lo]" "\n\t" 3168 "rjmp head20" "\n\t" 3169 "nextbyte20:" "\n\t" 3170 "ldi %[bit] , 8" "\n\t" 3171 "ld %[byte] , %a[ptr]+" "\n\t" 3172 "st %a[port], %[lo]" "\n\t" 3174 "sbiw %[count], 1" "\n\t" 3185 volatile uint8_t next, bit;
3192 "st %a[port], %[hi]" "\n\t" 3193 "sbrc %[byte] , 7" "\n\t" 3194 "mov %[next] , %[hi]" "\n\t" 3197 "st %a[port], %[next]" "\n\t" 3203 "st %a[port], %[lo]" "\n\t" 3205 "mov %[next] , %[lo]" "\n\t" 3207 "breq nextbyte40" "\n\t" 3208 "rol %[byte]" "\n\t" 3215 "rjmp head40" "\n\t" 3216 "nextbyte40:" "\n\t" 3217 "ldi %[bit] , 8" "\n\t" 3218 "ld %[byte] , %a[ptr]+" "\n\t" 3220 "st %a[port], %[lo]" "\n\t" 3222 "sbiw %[count], 1" "\n\t" 3234 #error "CPU SPEED NOT SUPPORTED" 3236 #elif defined(__arm__) 3237 #if defined(TEENSYDUINO) && defined(KINETISK) // Teensy 3.0, 3.1, 3.2, 3.5, 3.6 3238 #define CYCLES_800_T0H (F_CPU / 4000000) 3239 #define CYCLES_800_T1H (F_CPU / 1250000) 3240 #define CYCLES_800 (F_CPU / 800000) 3241 #define CYCLES_400_T0H (F_CPU / 2000000) 3242 #define CYCLES_400_T1H (F_CPU / 833333) 3243 #define CYCLES_400 (F_CPU / 400000) 3246 volatile uint8_t *
set = portSetRegister(
pin),
3247 *clr = portClearRegister(
pin);
3249 ARM_DEMCR |= ARM_DEMCR_TRCENA;
3250 ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;
3252 cyc = ARM_DWT_CYCCNT + CYCLES_800;
3255 for(mask = 0x80; mask; mask >>= 1) {
3256 while(ARM_DWT_CYCCNT - cyc < CYCLES_800);
3257 cyc = ARM_DWT_CYCCNT;
3260 while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T1H);
3262 while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T0H);
3267 while(ARM_DWT_CYCCNT - cyc < CYCLES_800);
3269 cyc = ARM_DWT_CYCCNT + CYCLES_400;
3272 for(mask = 0x80; mask; mask >>= 1) {
3273 while(ARM_DWT_CYCCNT - cyc < CYCLES_400);
3274 cyc = ARM_DWT_CYCCNT;
3277 while(ARM_DWT_CYCCNT - cyc < CYCLES_400_T1H);
3279 while(ARM_DWT_CYCCNT - cyc < CYCLES_400_T0H);
3284 while(ARM_DWT_CYCCNT - cyc < CYCLES_400);
3287 #error "Sorry, only 48 MHz is supported, please set Tools > CPU Speed to 48 MHz" 3289 #elif defined(ESP8266) || defined(ESP32) 3291 #elif defined(__ARDUINO_ARC__) 3293 #define NOPx7 { __builtin_arc_nop(); \ 3294 __builtin_arc_nop(); __builtin_arc_nop(); \ 3295 __builtin_arc_nop(); __builtin_arc_nop(); \ 3296 __builtin_arc_nop(); __builtin_arc_nop(); } 3297 PinDescription *pindesc = &g_APinDescription[
pin];
3299 register uint8_t *p =
pixels;
3300 register uint32_t currByte = (uint32_t) (*p);
3301 register uint32_t currBit = 0x80 & currByte;
3302 register uint32_t bitCounter = 0;
3303 register uint32_t first = 1;
3304 if (pindesc->ulGPIOType == SS_GPIO) {
3305 register uint32_t reg = pindesc->ulGPIOBase + SS_GPIO_SWPORTA_DR;
3306 uint32_t reg_val = __builtin_arc_lr((
volatile uint32_t)reg);
3307 register uint32_t reg_bit_high = reg_val | (1 << pindesc->ulGPIOId);
3308 register uint32_t reg_bit_low = reg_val & ~(1 << pindesc->ulGPIOId);
3316 __builtin_arc_sr(first ? reg_bit_low : reg_bit_high, (
volatile uint32_t)reg);
3323 __builtin_arc_nop();
3325 __builtin_arc_sr(reg_bit_low, (
volatile uint32_t)reg);
3328 if(bitCounter >= 8) {
3330 currByte = (uint32_t) (*++p);
3332 currBit = 0x80 & currByte;
3335 }
else if(pindesc->ulGPIOType == SOC_GPIO) {
3336 register uint32_t reg = pindesc->ulGPIOBase + SOC_GPIO_SWPORTA_DR;
3337 uint32_t reg_val = MMIO_REG_VAL(reg);
3338 register uint32_t reg_bit_high = reg_val | (1 << pindesc->ulGPIOId);
3339 register uint32_t reg_bit_low = reg_val & ~(1 << pindesc->ulGPIOId);
3346 MMIO_REG_VAL(reg) = first ? reg_bit_low : reg_bit_high;
3350 __builtin_arc_nop();
3355 MMIO_REG_VAL(reg) = reg_bit_low;
3358 if(bitCounter >= 8) {
3360 currByte = (uint32_t) (*++p);
3362 currBit = 0x80 & currByte;
3367 #error Architecture not supported 3377 digitalWrite(p, LOW);
3380 port = portOutputRegister(digitalPinToPort(p));
3381 pinMask = digitalPinToBitMask(p);
3385 uint16_t n, uint8_t r, uint8_t g, uint8_t b) {
3405 uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w) {
3428 r = (uint8_t)(c >> 16),
3429 g = (uint8_t)(c >> 8),
3440 uint8_t w = (uint8_t)(c >> 24);
3449 return ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
3451 uint32_t
NeoPixel::Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w) {
3452 return ((uint32_t)w << 24) | ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
3464 return ((uint32_t)p[
aOffset[0]] << 16) |
3465 ((uint32_t)p[
aOffset[1]] << 8) |
3476 return ((uint32_t)p[
aOffset[3]] << 24) |
3477 ((uint32_t)p[
aOffset[0]] << 16) |
3478 ((uint32_t)p[
aOffset[1]] << 8) |
3490 uint8_t newBrightness = b + 1;
3496 if(oldBrightness == 0) scale = 0;
3497 else if(b == 255) scale = 65535 / oldBrightness;
3498 else scale = (((uint16_t)newBrightness << 8) - 1) / oldBrightness;
3499 for(uint16_t i=0; i<
numBytes; i++) {
3501 *ptr++ = (c * scale) >> 8;
3512 static const uint8_t PROGMEM _sineTable[256] = {
3513 128,131,134,137,140,143,146,149,152,155,158,162,165,167,170,173,
3514 176,179,182,185,188,190,193,196,198,201,203,206,208,211,213,215,
3515 218,220,222,224,226,228,230,232,234,235,237,238,240,241,243,244,
3516 245,246,248,249,250,250,251,252,253,253,254,254,254,255,255,255,
3517 255,255,255,255,254,254,254,253,253,252,251,250,250,249,248,246,
3518 245,244,243,241,240,238,237,235,234,232,230,228,226,224,222,220,
3519 218,215,213,211,208,206,203,201,198,196,193,190,188,185,182,179,
3520 176,173,170,167,165,162,158,155,152,149,146,143,140,137,134,131,
3521 128,124,121,118,115,112,109,106,103,100, 97, 93, 90, 88, 85, 82,
3522 79, 76, 73, 70, 67, 65, 62, 59, 57, 54, 52, 49, 47, 44, 42, 40,
3523 37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14, 12, 11,
3524 10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0,
3525 0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9,
3526 10, 11, 12, 14, 15, 17, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35,
3527 37, 40, 42, 44, 47, 49, 52, 54, 57, 59, 62, 65, 67, 70, 73, 76,
3528 79, 82, 85, 88, 90, 93, 97,100,103,106,109,112,115,118,121,124};
3529 static const uint8_t PROGMEM _gammaTable[256] = {
3530 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3531 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
3532 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,
3533 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7,
3534 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12,
3535 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20,
3536 20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29,
3537 30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 38, 38, 39, 40, 41, 42,
3538 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3539 58, 59, 60, 61, 62, 63, 64, 65, 66, 68, 69, 70, 71, 72, 73, 75,
3540 76, 77, 78, 80, 81, 82, 84, 85, 86, 88, 89, 90, 92, 93, 94, 96,
3541 97, 99,100,102,103,105,106,108,109,111,112,114,115,117,119,120,
3542 122,124,125,127,129,130,132,134,136,137,139,141,143,145,146,148,
3543 150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,
3544 182,184,186,188,191,193,195,197,199,202,204,206,209,211,213,215,
3545 218,220,223,225,227,230,232,235,237,240,242,245,247,250,252,255};
3547 return pgm_read_byte(&_sineTable[x]);
3550 return pgm_read_byte(&_gammaTable[x]);
3565 #if EBOARD_NANO > 0x0 || defined(DOC) 3567 #if EBOARD_GUESSPATH > 0x0 3572 typedef enum { _timer1, _Nbr_16timers } timer16_Sequence_t;
3573 #define MIN_PULSE_WIDTH 544 // the shortest pulse sent to a servo 3574 #define MAX_PULSE_WIDTH 2400 // the longest pulse sent to a servo 3575 #define DEFAULT_PULSE_WIDTH 1500 // default pulse width when servo is attached 3576 #define REFRESH_INTERVAL 20000 // minumim time to refresh servos in microseconds 3577 #define SERVOS_PER_TIMER 12 // the maximum number of servos controlled by one timer 3578 #define MAX_SERVOS (_Nbr_16timers * SERVOS_PER_TIMER) 3579 #define INVALID_SERVO 255 // flag indicating an invalid servo index 3582 uint8_t isActive :1 ;
3586 volatile unsigned int ticks;
3591 uint8_t attach(
int pin);
3592 uint8_t attach(
int pin,
int min,
int max);
3594 void write(
int value);
3595 void writeMicroseconds(
int value);
3597 int readMicroseconds();
3598 inline bool attached();
3604 #define usToTicks(_us) (( clockCyclesPerMicrosecond()* _us) / 8) // converts microseconds to tick (assumes prescale of 8) // 12 Aug 2009 3605 #define ticksToUs(_ticks) (( (unsigned)_ticks * 8)/ clockCyclesPerMicrosecond() ) // converts from ticks back to microseconds 3606 #define TRIM_DURATION 2 // compensation ticks to trim adjust for digitalWrite delays // 12 August 2009 3608 static servo_t servos[MAX_SERVOS];
3609 static volatile int8_t Channel[_Nbr_16timers ];
3610 uint8_t ServoCount = 0;
3612 #define SERVO_INDEX_TO_TIMER(_servo_nbr) ((timer16_Sequence_t)(_servo_nbr / SERVOS_PER_TIMER)) // returns the timer controlling this servo 3613 #define SERVO_INDEX_TO_CHANNEL(_servo_nbr) (_servo_nbr % SERVOS_PER_TIMER) // returns the index of the servo on this timer 3614 #define SERVO_INDEX(_timer,_channel) ((_timer*SERVOS_PER_TIMER) + _channel) // macro to access servo index by timer and channel 3615 #define SERVO(_timer,_channel) (servos[SERVO_INDEX(_timer,_channel)]) // macro to access servo class by timer and channel 3616 #define SERVO_MIN() (MIN_PULSE_WIDTH - this->min * 4) // minimum value in uS for this servo 3617 #define SERVO_MAX() (MAX_PULSE_WIDTH - this->max * 4) // maximum value in uS for this servo 3618 static inline void handle_interrupts(timer16_Sequence_t timer,
volatile uint16_t *TCNTn,
volatile uint16_t* OCRnA)
3620 if( Channel[timer] < 0 )
3623 if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && SERVO(timer,Channel[timer]).Pin.isActive ==
true )
3624 digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,LOW);
3627 if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) {
3628 *OCRnA = *TCNTn + SERVO(timer,Channel[timer]).ticks;
3629 if(SERVO(timer,Channel[timer]).Pin.isActive ==
true)
3630 digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,HIGH);
3634 if( ((
unsigned)*TCNTn) + 4 < usToTicks(REFRESH_INTERVAL) )
3635 *OCRnA = (
unsigned int)usToTicks(REFRESH_INTERVAL);
3637 *OCRnA = *TCNTn + 4;
3638 Channel[timer] = -1;
3641 #ifndef WIRING // Wiring pre-defines signal handlers so don't define any if compiling for the Wiring platform 3643 #if defined(_useTimer1) 3644 SIGNAL (TIMER1_COMPA_vect)
3646 handle_interrupts(_timer1, &TCNT1, &OCR1A);
3649 #elif defined WIRING 3651 #if defined(_useTimer1) 3652 void Timer1Service()
3654 handle_interrupts(_timer1, &TCNT1, &OCR1A);
3658 static void initISR(timer16_Sequence_t timer) {
3659 if(timer == _timer1) {
3663 TIFR1 |= _BV(OCF1A);
3664 TIMSK1 |= _BV(OCIE1A) ;
3666 timerAttach(TIMER1OUTCOMPAREA_INT, Timer1Service);
3670 static void finISR(timer16_Sequence_t timer) {
3671 #if defined WIRING // Wiring 3672 if(timer == _timer1) {
3673 TIMSK &= ~_BV(OCIE1A) ;
3674 timerDetach(TIMER1OUTCOMPAREA_INT);
3676 else if(timer == _timer3) {
3677 ETIMSK &= ~_BV(OCIE3A);
3678 timerDetach(TIMER3OUTCOMPAREA_INT);
3685 static boolean isTimerActive(timer16_Sequence_t timer) {
3687 for(uint8_t channel=0; channel < SERVOS_PER_TIMER; channel++) {
3688 if(SERVO(timer,channel).Pin.isActive ==
true)
3694 if( ServoCount < MAX_SERVOS) {
3695 this->servoIndex = ServoCount++;
3696 servos[this->servoIndex].ticks = usToTicks(DEFAULT_PULSE_WIDTH);
3699 this->servoIndex = INVALID_SERVO ;
3701 uint8_t Servo::attach(
int pin) {
3702 return this->attach(pin, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
3704 uint8_t Servo::attach(
int pin,
int min,
int max) {
3705 if(this->servoIndex < MAX_SERVOS ) {
3706 pinMode( pin, OUTPUT) ;
3707 servos[this->servoIndex].Pin.nbr = pin;
3709 this->min = (MIN_PULSE_WIDTH - min)/4;
3710 this->max = (MAX_PULSE_WIDTH - max)/4;
3712 timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
3713 if(isTimerActive(timer) ==
false)
3715 servos[this->servoIndex].Pin.isActive =
true;
3717 return this->servoIndex ;
3719 void Servo::detach() {
3720 servos[this->servoIndex].Pin.isActive =
false;
3721 timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
3722 if(isTimerActive(timer) ==
false) {
3726 void Servo::write(
int value) {
3727 if(value < MIN_PULSE_WIDTH)
3729 if(value < 0) value = 0;
3730 if(value > 180) value = 180;
3731 value = map(value, 0, 180, SERVO_MIN(), SERVO_MAX());
3733 this->writeMicroseconds(value);
3735 void Servo::writeMicroseconds(
int value) {
3737 byte channel = this->servoIndex;
3738 if( (channel < MAX_SERVOS) )
3740 if( value < SERVO_MIN() )
3741 value = SERVO_MIN();
3742 else if( value > SERVO_MAX() )
3743 value = SERVO_MAX();
3744 value = value - TRIM_DURATION;
3745 value = usToTicks(value);
3746 uint8_t oldSREG = SREG;
3748 servos[channel].ticks = value;
3752 inline int Servo::read()
3754 return map( this->readMicroseconds()+1, SERVO_MIN(), SERVO_MAX(), 0, 180);
3756 int Servo::readMicroseconds() {
3757 unsigned int pulsewidth;
3758 if( this->servoIndex != INVALID_SERVO )
3759 pulsewidth = ticksToUs(servos[this->servoIndex].ticks) + TRIM_DURATION ;
3764 inline bool Servo::attached() {
3765 return servos[this->servoIndex].Pin.isActive ;
3770 #if EBOARD_COPY_AND_PASTE > 0x0 3780 #if EBOARD_NANO > 0x0 3781 Servo mainMotor,steerMotor;
3785 ISR(TIMER2_OVF_vect) {
3793 TCNT2 = 256 - (int)((
float)F_CPU * 0.001 / 64);
3805 #if EBOARD_DEBUG_MODE > 0x0 3810 TIMSK2 &= ~(1<<TOIE2);
3811 TCCR2A &= ~((1<<WGM21) | (1<<WGM20));
3812 TCCR2B &= ~(1<<WGM22);
3814 TIMSK2 &= ~(1<<OCIE2A);
3815 TCCR2B |= (1<<CS22);
3816 TCCR2B &= ~((1<<CS21) | (1<<CS20));
3817 TCNT2 = 256 - (int)((
float)F_CPU * 0.001 / 64);
3818 TIMSK2 |= (1<<TOIE2);
3820 #if EBOARD_BLUETOOTH > 0x0 3823 #if (EBOARD_BLUETOOTH > 0x0) && (((PIN_BLUETOOTH_RX==0x13) && (PIN_BLUETOOTH_TX==0x12)) && defined(__AVR_ATmega2560__)) 3824 Serial1.begin(38400);
3830 #if EBOARD_I2C > 0x0 3833 #if EBOARD_SHIFT_REGISTER > 0x0 3839 #if EBOARD_USE_SPI > 0x0 && (EBOARD_NANO == 0) 3842 #if EBOARD_NANO > 0x0 3845 #if EBOARD_DEBUG_MODE > 0x0 3846 Serial.println(
"Initializing main driving motor (3s)");
3848 mainMotor.write(90);
3850 #if EBOARD_DEBUG_MODE > 0x0 3851 Serial.println(
"Initializing of main driving motor completed");
3854 #if EBOARD_DEBUG_MODE > 0x0 3856 Serial.println(
"fin");
3862 #if EBOARD_NANO > 0x0 3863 mainMotor.write(90);
3866 #if EBOARD_NANO == 0x0 3879 #if EBOARD_NANO > 0x0 || defined(DOC) 3885 if(spe < 0 || spe > 180)
return;
3886 mainMotor.write(spe);
3889 if(ang < 0 || ang > 180)
return;
3890 steerMotor.write(ang);
3895 #error This library is build for arduino-devices and should be used only in the Arduino IDE or with a similar linking process 3897 #pragma GCC diagnostic pop int actPos
stores the actual pos or move-to pos of the AX12Servo
uint16_t _rx_delay_intrabit
the rx startbit delay
uint8_t * pixels
stores the pixels
void onRequest(void(*function)(void))
this will set the user_onRequest method
volatile uint8_t * port
the used port register
virtual size_t write(uint8_t data)
this will write a single unsigned 8-bit value to address
void recv(void)
private receive routine called each time interrupt handler gets triggered
SoccerBoard(void)
The constructor.
void setTX(uint8_t transmitPin)
sets a specific pin to be 'the chosen one' as a txPin
int8_t pin
stores the pin -1 if the pin wasn't set
optVAL_t C
storing value for C-pin [MOTOR SPE]
void begin(long speed)
the start function to setup delay_values etc.
AX12Servo * connected[2]
stores the pointers to the registerd AX12Servo
const unsigned char * buf[11]
to enable 'smooth' access (:
uint8_t _transmitBitMask
the pin mask to address the tx pin
[COPY&PASTE] This is the SoccerBoard ghost struct :D
static void(* user_onReceive)(int numBytes)
twi slave [Rx]receive-event user def handler
uint8_t aOffset[4]
stores the offsets in rgbw format
static volatile uint8_t _receive_buffer_head
current location in rxBuffer
[COPY&PASTE] This is the AX12Servo ghost struct :D
static void detachInterrupt(void)
disables the interrupt feature
void write(void)
this will write values stored in B and C
static uint8_t rxBufferIndex
this defines the rxBuffer Index - current position in rxBuffer array
bool canShow(void)
this will determine if the next show is available [last show finished]
void storePosition(int pos, int speed=0x3FF)
This saves the Servo Position.
int actSpe
stores the actual 'would use speed' of the AX12Servo
optVAL_t getPosition(void)
This "kind of" returns the Servo-Position.
virtual size_t write(uint8_t byte)
writes a specific value to the tx register
optVAL_t B
storing value for B-pin [MOTOR DIR]
void setID(optVAL_t newID)
change the AX-12 Servo this object should speak to
uint8_t getBrightness(void) const
returns the current set brightness
[SPI] This is used to avoid path resolving issues and defines the common known Arduino SPI interface ...
uint16_t numLEDs
stores the amount of LEDs
I2CInOut(SoccerBoard &, optVAL_t, optVAL_t, optVAL_t, optVAL_t)
The constructor.
void button(int)
š§ I prevent errors!
bool isListening(void)
checks if this object is the listening object
~NeoPixel(void)
the destructor [calling free on pixel and freeing input pin]
static uint8_t txBufferIndex
this defines the txBuffer Index - current position in txBuffer array
static void onRequestService(void)
twi slave [Tx]transmitting-event handler
uint16_t _rx_delay_stopbit
the rx stopbit dely
char channel(optVAL_t)
will return the next char received by the module. A 64 byte Serial buffer is included! ...
This is used to avoid path resolving issues and defines the common known Arduino Wire-Interface    ...
int peek(void)
reads the actual pointed rxBuffer element without dropping it
void led(int idx, bool state)
[MEGA] Control the OnBoard LED
uint8_t rx_pin_read(void)
simple routine to read the rxPin by registers
bool begun
true if NeoPixel::begin has been called
static uint8_t transmitting
'boolean' value. Set to 1 if transmitting => in master write mode
RB14Scan(void)
The constructor.
void s2Cmd(optVAL_t o, optVAL_t t)
this function will execute two cmd sends without starting and without ending the transmission ...
void ledOff(int idx)
[MEGA] Deactivate the OnBoard LED
uint8_t gamma8(uint8_t x) const
acces to the gamma-correction-8-bit table ;D
void ledMeter(int)
[MEGA] Activate the OnBoard LED
void powerOn(optVAL_t id)
Set the state of a certain D-pin to HIGH.
void changeModes(optVAL_t, optVAL_t, optVAL_t)
š§ I prevent errors!
static void end(void)
this will end the SPI connection
int8_t getPin(void)
this will return the set data pin
void reset(void)
Resets the Soccerboard if EBOARD_USE_RESET is set to true.
bool listen(void)
sets the SoftwareSerial object to be the listening one gaining control over the buffers etc...
bool reset(void)
clears the screen
bool isMoving(void)
Use this if you wan't to have a nice way of writing false.
void sleep(uint16_t t)
Say goodnight!
void setTorque(uint16_t)
š§ I prevent errors!
void changeMode(bool newMode=true)
enable or disable the display
NeoPixel pixels
the NeoPixel-object we use
void ledOn(void)
Noone needs the AX-12 Servo LED^^.
static uint8_t rxBufferLength
this defines the length of rxBuffer
static uint8_t txAddress
this defines the txAddress the transmitting Dta
int storedPos
stores the position the Servo should go to DynamixelBoard::action()
bool init(void)
initializes the Display called by:
void tx_pin_write(uint8_t pin_state)
writes a bool value on the txPin by registers
static uint8_t txBuffer[]
this defines the txBuffer used to enable delayed read
void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b)
sets the rgb color of a specific pixel
void changeAddress(optVAL_t)
š§ I prevent errors!
this namespace contains all the Don't use manually classes ;)
static void attachInterrupt(void)
enables the interrupt feature
SoftwareSerial(uint8_t receivePin, uint8_t transmitPin, bool inverse_logic=false)
the constructor for the SoftwareSerial object
virtual void flush(void)
resets the position in buffer and the buffer itself if the object is listening
static char _receive_buffer[64]
the buffer for rxBuffer
static void begin(void)
this will setup everything for SPI connection
optVAL_t id
stores the id of the AX12Servo obejct
void msleep(uint16_t t)
Say goodnight!
byte pX
the addressing mode (page/horizontal)
DynamixelBoard(SoccerBoard &)
The constructor.
void updateLength(uint16_t n)
this changes the length of the connected LED stripe
uint16_t numBytes
stores the byte size [pixels] used internally
static uint32_t Color(uint8_t r, uint8_t g, uint8_t b)
returns a color value that can be used with NeoPixel::setPixelColor()
void setPin(uint8_t p)
sets pin for communication
virtual int read(void)
this will read a single byte from rxBuffer and increment the Index
void clear(void)
this will reset all set pixels [won't call NeoPixel::show()]
bool setCursor(byte posX=0x0, byte posY=0x0)
set the position of the cursor
uint8_t * getPixels(void) const
this will give you access to the pixels
~SoftwareSerial(void)
the destructor of the SoftwareSerial object
LCD(SoccerBoard &soccerBoard, optVAL_t id=0x3C)
The constructor.
void waitForButton(int)
š§ I prevent errors!
void motorsOff(void)
As requested this is the shortcut to disable the main motor.
int raw(optVAL_t)
this will check for connection status [will return true if pin not connected]
bool overflow(void)
returns the current overflow flag and disables it
static void setDataMode(uint8_t mode)
this will set the Data transfer mode
void updateType(uint16_t t)
this changes the type of communication between arduino and LED stripe
virtual int available(void)
checks if there is data to read available
NeoPixel(void)
the empty constructor
[COPY&PASTE] [BLUETOOTH] This is the RB14Scan ghost struct :D
uint8_t requestFrom(uint8_t address, uint8_t quantity)
this will read a specific quantity of bytes from a specific address
void changeBackground(bool newBackground=false)
changes the background of the display
static void onReceiveService(uint8_t *inBytes, int numBytes)
twi slave [Rx]receive-event handler
void begin()
begin the TwoWire communcation without any data set
optVAL_t ID
ID of the Display.
void motor(uint8_t id, int16_t val)
As requested this is the ultimate shortcut ;)
uint8_t sine8(uint8_t x) const
acces to the sine-8-bit table ;D
bool digital(optVAL_t id)
Reads a digital value from a pin.
static void handle_interrupt(void)
used to handle interrupts on active listening object
int storedSpe
stores the Speed of the Servo DynamixelBoard::action()
[COPY&PASTE] This is the DynamixelBoard ghost struct :D
TwoWire()
The constructor of the TwoWire class.
volatile uint8_t * _transmitPortRegister
the register the reveice pin is located on
static void setClockDivider(uint8_t rate)
this will change the clock devider the
void write(const char *const val)
this will write a constant string to the output
void beginTransmission(uint8_t address)
this will start a new transmission to a specific address => master mode
void power(optVAL_t id, bool state)
Set the state of a certain D-pin.
void s1Dat(optVAL_t o)
this function will execute one dat send without starting and without ending the transmission ...
uint32_t endTime
stores the last call time of show for NeoPixel::canShow()
void changeId(optVAL_t)
š§ I prevent errors!
uint16_t _tx_delay
the (generic) tx delay
DynamixelBoard * _conBoard
virtual int peek(void)
this will read a single byte from rxBuffer without increment the Index
void setBrightness(uint8_t val)
changes the brightness for all further acceses via NeoPixel::setPixelColor()
void setSpeed(optVAL_t)
š§ I prevent errors!
void lightOn(void)
enable the backlight
[COPY&PASTE] This is the I2CInOut ghost struct :D
void lightOff(void)
disable the backlight
void setRX(uint8_t receivePin)
sets a specific pin to be 'the chosen one' as a rxPin
bool clear(void)
clears the LCD
bool s1Cmd(optVAL_t o)
this function will execute one cmd send without starting and without ending the transmission ...
void onReceive(void(*function)(int))
this will set the user_onReceive method
uint8_t brightness
stores the brightness
uint8_t pinMask
the used pinMask
void ledsOff(void)
[MEGA] Deactivate the OnBoard LED
static uint8_t txBufferLength
this defines the length of txBuffer
static byte transfer(byte _data)
this will send a single bite via the SPI connection
void setPositionMode(void)
set the AX-12 Servo to positionMode
static void setBitOrder(uint8_t bitOrder)
this will set the BitOrder
void end(void)
ends communcation on the rx pin
void action(void)
will force every AX12Servo to drive to AX12Servo::storedPos with AX12Servo::storedSpeed ...
static SoftwareSerial * active_object
the active SoftwareSerial object to operate on
bool changeBrightness(byte val=0x64)
changes the brightness of the display
void read(void)
š§ I prevent errors!
optVAL_t analog(optVAL_t id)
Reads an analog value from a pin.
void ledOn(int idx)
[MEGA] Activate the OnBoard LED
AX12Servo(void)
The constructor.
void ledOn(optVAL_t)
š§ I prevent errors!
bool changeID(optVAL_t newID=0x3C)
changes the address of the LCD display talked to
void setPosition(int pos, int speed=0x3FF)
This moves the Servo to the new position.
uint16_t _inverse_logic
determining if all pin reads etc whould be inverted (e.g. no pullup on rx);
DynamixelBoard dBoard(board)
the dBoard object
bool is800KHz
determines the speed the communcation is working on
uint16_t _rx_delay_centering
the rx center delay
static volatile uint8_t _receive_buffer_tail
size of rxBuffer
uint8_t endTransmission(void)
this will end the transmission and send the STOP-sequence
void print(const char *data)
prints a string to the display
void setSpeedMode(void)
set the AX-12 Servo NOT to speedMode
virtual int available(void)
this will return the amount of rxBuffer left
uint8_t _receivePin
the id of the receive pin
void drawBitmap(const unsigned char *bitmap, byte posX, byte posY, byte hiX, byte hiY)
draws a bitmap representet as an array of bytes
void ledOff(void)
Noone needs the AX-12 Servo LED^^.
void powerOff(optVAL_t id)
Set the state of a certain D-pin to LOW.
uint16_t _buffer_overflow
determining if an _buffer_overflow occured
static void(* user_onRequest)(void)
twi slave [Tx]transmitting-event user def handler
uint8_t _receiveBitMask
the pin mask to directly read from register (Rx)
virtual int read(void)
reads the actual pointed rxBuffer top element
static uint8_t rxBuffer[]
this defines the rxBuffer used to enable delayed read
volatile uint8_t * _receivePortRegister
the register the reveice pin is located on
void begin(void)
this has to be called to start the communcation (you should call NeoPixel::setPin() before) ...
[NEO] this allows you to access Adafruit LED-stripes
uint32_t getPixelColor(uint16_t n) const
returns the color of a specific pixel
void changeMotorID(optVAL_t)
š§ I prevent errors!
void show(void)
this will reveal the setPixels [via NeoPixel::setPixelColor() etc...]
uint16_t numPixels(void) const
returns the size of the LED stripe
void ledOff(optVAL_t)
š§ I prevent errors!
static void tunedDelay(uint16_t delay)
apply a specific delay to achieve higher precision
[I2C] [LCD] This is used to add support for OLED displays connected to the 'SoccerBoard' ...
void changeMotorID(optVAL_t newID)
change the AX-12 Servo this object should speak to
optVAL_t A
storing value for A-pin (š§ I prevent errors!)
This is used to avoid path resolving issues and defines the common known Arduino SoftwareSerial inter...