void view_flasher_0(){
}
void view_flasher_1(){
}
void view_flasher_2(){
}
void view_flasher_3(){
}
void view_flasher_4(){
}
void view_flasher_5(){
}


typedef void (*pfun_t)(void);


pfun_t   rnd_arr[] = {
   view_flasher_0,
   view_flasher_1,
   view_flasher_2,
   view_flasher_3,
   view_flasher_4,
   view_flasher_5,

};

#define MAX_EFFECTS     (sizeof(rnd_arr)/sizeof(rnd_arr[0]))


void swap(pfun_t *val1, pfun_t *val2){
   pfun_t t = *val1;
   *val1 = *val2;
   *val2 = t;
}

...................................................................................................

for(int i=0; i<100; i++){                   // Перемешиваем
   uint8_t     a = rand()%MAX_EFFECTS;
   uint8_t     b = rand()%MAX_EFFECTS;
   swap(&rnd_arr[a], &rnd_arr[b]);
}


for(uint8_t i=0; i<MAX_EFFECTS; i++){      // Вывод эффектов
   rnd_arr[i]();
}

/* ATtiny 84 */
#include <avr/io.h>
#include <stdint.h>
#include "pins_0.hpp"

int main(void){

//Pin pin; //Ошибка отсутствия аргументов шаблона перед &#39;pin&#39;   
//Pin.as_output(PORTB, PB0);
//Pin.as_output(PB0);
   
    while(1){    }
}

/* ATtiny 84 */
#ifndef PINS_H_
#define PINS_H_

#include <stdint.h>
#include <avr/io.h>

// arbitrarly use PORT as base addres
// произвольно использовать ПОРТ как базовый адрес
enum base {
   A = (const uint16_t) &PORTB,
   B = (const uint16_t) &PORTB
//   C = (const uint16_t) &PORTC,
//   D = (const uint16_t) &PORTD   
   };      

template <base b, uint8_t /*...*/all_args>

class Pin {
   private:
   // Calculate DDR and PIN offsets from PORT
   // Рассчитайте смещения DDR и PIN из ПОРТА
   static constexpr int8_t dir_offset = &DDRB - &PORTB;
   static constexpr int8_t in_offset = &PINB - &PORTB;

   // In C++11, constexpr functions can only contain one statement: return.
   // В C++11 функции constexpr могут содержать только один оператор: return.
   
   // This forces recursiveness to be used
   // Это заставляет использовать рекурсивность
   struct recursive {
      // Funtion to terminate iteration
      // Функция завершения итерации
      static constexpr uint8_t bit_mask(){ return 0; }
      
      // Recursive function
      // Рекурсивная функция
      
      // Since this function is private, it can only receive the types of "all_args...",
      // that is uint8_t
      // Поскольку эта функция является частной, она может получать только типы "all_args ...",
      // то есть uint8_t
      template <typename first_arg_type, typename /*...*/ next_args_types>
      static constexpr uint8_t bit_mask(first_arg_type first_arg, next_args_types /*...*/ next_args){
         return (1<<first_arg)|bit_mask(next_args/*...*/);
      }
   };

   // This version is valid in C++14 only, constexpr functions have less limitations
   // Эта версия действительна только для C++14, функции constexpr имеют меньше ограничений.
   struct non_recursive { // нерекурсивный
      // put variadic arguments in static constant array for easy access
      // поместите вариативные аргументы в статический массив констант для облегчения доступа
      static constexpr int arg_count = sizeof/*...*/(all_args);
      static constexpr int params[arg_count]={ all_args /*...*/ };
      
      static constexpr uint8_t  bit_mask(){
         uint8_t mask = 0;
         for (unsigned int i = 0; i < arg_count; i++)
         mask |= 1<<params[i];
         return mask;
      }
   };

   public:
   static void set(){
      *(volatile uint8_t*)b |= recursive::bit_mask(all_args/*...*/);
   }
   static void clear(){
      *(volatile uint8_t*)b &= ~recursive::bit_mask(all_args/*...*/);
   }
   static void as_output(){ // как выход
      *(volatile uint8_t*) (b + dir_offset) |= recursive::bit_mask(all_args/*...*/);
   }
   static void as_input(){
      *(volatile uint8_t*) (b + dir_offset) &= ~recursive::bit_mask(all_args/*...*/);
   }
   static void toggle(){ // переключить
      *(volatile uint8_t*) (b + in_offset) |= recursive::bit_mask(all_args/*...*/);
   }
   
};

#endif /* PINS_H_ */

/* ATtiny 84 */
#define F_CPU 8000000L
#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>

enum base {
   A = (const uint16_t) &PORTA,
   B = (const uint16_t) &PORTB
};

template <base b, uint8_t ... all_args>
class Pin {
   private:

   static constexpr int8_t dir_offset = &DDRB - &PORTB;
   static constexpr int8_t in_offset = &PINB - &PORTB;
   
   struct recursive {

         static constexpr uint8_t bit_mask(){ return 0; }

         template <typename first_arg_type, typename ... next_args_types>
         static constexpr uint8_t bit_mask(first_arg_type first_arg, next_args_types ... next_args){
            return (1<<first_arg) | bit_mask(next_args ... );
         }
      };
      
   struct non_recursive { // нерекурсивный

         static constexpr int arg_count = sizeof ... (all_args);
         static constexpr int params[arg_count]={ all_args ... };
            
            static constexpr uint8_t  bit_mask(){
               uint8_t mask = 0;
               for (unsigned int i = 0; i < arg_count; i++)
               mask |= 1<<params[i];
               return mask;
         }
      };
//----------
   public:
static void set(){
   *(volatile uint8_t*)b |= recursive::bit_mask(all_args... );
}
static void clear(){
   *(volatile uint8_t*)b &= ~recursive::bit_mask(all_args... );
}
static void as_output(){ // как выход
   *(volatile uint8_t*)(b + dir_offset) |= recursive::bit_mask(all_args... );
}
static void as_input(){
   *(volatile uint8_t*)(b + dir_offset) &= ~recursive::bit_mask(all_args... );
}
static void toggle(){ // переключить
   *(volatile uint8_t*)(b + in_offset) |= recursive::bit_mask(all_args... );
}
      
};

int main(void){

Pin<A, 0> pin1;

pin1.as_output();
pin1.set();

    while (1) {
_delay_ms(300);
pin1.toggle();
   }   
   
}

// Описание структуры, с результатами измерения:
struct {
  uint32_t time;
  int16_t temperature;
  unt16_t pressure;
} Data_t;

// Пишете функцию, которая умеет писать данные в eeprom по заданному адресу
void write_to_eeprom(uint16_t ee_addr, void *data, size_t size);

// Пишете функцию, которая умеет читать данные из eeprom
void read_from_eeprom(uint16_t ee_addr, void *data, size_t size);

// Функция, которая будет искать самую последнюю запись
int16_t find_last_record()
{
    int16_t idx = 0;
    uint32_t time = 0;
    Data_t last_data;
   
    for (int16_t i = 0; i < EEPROM_SIZE / sizeof(Data_t); i++) {
        read_from_eeprom(i * sizeof(Data_t), &last_data, sizeof(Data_t));
        if (last_data.time != 0xFFFFFFFF && last_data.time > time) {
            idx = i;
        }
    }

    return idx;
}