3 #ifndef EBOARD_HEADER_GUARD 4 #define EBOARD_HEADER_GUARD 5 #pragma GCC diagnostic push 6 #pragma GCC diagnostic ignored "-Wall" 7 #pragma GCC diagnostic ignored "-Wextra" 10 #define EBOARD_VERSION "3.1m" 11 #define VALUE_TO_STRING(x) #x 15 #define PREPROCESS_DEBUG 1 17 #define VALUE(x) VALUE_TO_STRING(x) 18 #ifndef PREPROCESS_DEBUG 19 #define PREPROCESS_DEBUG 0 22 #define PPERFORM_PRAGMA(str) _Pragma(#str) 23 #if PREPROCESS_DEBUG == 1 24 #define DEBUG_MSG(str) PPERFORM_PRAGMA(message ("" #str)) 25 #define MACRO_MSG(mac,str) PPERFORM_PRAGMA(message("You set " #mac " to " VALUE(mac) ": " #str)) 27 #define DEBUG_MSG(str) ; 28 #define MACRO_MSG(mac,str) ; 30 DEBUG_MSG(
"If you do not want any preprocessing information from this eBoard-Header set PREPROCESS_DEBUG to 0");
31 DEBUG_MSG(
"You are using eBoard-header v3.1m written by EagleoutIce");
39 DEBUG_MSG(
"Documentation macro SET => Full doc features enabled");
42 #define EBOARD_I2C 0x1 44 #define EBOARD_LCD 0x1 46 #define EBOARD_SHIFT_REGISTER 0x1 48 #define EBOARD_BLUETOOTH 0x1 52 #define __AVR_ATmega2560__ 54 #define __AVR_ATmega328P__ 56 #define EBOARD_NEO 0x1 63 inline int sine8(uint8_t val){
64 return int((__builtin_sin((val/128.0*PI))+1)*127.5+0.5);
67 inline int gamma8(uint8_t val){
68 return int(pow((val)/255.0,2.6)*255.0+0.5);
70 #include <avr/pgmspace.h> 74 #ifndef EBOARD_GUESSPATH 75 DEBUG_MSG(
"You are using Guesspath! Necessary libraries for eBoard will be included automatically");
77 #define EBOARD_GUESSPATH 0x1 79 DEBUG_MSG(
"You are not using Guesspath! Necessary libraries for eBoard have to be included manually");
81 #if defined(ARDUINO) //general platform-check [No tab] 83 #define main eVirtual_main //main has a different meaning^^ 84 #if ARDUINO >= 100 //this could be only Arduino.h but this snippet is portable :D 89 #if not ( defined(__AVR_ATmega2560__) || defined(__AVR_ATmega328P__)) 90 #error "This library was build for ARDUINO UNO R3 Aand ARDUINO MEGA 2560!" 92 #if defined(__AVR_ATmega2560__) 93 DEBUG_MSG(
"Building for Arduino Mega with ATmega2560");
95 #define PIN_MAX 0x32 //53 pins to address - 4 !!53 is SS 97 DEBUG_MSG(
"Building for Arduino Uno or Nano with ATmega328P");
98 #define PIN_MAX 0xA // 13 Pins to address - 4 !!10 is SS 101 #include <avr/interrupt.h> 102 #if EBOARD_I2C > 0x0 && EBOARD_GUESSPATH > 0x0 103 DEBUG_MSG(
"You enabled I²C featurea");
108 #define TWI_FREQ 100000L 110 # ifndef TWI_BUFFER_LENGTH 111 #define TWI_BUFFER_LENGTH 32 120 #include <avr/interrupt.h> 121 #include <compat/twi.h> 123 #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) 126 #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) 128 #include "pins_arduino.h" 129 static volatile uint8_t twi_state;
130 static volatile uint8_t twi_slarw;
131 static volatile uint8_t twi_sendStop;
132 static volatile uint8_t twi_inRepStart;
133 static void (*twi_onSlaveTransmit)(void);
134 static void (*twi_onSlaveReceive)(uint8_t*, int);
135 static uint8_t twi_masterBuffer[TWI_BUFFER_LENGTH];
136 static volatile uint8_t twi_masterBufferIndex;
137 static volatile uint8_t twi_masterBufferLength;
138 static uint8_t twi_txBuffer[TWI_BUFFER_LENGTH];
139 static volatile uint8_t twi_txBufferIndex;
140 static volatile uint8_t twi_txBufferLength;
141 static uint8_t twi_rxBuffer[TWI_BUFFER_LENGTH];
142 static volatile uint8_t twi_rxBufferIndex;
143 static volatile uint8_t twi_error;
144 void twi_init(
void) {
145 twi_state = TWI_READY;
147 twi_inRepStart =
false;
148 digitalWrite(SDA, 1);
149 digitalWrite(SCL, 1);
152 TWBR = ((F_CPU / TWI_FREQ) - 16) / 2;
153 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA);
155 inline void twi_setAddress(uint8_t address) {
158 uint8_t twi_readFrom(uint8_t address, uint8_t* data, uint8_t length, uint8_t sendStop) {
160 if(TWI_BUFFER_LENGTH < length)
return 0;
161 while(TWI_READY != twi_state)
continue;
163 twi_sendStop = sendStop;
165 twi_masterBufferIndex = 0;
166 twi_masterBufferLength = length-1;
168 twi_slarw |= address << 1;
169 if (
true == twi_inRepStart) {
170 twi_inRepStart =
false;
172 TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE);
175 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTA);
176 while(TWI_MRX == twi_state)
continue;
177 if (twi_masterBufferIndex < length)
178 length = twi_masterBufferIndex;
179 for(i = 0; i < length; ++i) data[i] = twi_masterBuffer[i];
182 uint8_t twi_writeTo(uint8_t address, uint8_t* data, uint8_t length, uint8_t wait, uint8_t sendStop) {
184 if(TWI_BUFFER_LENGTH < length)
return 1;
185 while(TWI_READY != twi_state)
continue;
187 twi_sendStop = sendStop;
189 twi_masterBufferIndex = 0;
190 twi_masterBufferLength = length;
191 for(i = 0; i < length; ++i) twi_masterBuffer[i] = data[i];
192 twi_slarw = TW_WRITE;
193 twi_slarw |= address << 1;
194 if (
true == twi_inRepStart) {
195 twi_inRepStart =
false;
197 TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE);
200 TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE) | _BV(TWSTA);
201 while(wait && (TWI_MTX == twi_state))
continue;
202 if (twi_error == 0xFF)
return 0;
203 else if (twi_error == TW_MT_SLA_NACK)
return 2;
204 else if (twi_error == TW_MT_DATA_NACK)
return 3;
207 uint8_t twi_transmit(
const uint8_t* data, uint8_t length) {
209 if(TWI_BUFFER_LENGTH < length)
return 1;
210 if(TWI_STX != twi_state)
return 2;
211 twi_txBufferLength = length;
212 for(i = 0; i < length; ++i) twi_txBuffer[i] = data[i];
215 void twi_attachSlaveRxEvent(
void (*
function)(uint8_t*,
int) ) {
216 twi_onSlaveReceive =
function;
218 void twi_attachSlaveTxEvent(
void (*
function)(
void) ) {
219 twi_onSlaveTransmit =
function;
221 void twi_reply(uint8_t ack) {
223 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA);
225 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT);
228 void twi_stop(
void) {
229 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTO);
230 while(TWCR & _BV(TWSTO))
continue;
231 twi_state = TWI_READY;
233 void twi_releaseBus(
void){
234 TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT);
235 twi_state = TWI_READY;
246 if(twi_masterBufferIndex < twi_masterBufferLength){
247 TWDR = twi_masterBuffer[twi_masterBufferIndex++];
250 if (twi_sendStop) twi_stop();
252 twi_inRepStart =
true;
253 TWCR = _BV(TWINT) | _BV(TWSTA)| _BV(TWEN) ;
254 twi_state = TWI_READY;
259 twi_error = TW_MT_SLA_NACK;
262 case TW_MT_DATA_NACK:
263 twi_error = TW_MT_DATA_NACK;
267 twi_error = TW_MT_ARB_LOST;
271 twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
273 if(twi_masterBufferIndex < twi_masterBufferLength) twi_reply(1);
276 case TW_MR_DATA_NACK:
277 twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
278 if (twi_sendStop) twi_stop();
280 twi_inRepStart =
true;
281 TWCR = _BV(TWINT) | _BV(TWSTA)| _BV(TWEN) ;
282 twi_state = TWI_READY;
289 case TW_SR_GCALL_ACK:
290 case TW_SR_ARB_LOST_SLA_ACK:
291 case TW_SR_ARB_LOST_GCALL_ACK:
293 twi_rxBufferIndex = 0;
297 case TW_SR_GCALL_DATA_ACK:
298 if(twi_rxBufferIndex < TWI_BUFFER_LENGTH){
299 twi_rxBuffer[twi_rxBufferIndex++] = TWDR;
304 if(twi_rxBufferIndex < TWI_BUFFER_LENGTH) twi_rxBuffer[twi_rxBufferIndex] =
'\0';
306 twi_onSlaveReceive(twi_rxBuffer, twi_rxBufferIndex);
307 twi_rxBufferIndex = 0;
310 case TW_SR_DATA_NACK:
311 case TW_SR_GCALL_DATA_NACK:
315 case TW_ST_ARB_LOST_SLA_ACK:
317 twi_txBufferIndex = 0;
318 twi_txBufferLength = 0;
319 twi_onSlaveTransmit();
320 if(0 == twi_txBufferLength){
321 twi_txBufferLength = 1;
322 twi_txBuffer[0] = 0x00;
325 TWDR = twi_txBuffer[twi_txBufferIndex++];
326 if(twi_txBufferIndex < twi_txBufferLength) twi_reply(1);
329 case TW_ST_DATA_NACK:
330 case TW_ST_LAST_DATA:
332 twi_state = TWI_READY;
337 twi_error = TW_BUS_ERROR;
343 #include <inttypes.h> 345 #define BUFFER_LENGTH 32 348 class TwoWire :
public Stream {
380 void begin(uint8_t address);
382 inline void begin(
int address);
392 inline uint8_t
requestFrom(uint8_t address, uint8_t quantity);
394 uint8_t
requestFrom(uint8_t address , uint8_t quantity, uint8_t sendStop);
396 inline uint8_t
requestFrom(
int address,
int quantity);
398 inline uint8_t
requestFrom(
int address,
int quantity,
int sendStop);
400 virtual size_t write(uint8_t data);
402 virtual size_t write(
const uint8_t *data,
size_t quantity);
406 virtual int read(
void);
408 virtual int peek(
void);
412 void onRequest(
void (*
function)(
void) );
420 #include <inttypes.h> 443 twi_setAddress(address);
449 begin((uint8_t)address);
455 uint8_t
read = twi_readFrom(address,
rxBuffer, quantity, sendStop);
461 return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)
true);
464 return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)
true);
467 return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)sendStop);
498 twi_transmit(&data, 1);
504 for(
size_t i = 0; i < quantity; ++i) {
508 twi_transmit(data, quantity);
537 for(uint8_t i = 0; i < numBytes; ++i) {
560 DEBUG_MSG(
"You disabled I²C");
563 #ifndef EBOARD_USE_SPI 564 #define EBOARD_USE_SPI 0x1 566 #if EBOARD_USE_SPI > 0x0 567 DEBUG_MSG(
"You enabled SPI");
569 #define _SPI_H_INCLUDED 572 #define SPI_CLOCK_DIV4 0x00 574 #define SPI_CLOCK_DIV16 0x01 576 #define SPI_CLOCK_DIV64 0x02 578 #define SPI_CLOCK_DIV128 0x03 580 #define SPI_CLOCK_DIV2 0x04 582 #define SPI_CLOCK_DIV8 0x05 584 #define SPI_CLOCK_DIV32 0x06 586 #define SPI_MODE0 0x00 588 #define SPI_MODE1 0x04 590 #define SPI_MODE2 0x08 592 #define SPI_MODE3 0x0C 594 #define SPI_MODE_MASK 0x0C 596 #define SPI_CLOCK_MASK 0x03 598 #define SPI_2XCLOCK_MASK 0x01 603 inline static byte
transfer(byte _data);
609 static void begin(
void);
611 inline static void end(
void);
623 while (!(SPSR & _BV(SPIF)));
629 digitalWrite(SS, HIGH);
633 pinMode(SCK, OUTPUT);
634 pinMode(MOSI, OUTPUT);
638 if(bitOrder == LSBFIRST) SPCR |= _BV(DORD);
639 else SPCR &= ~(_BV(DORD));
649 DEBUG_MSG(
"You disabled SPI");
651 #if (EBOARD_I2C > 0x0) && (EBOARD_LCD > 0x0) 652 #include <avr/pgmspace.h> 653 DEBUG_MSG(
"You enabled LCD");
656 static bool STOP =
false;
659 DEBUG_MSG(
"You defined IGNORE_SIZE: byte will be used");
662 DEBUG_MSG(
"You did not define IGNORE_SIZE: int will be used");
666 #ifndef EBOARD_DEBUG_MODE 667 #define EBOARD_DEBUG_MODE 0x1 669 #if EBOARD_DEBUG_MODE > 0x0 676 #define EBOARD_NANO 0x0 678 #if EBOARD_NANO > 0x0 || defined(DOC) 679 #ifndef EBOARD_NANO_STEER 681 #define EBOARD_NANO_STEER 12 683 #ifndef EBOARD_NANO_MAIN 685 #define EBOARD_NANO_MAIN 13 687 MACRO_MSG(
EBOARD_NANO,
"Using Arduino NANO environment [e.g. remove SoccerBoard]");
688 #if PREPROCESS_DEBUG > 0x1 689 #pragma message("Using " VALUE(EBOARD_NANO_STEER) " as data pin for STEERING MOTOR") 690 #pragma message("Using " VALUE(EBOARD_NANO_MAIN) " as data pin for MAIN (Driving) MOTOR") 693 MACRO_MSG(
EBOARD_NANO,
"Using Arduino UNO/MEGA environment");
696 #ifndef EBOARD_CHECK_PINS 697 #define EBOARD_CHECK_PINS 0x1 699 #if EBOARD_CHECK_PINS > 0x0 704 #ifndef EBOARD_SHIFT_REGISTER 706 #define EBOARD_SHIFT_REGISTER 0x0 708 #if EBOARD_SHIFT_REGISTER > 0x0 714 #ifndef EBOARD_CHECK_PINS_PWM 715 #define EBOARD_CHECK_PINS_PWM 0x1 717 #if EBOARD_CHECK_PINS_PWM > 0x0 723 #ifndef EBOARD_DEBUG_SPEED 724 #define EBOARD_DEBUG_SPEED 9600 726 #if PREPROCESS_DEBUG > 0x0 727 #pragma message("Set Debugging speed to " VALUE(EBOARD_DEBUG_SPEED)) 730 #ifndef EBOARD_SPI_SERVO_MAX 731 #define EBOARD_SPI_SERVO_MAX 2 733 #if PREPROCESS_DEBUG > 0x0 734 #pragma message("Set amount of used Servos to " VALUE(EBOARD_SPI_SERVO_MAX)) 737 #ifndef EBOARD_USE_UTILITY 738 #define EBOARD_USE_UTILITY 0x1 740 #if EBOARD_USE_UTILITY > 0x0 746 #define EBOARD_COPY_AND_PASTE 0x1 748 #ifndef EBOARD_PWM_SPE 749 #define EBOARD_PWM_SPE 1 751 #if PREPROCESS_DEBUG > 0x0 752 #pragma message("Set PWM interval to " VALUE(EBOARD_PWM_SPE) "s") 756 #define EBOARD_I2C 0x0 //disabled by default 758 #ifndef EBOARD_BLUETOOTH 760 #define EBOARD_BLUETOOTH 0x0 762 #if EBOARD_BLUETOOTH > 0x0 769 #define EBOARD_CLAMP 0x1 771 #if EBOARD_CLAMP > 0x0 772 MACRO_MSG(
EBOARD_CLAMP,
"Motor Range is set to [0;1023]");
774 MACRO_MSG(
EBOARD_CLAMP,
"Motor Range is set to [-300;300]");
778 #define EBOARD_NEO 0x0 781 MACRO_MSG(
EBOARD_NEO,
"Adafruit Neo-Pixel support enabled");
783 MACRO_MSG(
EBOARD_NEO,
"Adafruit Neo-Pixel support disabled");
786 #ifndef EBOARD_USE_RESET 787 #define EBOARD_USE_RESET 0x1 789 #if EBOARD_USE_RESET > 0x0 796 #ifndef PIN_BLUETOOTH_STATE 797 #if defined(__AVR_ATmega2560__) 798 #define PIN_BLUETOOTH_STATE 0x13 // 19 800 #define PIN_BLUETOOTH_STATE 0x2 804 #ifndef PIN_BLUETOOTH_RX 805 #if defined(__AVR_ATmega2560__) 806 #define PIN_BLUETOOTH_RX 0x13 // 19 808 #define PIN_BLUETOOTH_RX 0x2 812 #ifndef PIN_BLUETOOTH_TX 813 #if defined(__AVR_ATmega2560__) 814 #define PIN_BLUETOOTH_TX 0x12 // 18 816 #define PIN_BLUETOOTH_TX 0x3 820 #ifndef PIN_MOTOR_DIR 821 #define PIN_MOTOR_DIR 0x4 824 #ifndef PIN_MOTOR_SPE 825 #define PIN_MOTOR_SPE 0x5 828 #ifndef PIN_SHIFT_CLK 829 #define PIN_SHIFT_CLK 0x6 832 #ifndef PIN_SHIFT_DAT 833 #define PIN_SHIFT_DAT 0x7 836 #ifndef PIN_SHIFT_LAT 837 #define PIN_SHIFT_LAT 0x8 847 #if (EBOARD_BLUETOOTH > 0x0) && defined(__AVR_ATmega328P__) 848 #if EBOARD_GUESSPATH > 0x0 850 #define _SS_MAX_RX_BUFF 64 // RX buffer size 852 #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) 895 void setTX(uint8_t transmitPin);
897 void setRX(uint8_t receivePin);
899 static inline void tunedDelay(uint16_t delay);
903 SoftwareSerial(uint8_t receivePin, uint8_t transmitPin,
bool inverse_logic =
false);
907 void begin(
long speed);
911 inline void end(
void);
919 virtual size_t write(uint8_t byte);
921 virtual int read(
void);
925 virtual void flush(
void);
942 #if EBOARD_DEBUG_MODE > 0x0 944 #define _DEBUG_PIN1 11 945 #define _DEBUG_PIN2 13 947 typedef struct _DELAY_TABLE {
949 unsigned short rx_delay_centering;
950 unsigned short rx_delay_intrabit;
951 unsigned short rx_delay_stopbit;
952 unsigned short tx_delay;
954 #if F_CPU == 16000000 955 static const DELAY_TABLE PROGMEM table[] = {
957 { 115200, 1, 17, 17, 12, },
958 { 57600, 10, 37, 37, 33, },
959 { 38400, 25, 57, 57, 54, },
960 { 31250, 31, 70, 70, 68, },
961 { 28800, 34, 77, 77, 74, },
962 { 19200, 54, 117, 117, 114, },
963 { 14400, 74, 156, 156, 153, },
964 { 9600, 114, 236, 236, 233, },
965 { 4800, 233, 474, 474, 471, },
966 { 2400, 471, 950, 950, 947, },
967 { 1200, 947, 1902, 1902, 1899, },
968 { 600, 1902, 3804, 3804, 3800, },
969 { 300, 3804, 7617, 7617, 7614, },
971 const int XMIT_START_ADJUSTMENT = 5;
972 #elif F_CPU == 8000000 973 static const DELAY_TABLE table[] PROGMEM = {
975 { 115200, 1, 5, 5, 3, },
976 { 57600, 1, 15, 15, 13, },
977 { 38400, 2, 25, 26, 23, },
978 { 31250, 7, 32, 33, 29, },
979 { 28800, 11, 35, 35, 32, },
980 { 19200, 20, 55, 55, 52, },
981 { 14400, 30, 75, 75, 72, },
982 { 9600, 50, 114, 114, 112, },
983 { 4800, 110, 233, 233, 230, },
984 { 2400, 229, 472, 472, 469, },
985 { 1200, 467, 948, 948, 945, },
986 { 600, 948, 1895, 1895, 1890, },
987 { 300, 1895, 3805, 3805, 3802, },
989 const int XMIT_START_ADJUSTMENT = 4;
990 #elif F_CPU == 20000000 991 static const DELAY_TABLE PROGMEM table[] = {
993 { 115200, 3, 21, 21, 18, },
994 { 57600, 20, 43, 43, 41, },
995 { 38400, 37, 73, 73, 70, },
996 { 31250, 45, 89, 89, 88, },
997 { 28800, 46, 98, 98, 95, },
998 { 19200, 71, 148, 148, 145, },
999 { 14400, 96, 197, 197, 194, },
1000 { 9600, 146, 297, 297, 294, },
1001 { 4800, 296, 595, 595, 592, },
1002 { 2400, 592, 1189, 1189, 1186, },
1003 { 1200, 1187, 2379, 2379, 2376, },
1004 { 600, 2379, 4759, 4759, 4755, },
1005 { 300, 4759, 9523, 9523, 9520, },
1007 const int XMIT_START_ADJUSTMENT = 6;
1009 #error This version of SoftwareSerial supports only 20, 16 and 8MHz processors 1015 #if EBOARD_DEBUG_MODE > 0x0 1016 inline void DebugPulse(uint8_t pin, uint8_t count) {
1018 volatile uint8_t *pport = portOutputRegister(digitalPinToPort(pin));
1019 uint8_t val = *pport;
1022 *pport = val | digitalPinToBitMask(pin);
1030 asm volatile(
"sbiw %0, 0x01 \n\t" 1032 "cpi %A0, 0xFF \n\t" 1035 :
"+r" (delay),
"+a" (tmp)
1043 uint8_t oldSREG = SREG;
1053 #if GCC_VERSION < 40302 1069 #if EBOARD_DEBUG_MODE > 0x0 1070 DebugPulse(_DEBUG_PIN2, 1);
1073 for (uint8_t i=0x1; i; i <<= 1)
1076 #if EBOARD_DEBUG_MODE > 0x0 1077 DebugPulse(_DEBUG_PIN2, 1);
1087 #if EBOARD_DEBUG_MODE > 0x0 1088 DebugPulse(_DEBUG_PIN2, 1);
1097 #if EBOARD_DEBUG_MODE > 0x0 1098 #if _DEBUG // for scope: pulse pin as overflow indictator 1099 DebugPulse(_DEBUG_PIN1, 1);
1105 #if GCC_VERSION < 40302 1119 if (pin_state == LOW)
1132 #if defined(PCINT0_vect) 1137 #if defined(PCINT1_vect) 1142 #if defined(PCINT2_vect) 1147 #if defined(PCINT3_vect) 1153 _rx_delay_centering(0),
1154 _rx_delay_intrabit(0),
1155 _rx_delay_stopbit(0),
1157 _buffer_overflow(false),
1158 _inverse_logic(inverse_logic) {
1162 SoftwareSerial::~SoftwareSerial() {
1166 pinMode(tx, OUTPUT);
1167 digitalWrite(tx, HIGH);
1169 uint8_t port = digitalPinToPort(tx);
1175 digitalWrite(rx, HIGH);
1178 uint8_t port = digitalPinToPort(rx);
1183 for (
unsigned i=0; i<
sizeof(table)/
sizeof(table[0]); ++i) {
1184 long baud = pgm_read_dword(&table[i].baud);
1185 if (baud == speed) {
1189 _tx_delay = pgm_read_word(&table[i].tx_delay);
1201 pinMode(_DEBUG_PIN1, OUTPUT);
1202 pinMode(_DEBUG_PIN2, OUTPUT);
1229 uint8_t oldSREG = SREG;
1234 for (byte mask = 0x01; mask; mask <<= 1) {
1244 for (byte mask = 0x01; mask; mask <<= 1) {
1260 uint8_t oldSREG = SREG;
1277 #if EBOARD_DEBUG_MODE > 0x0 1279 #define __ASSERT_USE_STDERR 1282 void __assert (
const char *__func,
const char *__file,
optVAL_t __lineno,
const char *__sexp);
1284 void __assert (
const char *__func,
const char *__file,
optVAL_t __lineno,
const char *__sexp){
1285 Serial.print(
"Error with: "); Serial.print(__func);
1286 Serial.print(
" in "); Serial.print(__file);
1287 Serial.print(
" >>");
1288 Serial.println(__sexp);
1289 if(strcmp(__func,
"checkIdx")==0){
1290 Serial.println(
" This happens if an out of bounds exception");
1291 Serial.println(
" has occured. Following pins shouldn't be used:");
1294 Serial.println(
" : Used for Bluetooth communication");
1295 Serial.print(
" D");Serial.print(
PIN_MOTOR_DIR);Serial.print(
"&");
1297 Serial.println(
" : Used for main motor control");
1298 #if EBOARD_USE_SPI > 0x0 1299 Serial.print(
" D10-13");
1300 Serial.println(
": Used for smart-servo-shield");
1302 }
else if (strcmp(__func,
"readPin")==0){
1303 Serial.println(
"You've tried to access an analogPin that isn't present on the board you're currently working on!");
1314 #if EBOARD_DEBUG_MODE > 0x0 1315 assert(idx>=0x0 && idx <
PIN_MAX);
1320 #if EBOARD_COPY_AND_PASTE > 0x0 1321 #if EBOARD_CHECK_PINS_PWM > 0x0 1327 for (count = 0; x; count++)
1333 #if EBOARD_CHECK_PINS > 0x0 1335 #if defined(__AVR_ATmega328P__) && not defined(__AVR_ATmega2560__) 1337 #elif defined(__AVR_ATmega2560__) 1341 #if defined(__AVR_ATmega328P__) && not defined(__AVR_ATmega2560__) 1343 #elif defined(__AVR_ATmega2560__) 1351 return (mode == OUTPUT)? ((
pin_out & (1<<idx))>0x0):((
pin_in & (1<<idx))>0x0);
1359 #if EBOARD_CHECK_PINS > 0x0 1374 #if EBOARD_BLUETOOTH > 0x0 1376 inline char readVal(
char oF =
'.');
1380 template <
typename T>
1381 inline void writeVal(
const T& val);
1386 #if (EBOARD_BLUETOOTH > 0x0) && (((PIN_BLUETOOTH_RX==0x13) && (PIN_BLUETOOTH_TX==0x12)) && defined(__AVR_ATmega2560__)) 1392 inline char readVal(
char oF) {
1393 #if (EBOARD_BLUETOOTH > 0x0) && (((PIN_BLUETOOTH_RX==0x13) && (PIN_BLUETOOTH_TX==0x12)) && defined(__AVR_ATmega2560__)) 1394 return ((Serial1.available())?(Serial1.read()):(oF));
1399 template<
typename T>
1400 inline void writeVal(
const T& val){
1401 #if (EBOARD_BLUETOOTH > 0x0) && (((PIN_BLUETOOTH_RX==0x13) && (PIN_BLUETOOTH_TX==0x12)) && defined(__AVR_ATmega2560__)) 1408 #if PIN_BLUETOOTH_RX != PIN_BLUETOOTH_STATE 1416 #if EBOARD_SHIFT_REGISTER > 0x0 1444 val = min(val,0xFF); val = max(0x0,val);
1448 extern void rept_task(
void);
1449 DEBUG_MSG(
"You defined REPT_TASK: you have to define rept_task(void)!");
1451 DEBUG_MSG(
"You did not define REPT_TASK: rept_task(void) will not have any effect");
1458 #if EBOARD_SHIFT_REGISTER > 0x0 1465 #if EBOARD_CHECK_PINS > 0x0 1469 #if EBOARD_COPY_AND_PASTE > 0x0 1472 pinMode(idx,OUTPUT);
1474 digitalWrite(idx,val);
1481 #if EBOARD_CHECK_PINS > 0x0 1483 #if defined (__AVR_ATmega2560__) 1484 else if (idx<0||idx>0xF){
1486 else if (idx<0||idx>0x7){
1488 #if EBOARD_DEBUG_MODE > 0x0 1495 #if EBOARD_COPY_AND_PASTE > 0x0 1500 return((dig)? digitalRead(idx) : analogRead(idx));
1503 #if EBOARD_USE_SPI > 0x0 && (EBOARD_NANO == 0x0) 1508 #if defined(__AVR_ATmega2560__) 1509 ServoCds55(
int CS=53);
1511 ServoCds55(
int CS=10);
1514 void WritePos(
int ID,
int Pos);
1515 void write(
int ID,
int Pos);
1516 inline void setVelocity(
int velocity);
1517 inline void setPoslimit(
int posLimit);
1518 inline void rotate(
int ID,
int velocity);
1519 void SetServoLimit(
int ID,
int upperLimit);
1520 void SetMotormode(
int ID,
int velocity);
1521 void SetID(
int ID,
int newID);
1523 byte sendWait (
const byte what);
1525 int upperLimit_temp;
1528 ServoCds55::ServoCds55 (
int CS):cs(CS) {
1529 velocity_temp = 150;
1530 upperLimit_temp = 300;
1532 void ServoCds55::begin() {
1534 digitalWrite(cs,HIGH);
1538 byte ServoCds55::sendWait (
const byte what) {
1540 delayMicroseconds (20);
1543 void ServoCds55::setVelocity(
int velocity){
1544 velocity_temp = velocity;
1546 void ServoCds55::setPoslimit(
int posLimit){
1547 upperLimit_temp = posLimit;
1549 void ServoCds55::write(
int ID,
int Pos){
1550 SetServoLimit(ID,upperLimit_temp);
1553 inline void ServoCds55::rotate(
int ID,
int velocity){
1554 SetServoLimit(ID,0);
1556 SetMotormode(ID,velocity);
1558 void ServoCds55::WritePos(
int ID,
int Pos){
1559 int PosB = (Pos>>8 & 0xff);
1560 int PosS = (Pos & 0xff);
1561 int velocityB = (velocity_temp>>8 & 0xff);
1562 int velocityS = (velocity_temp & 0xff);
1563 digitalWrite(cs, LOW);
1564 sendWait (
'p'); sendWait (ID);
1565 sendWait (PosB); sendWait (PosS);
1566 sendWait (velocityB); sendWait (velocityS);
1567 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1568 digitalWrite(cs, HIGH);
1571 void ServoCds55::SetServoLimit(
int ID,
int upperLimit_temp){
1572 int upperLimitB = (upperLimit_temp>>8 & 0xff);
1573 int upperLimitS = (upperLimit_temp & 0xff);
1574 digitalWrite(cs, LOW);
1575 sendWait (
's'); sendWait (ID);
1576 sendWait (upperLimitB); sendWait (upperLimitS);
1577 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1578 digitalWrite(cs, HIGH);
1581 void ServoCds55::SetMotormode(
int ID,
int velocity){
1582 int velocityB = (velocity>>8 & 0xff);
1583 int velocityS = (velocity & 0xff);
1584 digitalWrite(cs, LOW);
1585 sendWait (
'm'); sendWait (ID);
1586 sendWait (velocityB); sendWait (velocityS);
1587 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1588 digitalWrite(cs, HIGH);
1591 void ServoCds55::SetID(
int ID,
int newID){
1592 digitalWrite(cs, LOW);
1593 sendWait (
'i'); sendWait (ID);
1595 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1596 digitalWrite(cs, HIGH);
1599 void ServoCds55::Reset(
int ID){
1600 digitalWrite(cs, LOW);
1601 sendWait (
'r'); sendWait (ID);
1602 sendWait (
'\t'); sendWait (
'\r'); sendWait (
'\n');
1603 digitalWrite(cs, HIGH);
1610 #if EBOARD_COPY_AND_PASTE > 0x0 && EBOARD_NANO == 0 1616 #if EBOARD_USE_UTILITY > 0x0 or defined(__AVR_ATmega2560__) //won't shrink space... just speed things up 1618 inline void led(
int idx,
bool state);
1620 inline void ledOn(
int idx);
1622 inline void ledOff(
int idx);
1628 #if EBOARD_USE_UTILITY > 0x0 1635 inline void motor(uint8_t
id,int16_t val);
1649 inline void sleep(uint16_t t);
1651 inline void msleep(uint16_t t);
1657 inline void reset(
void);
1661 #if defined(__AVR_ATmega2560__) 1667 #elif EBOARD_USE_UTILITY > 0x0 1674 #if EBOARD_USE_UTILITY > 0x0 1680 else if(
id>0&&
id<3&&(val>-0 && val < 1024)) {
_servoHandler.write((
id-1),(val *600/1023 - 300));}
1684 #if EBOARD_USE_RESET > 0x0 1685 wdt_enable(WDTO_15MS);
1699 #define DIGITAL_IN 0x0 1701 #define DIGITAL_IN_INV 0x1 1703 #define DIGITAL_IN_PULLUP 0x2 1705 #define DIGITAL_IN_PULLUP_INV 0x3 1707 #define DIGITAL_OUT 0x4 1709 #define DIGITAL_OUT_INV 0x5 1711 #define DIGITAL_OUT_LOW 0x6 1713 #define DIGITAL_OUT_HIGH 0x7 1715 #define ANALOG_IN_8_BIT 0x8 1717 #define ANALOG_IN_10_BIT 0x9 1719 #define ANALOG_IN_MEAN_8_BIT 0xA 1721 #define ANALOG_IN_MEAN_10_BIT 0xB 1723 #define COUNTER_8_BIT 0xC 1725 #define COUNTER_16_BIT 0xD 1727 #define COUNTER_RISE_8_BIT 0xE 1729 #define COUNTER_RISE_16_BIT 0xF 1731 #define PWM_SLOW 0x8 1733 #define PWM_FAST 0x9 1735 #define FREQ_LOW 0xA 1737 #define FREQ_HIGH 0xB 1739 #define COUNTER_B_DIR 0xC 1741 #define COUNTER_B_DIR_PULLUP 0xD 1743 #define COUNTER_MEAN_8_BIT 0xE 1745 #define COUNTER_MEAN_16_BIT 0xF 1750 #if EBOARD_USE_UTILITY > 0x0 1752 inline void read(
void);
1759 inline void write(
void);
1770 this->
A=0x0;this->
B=0x0;this->
C=0x0;
1772 #if EBOARD_USE_UTILITY > 0x0 1792 #if EBOARD_USE_UTILITY > 0x0 1804 inline void ledOff(
void);
1806 inline void ledOn(
void);
1833 #if EBOARD_USE_UTILITY > 0x0 1845 #if EBOARD_CLAMP > 0x0 1846 if(pos>1023 || speed > 1023)
return;
1848 speed = speed*600/1023 - 300;
1849 pos = pos *600/1023 - 300;
1851 if(pos>300 || speed > 300)
return;
1867 #if EBOARD_USE_UTILITY > 0x0 1878 inline void action(
void);
1890 #if EBOARD_USE_UTILITY > 0x0 1913 #if EBOARD_BLUETOOTH > 0x0 1925 inline void write(
const char*
const val);
1935 #if EBOARD_I2C > 0x0 1945 for (byte i = 1; (i < 255 && !
STOP); i++) {
1949 if(count < ret_len) ret[count] = i;
1975 #if EBOARD_LCD > 0x0 1977 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
1978 {0x00,0x00,0x5F,0x00,0x00,0x00,0x00,0x00},
1979 {0x00,0x00,0x07,0x00,0x07,0x00,0x00,0x00},
1980 {0x00,0x14,0x7F,0x14,0x7F,0x14,0x00,0x00},
1981 {0x00,0x24,0x2A,0x7F,0x2A,0x12,0x00,0x00},
1982 {0x00,0x23,0x13,0x08,0x64,0x62,0x00,0x00},
1983 {0x00,0x36,0x49,0x55,0x22,0x50,0x00,0x00},
1984 {0x00,0x00,0x05,0x03,0x00,0x00,0x00,0x00},
1985 {0x00,0x1C,0x22,0x41,0x00,0x00,0x00,0x00},
1986 {0x00,0x41,0x22,0x1C,0x00,0x00,0x00,0x00},
1987 {0x00,0x08,0x2A,0x1C,0x2A,0x08,0x00,0x00},
1988 {0x00,0x08,0x08,0x3E,0x08,0x08,0x00,0x00},
1989 {0x00,0xA0,0x60,0x00,0x00,0x00,0x00,0x00},
1990 {0x00,0x08,0x08,0x08,0x08,0x08,0x00,0x00},
1991 {0x00,0x60,0x60,0x00,0x00,0x00,0x00,0x00},
1992 {0x00,0x20,0x10,0x08,0x04,0x02,0x00,0x00},
1993 {0x00,0x3E,0x51,0x49,0x45,0x3E,0x00,0x00},
1994 {0x00,0x00,0x42,0x7F,0x40,0x00,0x00,0x00},
1995 {0x00,0x62,0x51,0x49,0x49,0x46,0x00,0x00},
1996 {0x00,0x22,0x41,0x49,0x49,0x36,0x00,0x00},
1997 {0x00,0x18,0x14,0x12,0x7F,0x10,0x00,0x00},
1998 {0x00,0x27,0x45,0x45,0x45,0x39,0x00,0x00},
1999 {0x00,0x3C,0x4A,0x49,0x49,0x30,0x00,0x00},
2000 {0x00,0x01,0x71,0x09,0x05,0x03,0x00,0x00},
2001 {0x00,0x36,0x49,0x49,0x49,0x36,0x00,0x00},
2002 {0x00,0x06,0x49,0x49,0x29,0x1E,0x00,0x00},
2003 {0x00,0x00,0x36,0x36,0x00,0x00,0x00,0x00},
2004 {0x00,0x00,0xAC,0x6C,0x00,0x00,0x00,0x00},
2005 {0x00,0x08,0x14,0x22,0x41,0x00,0x00,0x00},
2006 {0x00,0x14,0x14,0x14,0x14,0x14,0x00,0x00},
2007 {0x00,0x41,0x22,0x14,0x08,0x00,0x00,0x00},
2008 {0x00,0x02,0x01,0x51,0x09,0x06,0x00,0x00},
2009 {0x00,0x32,0x49,0x79,0x41,0x3E,0x00,0x00},
2010 {0x00,0x7E,0x09,0x09,0x09,0x7E,0x00,0x00},
2011 {0x00,0x7F,0x49,0x49,0x49,0x36,0x00,0x00},
2012 {0x00,0x3E,0x41,0x41,0x41,0x22,0x00,0x00},
2013 {0x00,0x7F,0x41,0x41,0x22,0x1C,0x00,0x00},
2014 {0x00,0x7F,0x49,0x49,0x49,0x41,0x00,0x00},
2015 {0x00,0x7F,0x09,0x09,0x09,0x01,0x00,0x00},
2016 {0x00,0x3E,0x41,0x41,0x51,0x72,0x00,0x00},
2017 {0x00,0x7F,0x08,0x08,0x08,0x7F,0x00,0x00},
2018 {0x00,0x41,0x7F,0x41,0x00,0x00,0x00,0x00},
2019 {0x00,0x20,0x40,0x41,0x3F,0x01,0x00,0x00},
2020 {0x00,0x7F,0x08,0x14,0x22,0x41,0x00,0x00},
2021 {0x00,0x7F,0x40,0x40,0x40,0x40,0x00,0x00},
2022 {0x00,0x7F,0x02,0x0C,0x02,0x7F,0x00,0x00},
2023 {0x00,0x7F,0x04,0x08,0x10,0x7F,0x00,0x00},
2024 {0x00,0x3E,0x41,0x41,0x41,0x3E,0x00,0x00},
2025 {0x00,0x7F,0x09,0x09,0x09,0x06,0x00,0x00},
2026 {0x00,0x3E,0x41,0x51,0x21,0x5E,0x00,0x00},
2027 {0x00,0x7F,0x09,0x19,0x29,0x46,0x00,0x00},
2028 {0x00,0x26,0x49,0x49,0x49,0x32,0x00,0x00},
2029 {0x00,0x01,0x01,0x7F,0x01,0x01,0x00,0x00},
2030 {0x00,0x3F,0x40,0x40,0x40,0x3F,0x00,0x00},
2031 {0x00,0x1F,0x20,0x40,0x20,0x1F,0x00,0x00},
2032 {0x00,0x3F,0x40,0x38,0x40,0x3F,0x00,0x00},
2033 {0x00,0x63,0x14,0x08,0x14,0x63,0x00,0x00},
2034 {0x00,0x03,0x04,0x78,0x04,0x03,0x00,0x00},
2035 {0x00,0x61,0x51,0x49,0x45,0x43,0x00,0x00},
2036 {0x00,0x7F,0x41,0x41,0x00,0x00,0x00,0x00},
2037 {0x00,0x02,0x04,0x08,0x10,0x20,0x00,0x00},
2038 {0x00,0x41,0x41,0x7F,0x00,0x00,0x00,0x00},
2039 {0x00,0x04,0x02,0x01,0x02,0x04,0x00,0x00},
2040 {0x00,0x80,0x80,0x80,0x80,0x80,0x00,0x00},
2041 {0x00,0x01,0x02,0x04,0x00,0x00,0x00,0x00},
2042 {0x00,0x20,0x54,0x54,0x54,0x78,0x00,0x00},
2043 {0x00,0x7F,0x48,0x44,0x44,0x38,0x00,0x00},
2044 {0x00,0x38,0x44,0x44,0x28,0x00,0x00,0x00},
2045 {0x00,0x38,0x44,0x44,0x48,0x7F,0x00,0x00},
2046 {0x00,0x38,0x54,0x54,0x54,0x18,0x00,0x00},
2047 {0x00,0x08,0x7E,0x09,0x02,0x00,0x00,0x00},
2048 {0x00,0x18,0xA4,0xA4,0xA4,0x7C,0x00,0x00},
2049 {0x00,0x7F,0x08,0x04,0x04,0x78,0x00,0x00},
2050 {0x00,0x00,0x7D,0x00,0x00,0x00,0x00,0x00},
2051 {0x00,0x80,0x84,0x7D,0x00,0x00,0x00,0x00},
2052 {0x00,0x7F,0x10,0x28,0x44,0x00,0x00,0x00},
2053 {0x00,0x41,0x7F,0x40,0x00,0x00,0x00,0x00},
2054 {0x00,0x7C,0x04,0x18,0x04,0x78,0x00,0x00},
2055 {0x00,0x7C,0x08,0x04,0x7C,0x00,0x00,0x00},
2056 {0x00,0x38,0x44,0x44,0x38,0x00,0x00,0x00},
2057 {0x00,0xFC,0x24,0x24,0x18,0x00,0x00,0x00},
2058 {0x00,0x18,0x24,0x24,0xFC,0x00,0x00,0x00},
2059 {0x00,0x00,0x7C,0x08,0x04,0x00,0x00,0x00},
2060 {0x00,0x48,0x54,0x54,0x24,0x00,0x00,0x00},
2061 {0x00,0x04,0x7F,0x44,0x00,0x00,0x00,0x00},
2062 {0x00,0x3C,0x40,0x40,0x7C,0x00,0x00,0x00},
2063 {0x00,0x1C,0x20,0x40,0x20,0x1C,0x00,0x00},
2064 {0x00,0x3C,0x40,0x30,0x40,0x3C,0x00,0x00},
2065 {0x00,0x44,0x28,0x10,0x28,0x44,0x00,0x00},
2066 {0x00,0x1C,0xA0,0xA0,0x7C,0x00,0x00,0x00},
2067 {0x00,0x44,0x64,0x54,0x4C,0x44,0x00,0x00},
2068 {0x00,0x08,0x36,0x41,0x00,0x00,0x00,0x00},
2069 {0x00,0x00,0x7F,0x00,0x00,0x00,0x00,0x00},
2070 {0x00,0x41,0x36,0x08,0x00,0x00,0x00,0x00},
2071 {0x00,0x02,0x01,0x01,0x02,0x01,0x00,0x00},
2072 {0x00,0x02,0x05,0x05,0x02,0x00,0x00,0x00}
2077 #define LCD_COMMAND_MODE 0x80 2079 #define LCD_DATA_MODE 0x40 2081 #define LCD_COMMAND_DISPLAY_OFF 0xAE 2083 #define LCD_COMMAND_DISPLAY_ON 0xAF 2085 #define LCD_COMMAND_BLACK_BACKGROUND 0xA6 2087 #define LCD_COMMAND_WHITE_BACKGROUND 0xA7 2089 #define LCD_COMMAND_SET_BRIGHTNESS 0x81 2091 #define LCD_PAGE_ADDRESSING 0x02 2093 #define LCD_HORIZONTAL_ADDRESSING 0x00 2096 #define LCD_COMMAND_CHARGE_PUMP_SETTING 0x8d 2098 #define LCD_COMMAND_CHARGE_PUMP_ENABLE 0x14 2101 #define LCD_WIDTH 128 2105 #define LCD_HEIGHT 64 2109 #if EBOARD_NANO == 0 2118 inline bool clear(
void);
2120 inline void print(
const char* data);
2122 inline void print(
int data);
2132 inline bool reset(
void);
2135 inline bool init(
void);
2137 inline void drawBitmap(
const unsigned char *bitmap, byte posX, byte posY, byte hiX, byte hiY);
2141 inline bool setCursor(byte posX = 0x0, byte posY = 0x0);
2164 #if EBOARD_NANO == 0x0 2179 return this->
init();
2183 for(byte i = 0; i < 8; i++){
2186 for (byte j = 0; j < 128; j++)
2206 if(data[i] < 32 || data[i] > 127){ i++;
continue;}
2207 for (byte j = 0; j < 8; j++){
2214 char buffer[11] =
"";
2215 itoa(data,buffer,10);
2216 this->
print(line,col,buffer);
2225 return this->
clear();
2241 return this->
clear();
2243 inline void LCD::drawBitmap(
const unsigned char *bitmap, byte posX, byte posY, byte hiX, byte hiY){
2247 for(
int i = 0x0; i < (hiX * 8 * hiY); i++){
2248 this->
s1Dat(pgm_read_byte(&bitmap[i]));
2249 if(++col == (hiX * 8)) {
2262 this->
s2Cmd((0x00 + (8 *posX & 0x0F)),(0x10 + ((8 * posX >> 4) & 0x0F)));
2263 this->
pX = posX; this->
pY = posY;
2264 return this->
s1Cmd(0xB0 + posY);
2268 this->
s2Cmd(0x81,val);
2296 #if EBOARD_NEO > 0x0 2301 #define EBOARD_NEO_RGB ((0 << 6) | (0 << 4) | (1 << 2) | (2)) 2303 #define EBOARD_NEO_RBG ((0 << 6) | (0 << 4) | (2 << 2) | (1)) 2305 #define EBOARD_NEO_GRB ((1 << 6) | (1 << 4) | (0 << 2) | (2)) 2307 #define EBOARD_NEO_GBR ((2 << 6) | (2 << 4) | (0 << 2) | (1)) 2309 #define EBOARD_NEO_BRG ((1 << 6) | (1 << 4) | (2 << 2) | (0)) 2311 #define EBOARD_NEO_BGR ((2 << 6) | (2 << 4) | (1 << 2) | (0)) 2315 #define EBOARD_NEO_WRGB ((0 << 6) | (1 << 4) | (2 << 2) | (3)) 2317 #define EBOARD_NEO_WRBG ((0 << 6) | (1 << 4) | (3 << 2) | (2)) 2319 #define EBOARD_NEO_WGRB ((0 << 6) | (2 << 4) | (1 << 2) | (3)) 2321 #define EBOARD_NEO_WGBR ((0 << 6) | (3 << 4) | (1 << 2) | (2)) 2323 #define EBOARD_NEO_WBRG ((0 << 6) | (2 << 4) | (3 << 2) | (1)) 2325 #define EBOARD_NEO_WBGR ((0 << 6) | (3 << 4) | (2 << 2) | (1)) 2327 #define EBOARD_NEO_RWGB ((1 << 6) | (0 << 4) | (2 << 2) | (3)) 2329 #define EBOARD_NEO_RWBG ((1 << 6) | (0 << 4) | (3 << 2) | (2)) 2331 #define EBOARD_NEO_RGWB ((2 << 6) | (0 << 4) | (1 << 2) | (3)) 2333 #define EBOARD_NEO_RGBW ((3 << 6) | (0 << 4) | (1 << 2) | (2)) 2335 #define EBOARD_NEO_RBWG ((2 << 6) | (0 << 4) | (3 << 2) | (1)) 2337 #define EBOARD_NEO_RBGW ((3 << 6) | (0 << 4) | (2 << 2) | (1)) 2339 #define EBOARD_NEO_GWRB ((1 << 6) | (2 << 4) | (0 << 2) | (3)) 2341 #define EBOARD_NEO_GWBR ((1 << 6) | (3 << 4) | (0 << 2) | (2)) 2343 #define EBOARD_NEO_GRWB ((2 << 6) | (1 << 4) | (0 << 2) | (3)) 2345 #define EBOARD_NEO_GRBW ((3 << 6) | (1 << 4) | (0 << 2) | (2)) 2347 #define EBOARD_NEO_GBWR ((2 << 6) | (3 << 4) | (0 << 2) | (1)) 2349 #define EBOARD_NEO_GBRW ((3 << 6) | (2 << 4) | (0 << 2) | (1)) 2351 #define EBOARD_NEO_BWRG ((1 << 6) | (2 << 4) | (3 << 2) | (0)) 2353 #define EBOARD_NEO_BWGR ((1 << 6) | (3 << 4) | (2 << 2) | (0)) 2355 #define EBOARD_NEO_BRWG ((2 << 6) | (1 << 4) | (3 << 2) | (0)) 2357 #define EBOARD_NEO_BRGW ((3 << 6) | (1 << 4) | (2 << 2) | (0)) 2359 #define EBOARD_NEO_BGWR ((2 << 6) | (3 << 4) | (1 << 2) | (0)) 2361 #define EBOARD_NEO_BGRW ((3 << 6) | (2 << 4) | (1 << 2) | (0)) 2363 #define EBOARD_NEO_800KHZ 0x0000 2365 #define EBOARD_NEO_400KHZ 0x0100 2382 void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);
2384 void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w);
2400 inline int8_t
getPin(
void);
2404 static inline uint32_t
Color(uint8_t r, uint8_t g, uint8_t b);
2406 static inline uint32_t
Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w);
2430 #ifdef __AVR__ //not needed (rem?) 2432 volatile uint8_t *
port;
2439 begun(false), brightness(0),
pixels(NULL), endTime(0) {
2447 begun(false), numLEDs(0), numBytes(0), pin(-1), brightness(0),
pixels(NULL),
2449 {aOffset[0]=1;aOffset[1]=0;aOffset[2]=2;aOffset[3]=1;}
2452 if(
pin >= 0) pinMode(
pin, INPUT);
2456 pinMode(
pin, OUTPUT);
2457 digitalWrite(
pin, LOW);
2483 #if defined(ESP8266) 2485 extern "C" void ICACHE_RAM_ATTR espShow(
2486 uint8_t pin, uint8_t *
pixels, uint32_t numBytes, uint8_t type);
2487 #elif defined(ESP32) 2488 extern "C" void espShow(
2489 uint8_t pin, uint8_t *
pixels, uint32_t numBytes, uint8_t type);
2503 #if (F_CPU >= 7400000UL) && (F_CPU <= 9500000UL) 2505 volatile uint8_t n1, n2 = 0;
2507 #if defined(PORTB) || defined(PORTC) || defined(PORTF) 2508 if(
port == &PORTD) {
2513 if(b & 0x80) n1 = hi;
2517 "out %[port] , %[hi]" "\n\t" 2518 "mov %[n2] , %[lo]" "\n\t" 2519 "out %[port] , %[n1]" "\n\t" 2521 "sbrc %[byte] , 6" "\n\t" 2522 "mov %[n2] , %[hi]" "\n\t" 2523 "out %[port] , %[lo]" "\n\t" 2526 "out %[port] , %[hi]" "\n\t" 2527 "mov %[n1] , %[lo]" "\n\t" 2528 "out %[port] , %[n2]" "\n\t" 2530 "sbrc %[byte] , 5" "\n\t" 2531 "mov %[n1] , %[hi]" "\n\t" 2532 "out %[port] , %[lo]" "\n\t" 2535 "out %[port] , %[hi]" "\n\t" 2536 "mov %[n2] , %[lo]" "\n\t" 2537 "out %[port] , %[n1]" "\n\t" 2539 "sbrc %[byte] , 4" "\n\t" 2540 "mov %[n2] , %[hi]" "\n\t" 2541 "out %[port] , %[lo]" "\n\t" 2544 "out %[port] , %[hi]" "\n\t" 2545 "mov %[n1] , %[lo]" "\n\t" 2546 "out %[port] , %[n2]" "\n\t" 2548 "sbrc %[byte] , 3" "\n\t" 2549 "mov %[n1] , %[hi]" "\n\t" 2550 "out %[port] , %[lo]" "\n\t" 2553 "out %[port] , %[hi]" "\n\t" 2554 "mov %[n2] , %[lo]" "\n\t" 2555 "out %[port] , %[n1]" "\n\t" 2557 "sbrc %[byte] , 2" "\n\t" 2558 "mov %[n2] , %[hi]" "\n\t" 2559 "out %[port] , %[lo]" "\n\t" 2562 "out %[port] , %[hi]" "\n\t" 2563 "mov %[n1] , %[lo]" "\n\t" 2564 "out %[port] , %[n2]" "\n\t" 2566 "sbrc %[byte] , 1" "\n\t" 2567 "mov %[n1] , %[hi]" "\n\t" 2568 "out %[port] , %[lo]" "\n\t" 2571 "out %[port] , %[hi]" "\n\t" 2572 "mov %[n2] , %[lo]" "\n\t" 2573 "out %[port] , %[n1]" "\n\t" 2575 "sbrc %[byte] , 0" "\n\t" 2576 "mov %[n2] , %[hi]" "\n\t" 2577 "out %[port] , %[lo]" "\n\t" 2578 "sbiw %[count], 1" "\n\t" 2580 "out %[port] , %[hi]" "\n\t" 2581 "mov %[n1] , %[lo]" "\n\t" 2582 "out %[port] , %[n2]" "\n\t" 2583 "ld %[byte] , %a[ptr]+" "\n\t" 2584 "sbrc %[byte] , 7" "\n\t" 2585 "mov %[n1] , %[hi]" "\n\t" 2586 "out %[port] , %[lo]" "\n\t" 2592 : [
port]
"I" (_SFR_IO_ADDR(PORTD)),
2596 #if defined(PORTB) || defined(PORTC) || defined(PORTF) 2601 #if defined(PORTD) || defined(PORTC) || defined(PORTF) 2602 if(
port == &PORTB) {
2603 #endif // defined(PORTD/C/F) 2607 if(b & 0x80) n1 = hi;
2610 "out %[port] , %[hi]" "\n\t" 2611 "mov %[n2] , %[lo]" "\n\t" 2612 "out %[port] , %[n1]" "\n\t" 2614 "sbrc %[byte] , 6" "\n\t" 2615 "mov %[n2] , %[hi]" "\n\t" 2616 "out %[port] , %[lo]" "\n\t" 2618 "out %[port] , %[hi]" "\n\t" 2619 "mov %[n1] , %[lo]" "\n\t" 2620 "out %[port] , %[n2]" "\n\t" 2622 "sbrc %[byte] , 5" "\n\t" 2623 "mov %[n1] , %[hi]" "\n\t" 2624 "out %[port] , %[lo]" "\n\t" 2626 "out %[port] , %[hi]" "\n\t" 2627 "mov %[n2] , %[lo]" "\n\t" 2628 "out %[port] , %[n1]" "\n\t" 2630 "sbrc %[byte] , 4" "\n\t" 2631 "mov %[n2] , %[hi]" "\n\t" 2632 "out %[port] , %[lo]" "\n\t" 2634 "out %[port] , %[hi]" "\n\t" 2635 "mov %[n1] , %[lo]" "\n\t" 2636 "out %[port] , %[n2]" "\n\t" 2638 "sbrc %[byte] , 3" "\n\t" 2639 "mov %[n1] , %[hi]" "\n\t" 2640 "out %[port] , %[lo]" "\n\t" 2642 "out %[port] , %[hi]" "\n\t" 2643 "mov %[n2] , %[lo]" "\n\t" 2644 "out %[port] , %[n1]" "\n\t" 2646 "sbrc %[byte] , 2" "\n\t" 2647 "mov %[n2] , %[hi]" "\n\t" 2648 "out %[port] , %[lo]" "\n\t" 2650 "out %[port] , %[hi]" "\n\t" 2651 "mov %[n1] , %[lo]" "\n\t" 2652 "out %[port] , %[n2]" "\n\t" 2654 "sbrc %[byte] , 1" "\n\t" 2655 "mov %[n1] , %[hi]" "\n\t" 2656 "out %[port] , %[lo]" "\n\t" 2658 "out %[port] , %[hi]" "\n\t" 2659 "mov %[n2] , %[lo]" "\n\t" 2660 "out %[port] , %[n1]" "\n\t" 2662 "sbrc %[byte] , 0" "\n\t" 2663 "mov %[n2] , %[hi]" "\n\t" 2664 "out %[port] , %[lo]" "\n\t" 2665 "sbiw %[count], 1" "\n\t" 2666 "out %[port] , %[hi]" "\n\t" 2667 "mov %[n1] , %[lo]" "\n\t" 2668 "out %[port] , %[n2]" "\n\t" 2669 "ld %[byte] , %a[ptr]+" "\n\t" 2670 "sbrc %[byte] , 7" "\n\t" 2671 "mov %[n1] , %[hi]" "\n\t" 2672 "out %[port] , %[lo]" "\n\t" 2674 : [byte]
"+r" (b), [n1]
"+r" (n1), [n2]
"+r" (n2), [count]
"+w" (i)
2675 : [
port]
"I" (_SFR_IO_ADDR(PORTB)), [ptr]
"e" (ptr), [hi]
"r" (hi),
2677 #if defined(PORTD) || defined(PORTC) || defined(PORTF) 2680 #if defined(PORTC) || defined(PORTF) 2685 #if defined(PORTD) || defined(PORTB) || defined(PORTF) 2686 if(
port == &PORTC) {
2691 if(b & 0x80) n1 = hi;
2694 "out %[port] , %[hi]" "\n\t" 2695 "mov %[n2] , %[lo]" "\n\t" 2696 "out %[port] , %[n1]" "\n\t" 2698 "sbrc %[byte] , 6" "\n\t" 2699 "mov %[n2] , %[hi]" "\n\t" 2700 "out %[port] , %[lo]" "\n\t" 2702 "out %[port] , %[hi]" "\n\t" 2703 "mov %[n1] , %[lo]" "\n\t" 2704 "out %[port] , %[n2]" "\n\t" 2706 "sbrc %[byte] , 5" "\n\t" 2707 "mov %[n1] , %[hi]" "\n\t" 2708 "out %[port] , %[lo]" "\n\t" 2710 "out %[port] , %[hi]" "\n\t" 2711 "mov %[n2] , %[lo]" "\n\t" 2712 "out %[port] , %[n1]" "\n\t" 2714 "sbrc %[byte] , 4" "\n\t" 2715 "mov %[n2] , %[hi]" "\n\t" 2716 "out %[port] , %[lo]" "\n\t" 2718 "out %[port] , %[hi]" "\n\t" 2719 "mov %[n1] , %[lo]" "\n\t" 2720 "out %[port] , %[n2]" "\n\t" 2722 "sbrc %[byte] , 3" "\n\t" 2723 "mov %[n1] , %[hi]" "\n\t" 2724 "out %[port] , %[lo]" "\n\t" 2726 "out %[port] , %[hi]" "\n\t" 2727 "mov %[n2] , %[lo]" "\n\t" 2728 "out %[port] , %[n1]" "\n\t" 2730 "sbrc %[byte] , 2" "\n\t" 2731 "mov %[n2] , %[hi]" "\n\t" 2732 "out %[port] , %[lo]" "\n\t" 2734 "out %[port] , %[hi]" "\n\t" 2735 "mov %[n1] , %[lo]" "\n\t" 2736 "out %[port] , %[n2]" "\n\t" 2738 "sbrc %[byte] , 1" "\n\t" 2739 "mov %[n1] , %[hi]" "\n\t" 2740 "out %[port] , %[lo]" "\n\t" 2742 "out %[port] , %[hi]" "\n\t" 2743 "mov %[n2] , %[lo]" "\n\t" 2744 "out %[port] , %[n1]" "\n\t" 2746 "sbrc %[byte] , 0" "\n\t" 2747 "mov %[n2] , %[hi]" "\n\t" 2748 "out %[port] , %[lo]" "\n\t" 2749 "sbiw %[count], 1" "\n\t" 2750 "out %[port] , %[hi]" "\n\t" 2751 "mov %[n1] , %[lo]" "\n\t" 2752 "out %[port] , %[n2]" "\n\t" 2753 "ld %[byte] , %a[ptr]+" "\n\t" 2754 "sbrc %[byte] , 7" "\n\t" 2755 "mov %[n1] , %[hi]" "\n\t" 2756 "out %[port] , %[lo]" "\n\t" 2758 : [byte]
"+r" (b), [n1]
"+r" (n1), [n2]
"+r" (n2), [count]
"+w" (i)
2759 : [
port]
"I" (_SFR_IO_ADDR(PORTC)), [ptr]
"e" (ptr), [hi]
"r" (hi),
2761 #if defined(PORTD) || defined(PORTB) || defined(PORTF) 2769 #if defined(PORTD) || defined(PORTB) || defined(PORTC) 2770 if(
port == &PORTF) {
2771 #endif // defined(PORTD/B/C) 2775 if(b & 0x80) n1 = hi;
2778 "out %[port] , %[hi]" "\n\t" 2779 "mov %[n2] , %[lo]" "\n\t" 2780 "out %[port] , %[n1]" "\n\t" 2782 "sbrc %[byte] , 6" "\n\t" 2783 "mov %[n2] , %[hi]" "\n\t" 2784 "out %[port] , %[lo]" "\n\t" 2786 "out %[port] , %[hi]" "\n\t" 2787 "mov %[n1] , %[lo]" "\n\t" 2788 "out %[port] , %[n2]" "\n\t" 2790 "sbrc %[byte] , 5" "\n\t" 2791 "mov %[n1] , %[hi]" "\n\t" 2792 "out %[port] , %[lo]" "\n\t" 2794 "out %[port] , %[hi]" "\n\t" 2795 "mov %[n2] , %[lo]" "\n\t" 2796 "out %[port] , %[n1]" "\n\t" 2798 "sbrc %[byte] , 4" "\n\t" 2799 "mov %[n2] , %[hi]" "\n\t" 2800 "out %[port] , %[lo]" "\n\t" 2802 "out %[port] , %[hi]" "\n\t" 2803 "mov %[n1] , %[lo]" "\n\t" 2804 "out %[port] , %[n2]" "\n\t" 2806 "sbrc %[byte] , 3" "\n\t" 2807 "mov %[n1] , %[hi]" "\n\t" 2808 "out %[port] , %[lo]" "\n\t" 2810 "out %[port] , %[hi]" "\n\t" 2811 "mov %[n2] , %[lo]" "\n\t" 2812 "out %[port] , %[n1]" "\n\t" 2814 "sbrc %[byte] , 2" "\n\t" 2815 "mov %[n2] , %[hi]" "\n\t" 2816 "out %[port] , %[lo]" "\n\t" 2818 "out %[port] , %[hi]" "\n\t" 2819 "mov %[n1] , %[lo]" "\n\t" 2820 "out %[port] , %[n2]" "\n\t" 2822 "sbrc %[byte] , 1" "\n\t" 2823 "mov %[n1] , %[hi]" "\n\t" 2824 "out %[port] , %[lo]" "\n\t" 2826 "out %[port] , %[hi]" "\n\t" 2827 "mov %[n2] , %[lo]" "\n\t" 2828 "out %[port] , %[n1]" "\n\t" 2830 "sbrc %[byte] , 0" "\n\t" 2831 "mov %[n2] , %[hi]" "\n\t" 2832 "out %[port] , %[lo]" "\n\t" 2833 "sbiw %[count], 1" "\n\t" 2834 "out %[port] , %[hi]" "\n\t" 2835 "mov %[n1] , %[lo]" "\n\t" 2836 "out %[port] , %[n2]" "\n\t" 2837 "ld %[byte] , %a[ptr]+" "\n\t" 2838 "sbrc %[byte] , 7" "\n\t" 2839 "mov %[n1] , %[hi]" "\n\t" 2840 "out %[port] , %[lo]" "\n\t" 2842 : [byte]
"+r" (b), [n1]
"+r" (n1), [n2]
"+r" (n2), [count]
"+w" (i)
2843 : [
port]
"I" (_SFR_IO_ADDR(PORTF)), [ptr]
"e" (ptr), [hi]
"r" (hi),
2845 #if defined(PORTD) || defined(PORTB) || defined(PORTC) 2847 #endif // defined(PORTD/B/C) 2848 #endif // defined(PORTF) 2850 volatile uint8_t next, bit;
2857 "st %a[port], %[hi]" "\n\t" 2858 "sbrc %[byte] , 7" "\n\t" 2859 "mov %[next], %[hi]" "\n\t" 2860 "st %a[port], %[next]" "\n\t" 2861 "mov %[next] , %[lo]" "\n\t" 2863 "breq nextbyte20" "\n\t" 2864 "rol %[byte]" "\n\t" 2865 "st %a[port], %[lo]" "\n\t" 2869 "rjmp head20" "\n\t" 2870 "nextbyte20:" "\n\t" 2871 "st %a[port], %[lo]" "\n\t" 2873 "ldi %[bit] , 8" "\n\t" 2874 "ld %[byte] , %a[ptr]+" "\n\t" 2875 "sbiw %[count], 1" "\n\t" 2886 #elif (F_CPU >= 11100000UL) && (F_CPU <= 14300000UL) 2888 volatile uint8_t next;
2891 #if defined(PORTB) || defined(PORTC) || defined(PORTF) 2892 if(
port == &PORTD) {
2897 if(b & 0x80) next = hi;
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" 2906 "out %[port], %[hi]" "\n\t" 2907 "rcall bitTimeD" "\n\t" 2908 "out %[port], %[hi]" "\n\t" 2909 "rcall bitTimeD" "\n\t" 2910 "out %[port], %[hi]" "\n\t" 2911 "rcall bitTimeD" "\n\t" 2912 "out %[port], %[hi]" "\n\t" 2913 "rcall bitTimeD" "\n\t" 2915 "out %[port] , %[hi]" "\n\t" 2917 "ld %[byte] , %a[ptr]+" "\n\t" 2918 "out %[port] , %[next]" "\n\t" 2919 "mov %[next] , %[lo]" "\n\t" 2920 "sbrc %[byte] , 7" "\n\t" 2921 "mov %[next] , %[hi]" "\n\t" 2923 "out %[port] , %[lo]" "\n\t" 2924 "sbiw %[count], 1" "\n\t" 2928 "out %[port], %[next]" "\n\t" 2929 "mov %[next], %[lo]" "\n\t" 2930 "rol %[byte]" "\n\t" 2931 "sbrc %[byte], 7" "\n\t" 2932 "mov %[next], %[hi]" "\n\t" 2934 "out %[port], %[lo]" "\n\t" 2940 : [
port]
"I" (_SFR_IO_ADDR(PORTD)),
2944 #if defined(PORTB) || defined(PORTC) || defined(PORTF) 2949 #if defined(PORTD) || defined(PORTC) || defined(PORTF) 2950 if(
port == &PORTB) {
2955 if(b & 0x80) next = hi;
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" 2965 "rcall bitTimeB" "\n\t" 2966 "out %[port], %[hi]" "\n\t" 2967 "rcall bitTimeB" "\n\t" 2968 "out %[port], %[hi]" "\n\t" 2969 "rcall bitTimeB" "\n\t" 2970 "out %[port], %[hi]" "\n\t" 2971 "rcall bitTimeB" "\n\t" 2972 "out %[port] , %[hi]" "\n\t" 2974 "ld %[byte] , %a[ptr]+" "\n\t" 2975 "out %[port] , %[next]" "\n\t" 2976 "mov %[next] , %[lo]" "\n\t" 2977 "sbrc %[byte] , 7" "\n\t" 2978 "mov %[next] , %[hi]" "\n\t" 2980 "out %[port] , %[lo]" "\n\t" 2981 "sbiw %[count], 1" "\n\t" 2985 "out %[port], %[next]" "\n\t" 2986 "mov %[next], %[lo]" "\n\t" 2987 "rol %[byte]" "\n\t" 2988 "sbrc %[byte], 7" "\n\t" 2989 "mov %[next], %[hi]" "\n\t" 2991 "out %[port], %[lo]" "\n\t" 2994 : [byte]
"+r" (b), [next]
"+r" (next), [count]
"+w" (i)
2995 : [
port]
"I" (_SFR_IO_ADDR(PORTB)), [ptr]
"e" (ptr), [hi]
"r" (hi),
2997 #if defined(PORTD) || defined(PORTC) || defined(PORTF) 3000 #if defined(PORTC) || defined(PORTF) 3005 #if defined(PORTD) || defined(PORTB) || defined(PORTF) 3006 if(
port == &PORTC) {
3011 if(b & 0x80) next = hi;
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" 3021 "rcall bitTimeC" "\n\t" 3022 "out %[port], %[hi]" "\n\t" 3023 "rcall bitTimeC" "\n\t" 3024 "out %[port], %[hi]" "\n\t" 3025 "rcall bitTimeC" "\n\t" 3026 "out %[port], %[hi]" "\n\t" 3027 "rcall bitTimeC" "\n\t" 3028 "out %[port] , %[hi]" "\n\t" 3030 "ld %[byte] , %a[ptr]+" "\n\t" 3031 "out %[port] , %[next]" "\n\t" 3032 "mov %[next] , %[lo]" "\n\t" 3033 "sbrc %[byte] , 7" "\n\t" 3034 "mov %[next] , %[hi]" "\n\t" 3036 "out %[port] , %[lo]" "\n\t" 3037 "sbiw %[count], 1" "\n\t" 3041 "out %[port], %[next]" "\n\t" 3042 "mov %[next], %[lo]" "\n\t" 3043 "rol %[byte]" "\n\t" 3044 "sbrc %[byte], 7" "\n\t" 3045 "mov %[next], %[hi]" "\n\t" 3047 "out %[port], %[lo]" "\n\t" 3050 : [byte]
"+r" (b), [next]
"+r" (next), [count]
"+w" (i)
3051 : [
port]
"I" (_SFR_IO_ADDR(PORTC)), [ptr]
"e" (ptr), [hi]
"r" (hi),
3053 #if defined(PORTD) || defined(PORTB) || defined(PORTF) 3061 #if defined(PORTD) || defined(PORTB) || defined(PORTC) 3062 if(
port == &PORTF) {
3067 if(b & 0x80) next = hi;
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" 3077 "rcall bitTimeC" "\n\t" 3078 "out %[port], %[hi]" "\n\t" 3079 "rcall bitTimeC" "\n\t" 3080 "out %[port], %[hi]" "\n\t" 3081 "rcall bitTimeC" "\n\t" 3082 "out %[port], %[hi]" "\n\t" 3083 "rcall bitTimeC" "\n\t" 3084 "out %[port] , %[hi]" "\n\t" 3086 "ld %[byte] , %a[ptr]+" "\n\t" 3087 "out %[port] , %[next]" "\n\t" 3088 "mov %[next] , %[lo]" "\n\t" 3089 "sbrc %[byte] , 7" "\n\t" 3090 "mov %[next] , %[hi]" "\n\t" 3092 "out %[port] , %[lo]" "\n\t" 3093 "sbiw %[count], 1" "\n\t" 3097 "out %[port], %[next]" "\n\t" 3098 "mov %[next], %[lo]" "\n\t" 3099 "rol %[byte]" "\n\t" 3100 "sbrc %[byte], 7" "\n\t" 3101 "mov %[next], %[hi]" "\n\t" 3103 "out %[port], %[lo]" "\n\t" 3106 : [byte]
"+r" (b), [next]
"+r" (next), [count]
"+w" (i)
3107 : [
port]
"I" (_SFR_IO_ADDR(PORTF)), [ptr]
"e" (ptr), [hi]
"r" (hi),
3109 #if defined(PORTD) || defined(PORTB) || defined(PORTC) 3114 volatile uint8_t next, bit;
3121 "st %a[port], %[hi]" "\n\t" 3122 "sbrc %[byte] , 7" "\n\t" 3123 "mov %[next], %[hi]" "\n\t" 3125 "st %a[port], %[next]" "\n\t" 3130 "st %a[port], %[lo]" "\n\t" 3133 "breq nextbyte30" "\n\t" 3134 "rol %[byte]" "\n\t" 3138 "rjmp head30" "\n\t" 3139 "nextbyte30:" "\n\t" 3141 "ldi %[bit] , 8" "\n\t" 3142 "ld %[byte] , %a[ptr]+" "\n\t" 3143 "sbiw %[count], 1" "\n\t" 3154 #elif (F_CPU >= 15400000UL) && (F_CPU <= 19000000L) 3156 volatile uint8_t next, bit;
3163 "st %a[port], %[hi]" "\n\t" 3164 "sbrc %[byte], 7" "\n\t" 3165 "mov %[next], %[hi]" "\n\t" 3167 "st %a[port], %[next]" "\n\t" 3168 "mov %[next] , %[lo]" "\n\t" 3169 "breq nextbyte20" "\n\t" 3170 "rol %[byte]" "\n\t" 3173 "st %a[port], %[lo]" "\n\t" 3176 "rjmp head20" "\n\t" 3177 "nextbyte20:" "\n\t" 3178 "ldi %[bit] , 8" "\n\t" 3179 "ld %[byte] , %a[ptr]+" "\n\t" 3180 "st %a[port], %[lo]" "\n\t" 3182 "sbiw %[count], 1" "\n\t" 3193 volatile uint8_t next, bit;
3200 "st %a[port], %[hi]" "\n\t" 3201 "sbrc %[byte] , 7" "\n\t" 3202 "mov %[next] , %[hi]" "\n\t" 3205 "st %a[port], %[next]" "\n\t" 3211 "st %a[port], %[lo]" "\n\t" 3213 "mov %[next] , %[lo]" "\n\t" 3215 "breq nextbyte40" "\n\t" 3216 "rol %[byte]" "\n\t" 3223 "rjmp head40" "\n\t" 3224 "nextbyte40:" "\n\t" 3225 "ldi %[bit] , 8" "\n\t" 3226 "ld %[byte] , %a[ptr]+" "\n\t" 3228 "st %a[port], %[lo]" "\n\t" 3230 "sbiw %[count], 1" "\n\t" 3242 #error "CPU SPEED NOT SUPPORTED" 3244 #elif defined(__arm__) 3245 #if defined(TEENSYDUINO) && defined(KINETISK) // Teensy 3.0, 3.1, 3.2, 3.5, 3.6 3246 #define CYCLES_800_T0H (F_CPU / 4000000) 3247 #define CYCLES_800_T1H (F_CPU / 1250000) 3248 #define CYCLES_800 (F_CPU / 800000) 3249 #define CYCLES_400_T0H (F_CPU / 2000000) 3250 #define CYCLES_400_T1H (F_CPU / 833333) 3251 #define CYCLES_400 (F_CPU / 400000) 3254 volatile uint8_t *
set = portSetRegister(
pin),
3255 *clr = portClearRegister(
pin);
3257 ARM_DEMCR |= ARM_DEMCR_TRCENA;
3258 ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;
3260 cyc = ARM_DWT_CYCCNT + CYCLES_800;
3263 for(mask = 0x80; mask; mask >>= 1) {
3264 while(ARM_DWT_CYCCNT - cyc < CYCLES_800);
3265 cyc = ARM_DWT_CYCCNT;
3268 while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T1H);
3270 while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T0H);
3275 while(ARM_DWT_CYCCNT - cyc < CYCLES_800);
3277 cyc = ARM_DWT_CYCCNT + CYCLES_400;
3280 for(mask = 0x80; mask; mask >>= 1) {
3281 while(ARM_DWT_CYCCNT - cyc < CYCLES_400);
3282 cyc = ARM_DWT_CYCCNT;
3285 while(ARM_DWT_CYCCNT - cyc < CYCLES_400_T1H);
3287 while(ARM_DWT_CYCCNT - cyc < CYCLES_400_T0H);
3292 while(ARM_DWT_CYCCNT - cyc < CYCLES_400);
3295 #error "Sorry, only 48 MHz is supported, please set Tools > CPU Speed to 48 MHz" 3297 #elif defined(ESP8266) || defined(ESP32) 3299 #elif defined(__ARDUINO_ARC__) 3301 #define NOPx7 { __builtin_arc_nop(); \ 3302 __builtin_arc_nop(); __builtin_arc_nop(); \ 3303 __builtin_arc_nop(); __builtin_arc_nop(); \ 3304 __builtin_arc_nop(); __builtin_arc_nop(); } 3305 PinDescription *pindesc = &g_APinDescription[
pin];
3307 register uint8_t *p =
pixels;
3308 register uint32_t currByte = (uint32_t) (*p);
3309 register uint32_t currBit = 0x80 & currByte;
3310 register uint32_t bitCounter = 0;
3311 register uint32_t first = 1;
3312 if (pindesc->ulGPIOType == SS_GPIO) {
3313 register uint32_t reg = pindesc->ulGPIOBase + SS_GPIO_SWPORTA_DR;
3314 uint32_t reg_val = __builtin_arc_lr((
volatile uint32_t)reg);
3315 register uint32_t reg_bit_high = reg_val | (1 << pindesc->ulGPIOId);
3316 register uint32_t reg_bit_low = reg_val & ~(1 << pindesc->ulGPIOId);
3324 __builtin_arc_sr(first ? reg_bit_low : reg_bit_high, (
volatile uint32_t)reg);
3331 __builtin_arc_nop();
3333 __builtin_arc_sr(reg_bit_low, (
volatile uint32_t)reg);
3336 if(bitCounter >= 8) {
3338 currByte = (uint32_t) (*++p);
3340 currBit = 0x80 & currByte;
3343 }
else if(pindesc->ulGPIOType == SOC_GPIO) {
3344 register uint32_t reg = pindesc->ulGPIOBase + SOC_GPIO_SWPORTA_DR;
3345 uint32_t reg_val = MMIO_REG_VAL(reg);
3346 register uint32_t reg_bit_high = reg_val | (1 << pindesc->ulGPIOId);
3347 register uint32_t reg_bit_low = reg_val & ~(1 << pindesc->ulGPIOId);
3354 MMIO_REG_VAL(reg) = first ? reg_bit_low : reg_bit_high;
3358 __builtin_arc_nop();
3363 MMIO_REG_VAL(reg) = reg_bit_low;
3366 if(bitCounter >= 8) {
3368 currByte = (uint32_t) (*++p);
3370 currBit = 0x80 & currByte;
3375 #error Architecture not supported 3385 digitalWrite(p, LOW);
3388 port = portOutputRegister(digitalPinToPort(p));
3389 pinMask = digitalPinToBitMask(p);
3393 uint16_t n, uint8_t r, uint8_t g, uint8_t b) {
3413 uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w) {
3436 r = (uint8_t)(c >> 16),
3437 g = (uint8_t)(c >> 8),
3448 uint8_t w = (uint8_t)(c >> 24);
3457 return ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
3459 uint32_t
NeoPixel::Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w) {
3460 return ((uint32_t)w << 24) | ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
3472 return ((uint32_t)p[
aOffset[0]] << 16) |
3473 ((uint32_t)p[
aOffset[1]] << 8) |
3484 return ((uint32_t)p[
aOffset[3]] << 24) |
3485 ((uint32_t)p[
aOffset[0]] << 16) |
3486 ((uint32_t)p[
aOffset[1]] << 8) |
3498 uint8_t newBrightness = b + 1;
3504 if(oldBrightness == 0) scale = 0;
3505 else if(b == 255) scale = 65535 / oldBrightness;
3506 else scale = (((uint16_t)newBrightness << 8) - 1) / oldBrightness;
3507 for(uint16_t i=0; i<
numBytes; i++) {
3509 *ptr++ = (c * scale) >> 8;
3537 #if EBOARD_NANO > 0x0 || defined(DOC) 3539 #if EBOARD_GUESSPATH > 0x0 3544 typedef enum { _timer1, _Nbr_16timers } timer16_Sequence_t;
3545 #define MIN_PULSE_WIDTH 544 // the shortest pulse sent to a servo 3546 #define MAX_PULSE_WIDTH 2400 // the longest pulse sent to a servo 3547 #define DEFAULT_PULSE_WIDTH 1500 // default pulse width when servo is attached 3548 #define REFRESH_INTERVAL 20000 // minumim time to refresh servos in microseconds 3549 #define SERVOS_PER_TIMER 12 // the maximum number of servos controlled by one timer 3550 #define MAX_SERVOS (_Nbr_16timers * SERVOS_PER_TIMER) 3551 #define INVALID_SERVO 255 // flag indicating an invalid servo index 3554 uint8_t isActive :1 ;
3558 volatile unsigned int ticks;
3563 uint8_t attach(
int pin);
3564 uint8_t attach(
int pin,
int min,
int max);
3566 void write(
int value);
3567 void writeMicroseconds(
int value);
3569 int readMicroseconds();
3570 inline bool attached();
3576 #define usToTicks(_us) (( clockCyclesPerMicrosecond()* _us) / 8) // converts microseconds to tick (assumes prescale of 8) // 12 Aug 2009 3577 #define ticksToUs(_ticks) (( (unsigned)_ticks * 8)/ clockCyclesPerMicrosecond() ) // converts from ticks back to microseconds 3578 #define TRIM_DURATION 2 // compensation ticks to trim adjust for digitalWrite delays // 12 August 2009 3580 static servo_t servos[MAX_SERVOS];
3581 static volatile int8_t Channel[_Nbr_16timers ];
3582 uint8_t ServoCount = 0;
3584 #define SERVO_INDEX_TO_TIMER(_servo_nbr) ((timer16_Sequence_t)(_servo_nbr / SERVOS_PER_TIMER)) // returns the timer controlling this servo 3585 #define SERVO_INDEX_TO_CHANNEL(_servo_nbr) (_servo_nbr % SERVOS_PER_TIMER) // returns the index of the servo on this timer 3586 #define SERVO_INDEX(_timer,_channel) ((_timer*SERVOS_PER_TIMER) + _channel) // macro to access servo index by timer and channel 3587 #define SERVO(_timer,_channel) (servos[SERVO_INDEX(_timer,_channel)]) // macro to access servo class by timer and channel 3588 #define SERVO_MIN() (MIN_PULSE_WIDTH - this->min * 4) // minimum value in uS for this servo 3589 #define SERVO_MAX() (MAX_PULSE_WIDTH - this->max * 4) // maximum value in uS for this servo 3590 static inline void handle_interrupts(timer16_Sequence_t timer,
volatile uint16_t *TCNTn,
volatile uint16_t* OCRnA)
3592 if( Channel[timer] < 0 )
3595 if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && SERVO(timer,Channel[timer]).Pin.isActive ==
true )
3596 digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,LOW);
3599 if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) {
3600 *OCRnA = *TCNTn + SERVO(timer,Channel[timer]).ticks;
3601 if(SERVO(timer,Channel[timer]).Pin.isActive ==
true)
3602 digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,HIGH);
3606 if( ((
unsigned)*TCNTn) + 4 < usToTicks(REFRESH_INTERVAL) )
3607 *OCRnA = (
unsigned int)usToTicks(REFRESH_INTERVAL);
3609 *OCRnA = *TCNTn + 4;
3610 Channel[timer] = -1;
3613 #ifndef WIRING // Wiring pre-defines signal handlers so don't define any if compiling for the Wiring platform 3615 #if defined(_useTimer1) 3616 SIGNAL (TIMER1_COMPA_vect)
3618 handle_interrupts(_timer1, &TCNT1, &OCR1A);
3621 #elif defined WIRING 3623 #if defined(_useTimer1) 3624 void Timer1Service()
3626 handle_interrupts(_timer1, &TCNT1, &OCR1A);
3630 static void initISR(timer16_Sequence_t timer) {
3631 if(timer == _timer1) {
3635 TIFR1 |= _BV(OCF1A);
3636 TIMSK1 |= _BV(OCIE1A) ;
3638 timerAttach(TIMER1OUTCOMPAREA_INT, Timer1Service);
3642 static void finISR(timer16_Sequence_t timer) {
3643 #if defined WIRING // Wiring 3644 if(timer == _timer1) {
3645 TIMSK &= ~_BV(OCIE1A) ;
3646 timerDetach(TIMER1OUTCOMPAREA_INT);
3648 else if(timer == _timer3) {
3649 ETIMSK &= ~_BV(OCIE3A);
3650 timerDetach(TIMER3OUTCOMPAREA_INT);
3657 static boolean isTimerActive(timer16_Sequence_t timer) {
3659 for(uint8_t channel=0; channel < SERVOS_PER_TIMER; channel++) {
3660 if(SERVO(timer,channel).Pin.isActive ==
true)
3666 if( ServoCount < MAX_SERVOS) {
3667 this->servoIndex = ServoCount++;
3668 servos[this->servoIndex].ticks = usToTicks(DEFAULT_PULSE_WIDTH);
3671 this->servoIndex = INVALID_SERVO ;
3673 uint8_t Servo::attach(
int pin) {
3674 return this->attach(pin, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
3676 uint8_t Servo::attach(
int pin,
int min,
int max) {
3677 if(this->servoIndex < MAX_SERVOS ) {
3678 pinMode( pin, OUTPUT) ;
3679 servos[this->servoIndex].Pin.nbr = pin;
3681 this->min = (MIN_PULSE_WIDTH - min)/4;
3682 this->max = (MAX_PULSE_WIDTH - max)/4;
3684 timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
3685 if(isTimerActive(timer) ==
false)
3687 servos[this->servoIndex].Pin.isActive =
true;
3689 return this->servoIndex ;
3691 void Servo::detach() {
3692 servos[this->servoIndex].Pin.isActive =
false;
3693 timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
3694 if(isTimerActive(timer) ==
false) {
3698 void Servo::write(
int value) {
3699 if(value < MIN_PULSE_WIDTH)
3701 if(value < 0) value = 0;
3702 if(value > 180) value = 180;
3703 value = map(value, 0, 180, SERVO_MIN(), SERVO_MAX());
3705 this->writeMicroseconds(value);
3707 void Servo::writeMicroseconds(
int value) {
3709 byte channel = this->servoIndex;
3710 if( (channel < MAX_SERVOS) )
3712 if( value < SERVO_MIN() )
3713 value = SERVO_MIN();
3714 else if( value > SERVO_MAX() )
3715 value = SERVO_MAX();
3716 value = value - TRIM_DURATION;
3717 value = usToTicks(value);
3718 uint8_t oldSREG = SREG;
3720 servos[channel].ticks = value;
3724 inline int Servo::read()
3726 return map( this->readMicroseconds()+1, SERVO_MIN(), SERVO_MAX(), 0, 180);
3728 int Servo::readMicroseconds() {
3729 unsigned int pulsewidth;
3730 if( this->servoIndex != INVALID_SERVO )
3731 pulsewidth = ticksToUs(servos[this->servoIndex].ticks) + TRIM_DURATION ;
3736 inline bool Servo::attached() {
3737 return servos[this->servoIndex].Pin.isActive ;
3742 #if EBOARD_COPY_AND_PASTE > 0x0 3752 #if EBOARD_NANO > 0x0 3753 Servo mainMotor,steerMotor;
3757 ISR(TIMER2_OVF_vect) {
3765 TCNT2 = 256 - (int)((
float)F_CPU * 0.001 / 64);
3775 #if EBOARD_NANO == 0x0 3779 #if EBOARD_DEBUG_MODE > 0x0 3783 #if (EBOARD_NANO == 0x0) || defined(REPT_TASK) 3785 TIMSK2 &= ~(1<<TOIE2);
3786 TCCR2A &= ~((1<<WGM21) | (1<<WGM20));
3787 TCCR2B &= ~(1<<WGM22);
3789 TIMSK2 &= ~(1<<OCIE2A);
3790 TCCR2B |= (1<<CS22);
3791 TCCR2B &= ~((1<<CS21) | (1<<CS20));
3792 TCNT2 = 256 - (int)((
float)F_CPU * 0.001 / 64);
3793 TIMSK2 |= (1<<TOIE2);
3796 #if EBOARD_BLUETOOTH > 0x0 3799 #if (EBOARD_BLUETOOTH > 0x0) && (((PIN_BLUETOOTH_RX==0x13) && (PIN_BLUETOOTH_TX==0x12)) && defined(__AVR_ATmega2560__)) 3800 Serial1.begin(38400);
3806 #if EBOARD_I2C > 0x0 3809 #if EBOARD_SHIFT_REGISTER > 0x0 3815 #if EBOARD_USE_SPI > 0x0 && (EBOARD_NANO == 0) 3818 #if EBOARD_NANO > 0x0 3821 #if EBOARD_DEBUG_MODE > 0x0 3822 Serial.println(
"Initializing main driving motor (3s)");
3824 mainMotor.write(90);
3826 #if EBOARD_DEBUG_MODE > 0x0 3827 Serial.println(
"Initializing of main driving motor completed");
3830 #if EBOARD_DEBUG_MODE > 0x0 3832 Serial.println(
"fin");
3838 #if EBOARD_NANO > 0x0 3839 mainMotor.write(90);
3842 #if EBOARD_NANO == 0x0 3855 #if EBOARD_NANO > 0x0 || defined(DOC) 3862 if(spe < 0 || spe > 180)
return;
3863 mainMotor.write(spe);
3866 if(ang < 0 || ang > 180)
return;
3867 steerMotor.write(ang);
3872 #error This library is build for arduino-devices and should be used only in the Arduino IDE or with a similar linking process 3874 #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
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 ;)
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 hardwareID of this AX-12 Servo and will continue speaking to the new [reconnection recomme...
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...