Полезные алгоритмы Arduino. Обновляемая статья!

void pinModeFast(uint8_t pin, uint8_t mode) {
  switch (mode) {
    case INPUT:
      if (pin < 8) {
        bitClear(DDRD, pin);		
        bitClear(PORTD, pin);
      } else if (pin < 14) {
        bitClear(DDRB, (pin - 8));
        bitClear(PORTB, (pin - 8));
      } else if (pin < 20) {
        bitClear(DDRC, (pin - 14));	 // Mode: INPUT
        bitClear(PORTC, (pin - 14));  // State: LOW
      }
      return;
    case OUTPUT:
      if (pin < 8) {
        bitSet(DDRD, pin);
        bitClear(PORTD, pin);
      } else if (pin < 14) {
        bitSet(DDRB, (pin - 8));
        bitClear(PORTB, (pin - 8));
      } else if (pin < 20) {
        bitSet(DDRC, (pin - 14));	// Mode: OUTPUT
        bitClear(PORTC, (pin - 14));	// State: LOW
      }
      return;
    case INPUT_PULLUP:
      if (pin < 8) {
        bitClear(DDRD, pin);
        bitSet(PORTD, pin);
      } else if (pin < 14) {
        bitClear(DDRB, (pin - 8));
        bitSet(PORTB, (pin - 8));
      } else if (pin < 20) {
        bitClear(DDRC, (pin - 14));	// Mode: OUTPUT
        bitSet(PORTC, (pin - 14));	// State: HIGH
      }
      return;
  }
}

void digitalWriteFast(uint8_t pin, bool x) {
  // раскомментируй, чтобы отключать таймер
  /*switch (pin) {						
    case 3: bitClear(TCCR2A, COM2B1);
      break;
    case 5: bitClear(TCCR0A, COM0B1);
      break;
    case 6: bitClear(TCCR0A, COM0A1);
      break;
    case 9: bitClear(TCCR1A, COM1A1);
      break;
    case 10: bitClear(TCCR1A, COM1B1);
      break;
    case 11: bitClear(TCCR2A, COM2A1); 	// PWM disable 
      break;
  }*/

  if (pin < 8) {
    bitWrite(PORTD, pin, x);
  } else if (pin < 14) {
    bitWrite(PORTB, (pin - 8), x);
  } else if (pin < 20) {
    bitWrite(PORTC, (pin - 14), x);		// Set pin to HIGH / LOW 
  }
}

// быстро инвертирует состояние пина
void digitalToggleFast(uint8_t pin) {
  if (pin < 8) {
    bitSet(PIND, pin);
  } else if (pin < 14) {
    bitSet(PINB, (pin - 8));
  } else if (pin < 20) {
    bitSet(PINC, (pin - 14));		// Toggle pin state (for 'tone()')
  }
}

bool digitalReadFast(uint8_t pin) {
  if (pin < 8) {
    return bitRead(PIND, pin);
  } else if (pin < 14) {
    return bitRead(PINB, pin - 8);
  } else if (pin < 20) {
    return bitRead(PINC, pin - 14);		// Return pin state
  }
}

void analogWriteFast(uint8_t pin, uint16_t duty) {
  
  if (!duty) {					// If duty = 0
    digitalWrite(pin, LOW);		// Disable PWM and set pin to LOW
    return;						// Skip next code
  }

  switch (pin) {
  case 5:
    bitSet(TCCR0A, COM0B1);		// Enable hardware timer output
    OCR0B = duty;				// Load duty to compare register
    return;
  case 6:
    bitSet(TCCR0A, COM0A1);
    OCR0A = duty;
    return;
  case 10:
    bitSet(TCCR1A, COM1B1);
    OCR1B = duty;
    return;
  case 9:
    bitSet(TCCR1A, COM1A1);
    OCR1A = duty;
    return;
  case 3:
    bitSet(TCCR2A, COM2B1);
    OCR2B = duty;
    return;
  case 11:
    bitSet(TCCR2A, COM2A1);
    OCR2A = duty;
    return;
  }
}

// ВНИМАНИЕ! Нужное опорное установлено DEFAULT, можно изменить на своё
uint16_t analogReadFast(uint8_t pin) {
  pin = ((pin < 8) ? pin : pin - 14);		// analogRead(2) = analogRead(A2)
  ADMUX = (DEFAULT<< 6) | pin;	  // Set analog MUX & reference
  bitSet(ADCSRA, ADSC);						// Start 
  while (ADCSRA & (1 << ADSC));				// Wait
  return ADC;								// Return result
}

// установка делителя АЦП. Доступны 2,4,8,16,32,64,128
  
void analogPrescaler(uint8_t prescaler) {
  switch (prescaler) {
    case 2: ADCSRA = (ADCSRA & 0xF8) | 0x01;
      break;
    case 4: ADCSRA = (ADCSRA & 0xF8) | 0x02;
      break;
    case 8: ADCSRA = (ADCSRA & 0xF8) | 0x03;
      break;
    case 16: ADCSRA = (ADCSRA & 0xF8) | 0x04;
      break;
    case 32: ADCSRA = (ADCSRA & 0xF8) | 0x05;
      break;
    case 64: ADCSRA = (ADCSRA & 0xF8) | 0x06;
      break;
    case 128: ADCSRA = (ADCSRA & 0xF8) | 0x07;
      break;
  }
}

// пример использования PCINT - прерывания на любом пине
// прерывание вызывается при переключении состояния любого пина из группы

// наши обработчики прерываний
ISR(PCINT0_vect) {  // пины 8-13

}
ISR(PCINT1_vect) {  // пины A0-A5

}
ISR(PCINT2_vect) {  // пины 0-7

}

// функция для настройки PCINT
uint8_t attachPCINT(uint8_t pin) {
  if (pin < 8) {            // D0-D7 (PCINT2)
    PCICR |= (1 << PCIE2);
    PCMSK2 |= (1 << pin); return 2; } else if (pin > 13) {    //A0-A5 (PCINT1)
    PCICR |= (1 << PCIE1);
    PCMSK1 |= (1 << pin - 14);
    return 1;
  } else {                  // D8-D13 (PCINT0)
    PCICR |= (1 << PCIE0);
    PCMSK0 |= (1 << pin - 8);
    return 0;
  }
}


// быстрый digitalRead для опроса внутри ISR
// пригодится для проверки конкретного пина
bool pinRead(uint8_t pin) {
  if (pin < 8) {
    return bitRead(PIND, pin);
  } else if (pin < 14) {
    return bitRead(PINB, pin - 8);
  } else if (pin < 20) {
    return bitRead(PINC, pin - 14);
  }
}

// прицепляем аппаратные прерывания напрямую (пин, тип)
void attachInterruptFast(uint8_t num, uint8_t type) {
  switch (num) {					
    case 0:
      EICRA = (EICRA & 0x0C) | type;	// Setup interrupt type
      bitSet(EIMSK, INT0);				// Enable external interrupt
      return;
    case 1:
      EICRA = (EICRA & 0x03) | (type << 2);
      bitSet(EIMSK, INT1);
      return;
  }
}

void detachInterruptFast(uint8_t num) {
  bitClear(EIMSK, num);					// Disable external interrupt
}

// векторы. В них будет прыгать прерывание
ISR(INT0_vect) {

}

ISR(INT1_vect) {

}

// пример работы с юартом
// UART_begin(бод) - запустить
// UART_write(byte) - отправить байт
// UART_available() - проверка на входящий
// UART_read() - прочитать байт
// UART_end() - выключить

void setup() {
  UART_begin(9600);
  UART_write(40);  // отправить байт 40
  UART_write(40);
}

void loop() {
  if (UART_available()) {      // если есть что на приём
    byte data = UART_read();   // прочитать
    UART_write(data);          // отправить обратно
  }
}

// собственно функции
void UART_begin(uint32_t baudrate) {
  uint16_t speed = (F_CPU / (8L * baudrate)) - 1;
  UBRR0H = highByte(speed);
  UBRR0L = lowByte(speed);
  UCSR0A = (1 << U2X0);
  UCSR0B = (1 << TXEN0) | (1 << RXEN0);
  UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
}

void UART_write(byte data) {
  while (!(UCSR0A & (1 << UDRE0)));
  UDR0 = data;
}

bool UART_available() {
  return (UCSR0A & (1 << RXC0));
}

byte UART_read() {
  byte data = UDR0;
  return data;
}

void UART_end() {
  UCSR0B = 0;
}

// используем минимальный набор для Serial
// стандартный читаемый вывод делает встроенный в ядро Print.h

// ==== класс ====
#include "Print.h"
class Uart : public Print {
  public:
    void begin(uint32_t baudrate) {
      uint16_t speed = (F_CPU / (8L * baudrate)) - 1;
      UBRR0 = speed;
      UCSR0A = (1 << U2X0);
      UCSR0B = (1 << TXEN0) | (1 << RXEN0);
      UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
    }
    void end() {
      UCSR0B = 0;
    }
    size_t write(uint8_t data) {
      while (!(UCSR0A & (1 << UDRE0)));
      UDR0 = data;
    }
    bool available() {
      return (UCSR0A & (1 << RXC0));
    }
    char read() {
      byte data = UDR0;
      return data;
    }
  private:
};
// ==== конец класса ====

Uart uart;

void setup() {
  uart.begin(9600);
  uart.println("Hello ");
  uart.println(123456);
  // также есть
  // uart.end();
  // uart.write();
  // uart.available();
  // uart.read();
}

void loop() {
  
}

// ВНИМАНИЕ! Это просто сон, без отключения АЦП и прочих жрущих блоков
// для полноценного комфортного сна используйте GyverPower

void setup() {
  pinMode(2, 2); // внешняя подтяжка лучше длоя энергосбережения!
  Serial.begin(9600);
  Serial.println("hello!");
  delay(500);
  Serial.println("go to sleep");
  delay(500);
  attachInterrupt(0, wakeUp, LOW);  // вкл прерывание пробуждения
  goToSleep();  // отправка в сон
  delay(1000);  // после сна
  Serial.println("im back in business");  // продолжили работу
}

void wakeUp() {
  detachInterrupt(0);    // откл прерывание пробуждения
  SMCR &= ~ (1 << SE);   // запретили сон
  Serial.println("five more minutes,pls"); // сказали что проснулись
}

void goToSleep() {  
  SMCR |= (1 << SM1); 				// настроили сон как powerDown
  SMCR |= (1 << SE); 				// разрешили сон
  asm volatile ("sleep"); 			// инструкция сна
}

void loop() {
}

// полные аналоги стандартным функциям времени
// пригодится, если работать без Arduino.h
// доступные функции
// необходимо вызвать uptime0Init() при запуске, чтобы всё завелось
void uptime0Init();
unsigned long millis0();
unsigned long micros0();
void delay0(unsigned long ms);
void delayMicroseconds0(unsigned int us);

// ==================== РЕАЛИЗАЦИЯ ==================
#define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256))
#define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)
#define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)
#define FRACT_MAX (1000 >> 3)
#define MICROS_MULT (64 / clockCyclesPerMicrosecond())
volatile unsigned long timer0_overflow_count = 0;
volatile unsigned long timer0_millis = 0;
static unsigned char timer0_fract = 0;

void uptime0Init() {
  sei();
  TCCR0A = (1 << WGM01) | (1 << WGM00);
  TCCR0B = (1 << CS01) | (1 << CS00);
  TIMSK0 |= (1 << TOIE0);
} ISR(TIMER0_OVF_vect) {
  timer0_millis += MILLIS_INC;
  timer0_fract += FRACT_INC;
  if (timer0_fract >= FRACT_MAX) {
    timer0_fract -= FRACT_MAX;
    timer0_millis++;
  }
  timer0_overflow_count++;
}

unsigned long millis0() {
  uint8_t oldSREG = SREG;   // запомнинаем были ли включены прерывания
  cli();                    // выключаем прерывания
  unsigned long m = timer0_millis;  // перехватить значение
  SREG = oldSREG;           // если прерывания не были включены - не включаем и наоборот
  return m;                 // вернуть миллисекунды
}

unsigned long micros0() {
  uint8_t oldSREG = SREG;     // запомнинаем были ли включены прерывания
  cli();                      // выключаем прерывания
  unsigned long m = timer0_overflow_count;  // счет переполнений
  uint8_t t = TCNT0;                        // считать содержимое счетного регистра
  if ((TIFR0 & _BV(TOV0)) && (t < 255))     // инкремент по переполнению
    m++;
  SREG = oldSREG;                 // если прерывания не были включены - не включаем и наоборот
  return (long)(((m << 8) + t) * MICROS_MULT); // вернуть микросекунды
}

void delay0(unsigned long ms) {
  uint32_t start = micros0();
  while (ms > 0) { // ведем отсчет
    while ( ms > 0 && (micros0() - start) >= 1000) {
      ms--;
      start += 1000;
    }
  }
}

void delayMicroseconds0(unsigned int us) {
#if F_CPU >= 24000000L
  us *= 6; // x6 us, = 7 cycles
  us -= 5; //=2 cycles
#elif F_CPU >= 20000000L
  __asm__ __volatile__ (
    "nop" "\n\t"
    "nop" "\n\t"
    "nop" "\n\t"
    "nop"); //just waiting 4 cycles
  if (us <= 1) return; //  = 3 cycles, (4 when true)
  us = (us << 2) + us; // x5 us, = 7 cycles us -= 7; // 2 cycles #elif F_CPU >= 16000000L
  if (us <= 1) return; //  = 3 cycles, (4 when true)
  us <<= 2; // x4 us, = 4 cycles us -= 5; // = 2 cycles, #elif F_CPU >= 12000000L
  if (us <= 1) return; //  = 3 cycles, (4 when true)
  us = (us << 1) + us; // x3 us, = 5 cycles us -= 5; //2 cycles #elif F_CPU >= 8000000L
  if (us <= 2) return; //  = 3 cycles, (4 when true)
  us <<= 1; //x2 us, = 2 cycles
  us -= 4; // = 2 cycles
#else
  if (us <= 16) return; //= 3 cycles, (4 when true)
  if (us <= 25) return; //= 3 cycles, (4 when true), (must be at least 25 if we want to substract 22) us -= 22; // = 2 cycles us >>= 2; // us div 4, = 4 cycles
#endif
  __asm__ __volatile__ (
    "1: sbiw %0,1" "\n\t" // 2 cycles
    "brne 1b" : "=w" (us) : "0" (us) // 2 cycles
  );
}

// полные аналоги стандартным функциям времени
// пригодится, если работать без Arduino.h
// доступные функции
// необходимо вызвать uptime2Init() при запуске, чтобы всё завелось
void uptime2Init();
unsigned long millis2();
unsigned long micros2();
void delay2(unsigned long ms);
void delayMicroseconds2(unsigned int us);

// =================== РЕАЛИЗАЦИЯ ==================
#define MICROSECONDS_PER_TIMER2_OVERFLOW (clockCyclesToMicroseconds(64 * 256))
#define MILLIS2_INC (MICROSECONDS_PER_TIMER2_OVERFLOW / 1000)
#define FRACT2_INC ((MICROSECONDS_PER_TIMER2_OVERFLOW % 1000) >> 3)
#define FRACT2_MAX (1000 >> 3)
#define MICROS2_MULT (64 / clockCyclesPerMicrosecond())
volatile unsigned long timer2_overflow_count = 0;
volatile unsigned long timer2_millis = 0;
static unsigned char timer2_fract = 0;

void uptime2Init() {
  sei();
  TCCR2A = (1 << WGM20) | (1 << WGM21);
  TCCR2B = 1 << CS22;
  TIMSK2 = 1 << TOIE2; } ISR(TIMER2_OVF_vect) { timer2_millis += MILLIS2_INC; timer2_fract += FRACT2_INC; if (timer2_fract >= FRACT2_MAX) {
    timer2_fract -= FRACT2_MAX;
    timer2_millis++;
  }
  timer2_overflow_count++;
}
unsigned long millis2() {
  uint8_t oldSREG = SREG;           // запомнинаем были ли включены прерывания
  cli();                            // выключаем прерывания
  unsigned long m = timer2_millis;  // перехватить значение
  SREG = oldSREG;                   // если прерывания не были включены - не включаем и наоборот
  return m;                         // вернуть миллисекунды
}
unsigned long micros2() {
  uint8_t oldSREG = SREG;                   // запомнинаем были ли включены прерывания
  cli();                                    // выключаем прерывания
  unsigned long m = timer2_overflow_count;  // счет переполнений
  uint8_t t = TCNT2;                        // считать содержимое счетного регистра
  if ((TIFR2 & _BV(TOV2)) && (t < 255))     // инкремент по переполнению
    m++;
  SREG = oldSREG;                           // если прерывания не были включены - не включаем и наоборот
  return (long)(((m << 8) + t) * MICROS2_MULT); // вернуть микросекунды } void delay2(unsigned long ms) { uint32_t start = micros2(); while (ms > 0) { // ведем отсчет
    while ( ms > 0 && (micros2() - start) >= 1000) {
      ms--;
      start += 1000;
    }
  }
}
void delayMicroseconds2(unsigned int us) {
#if F_CPU >= 24000000L
  us *= 6; // x6 us, = 7 cycles
  us -= 5; //=2 cycles
#elif F_CPU >= 20000000L
  __asm__ __volatile__ (
    "nop" "\n\t"
    "nop" "\n\t"
    "nop" "\n\t"
    "nop"); //just waiting 4 cycles
  if (us <= 1) return; //  = 3 cycles, (4 when true)
  us = (us << 2) + us; // x5 us, = 7 cycles us -= 7; // 2 cycles #elif F_CPU >= 16000000L
  if (us <= 1) return; //  = 3 cycles, (4 when true)
  us <<= 2; // x4 us, = 4 cycles us -= 5; // = 2 cycles, #elif F_CPU >= 12000000L
  if (us <= 1) return; //  = 3 cycles, (4 when true)
  us = (us << 1) + us; // x3 us, = 5 cycles us -= 5; //2 cycles #elif F_CPU >= 8000000L
  if (us <= 2) return; //  = 3 cycles, (4 when true)
  us <<= 1; //x2 us, = 2 cycles
  us -= 4; // = 2 cycles
#else
  if (us <= 16) return; //= 3 cycles, (4 when true)
  if (us <= 25) return; //= 3 cycles, (4 when true), (must be at least 25 if we want to substract 22) us -= 22; // = 2 cycles us >>= 2; // us div 4, = 4 cycles
#endif
  __asm__ __volatile__ (
    "1: sbiw %0,1" "\n\t" // 2 cycles
    "brne 1b" : "=w" (us) : "0" (us) // 2 cycles
  );
}

// пример чтения установленных фьюз-байтов 

#define LOW_FUSE       (0x0000)
#define LOCK           (0x0001)
#define EXTENDED_FUSE  (0x0002)
#define HIGH_FUSE      (0x0003)

void setup() {
  Serial.begin(9600);
  
  Serial.print("Low:  0x");
  Serial.println(fuse_get(LOW_FUSE_BYTE), HEX);
  
  Serial.print("High: 0x");
  Serial.println(fuse_get(HIGH_FUSE_BYTE), HEX);
  
  Serial.print("Extended:  0x");
  Serial.println(fuse_get(EXTENDED_FUSE_BYTE), HEX);
  
  Serial.print("Lock: 0x");
  Serial.println(fuse_get(LOCK_BYTE), HEX);
  
}

void loop() {  
}


uint8_t fuse_get(uint16_t address) {
  uint8_t data;
  asm volatile
  (
    "sts %[spmreg], %[spmcfg]   \n\t"
    "lpm %[data], Z             \n\t"

    : [data] "=r" (data)
    : [spmreg]"i" (_SFR_MEM_ADDR(SPMCSR)),
    [spmcfg] "r" ((1 << SPMEN) |(1 << BLBSET)),
    "z" (address)
  );
  return data;
}