#define DS_PORT    PORTD
#define DS_PIN     3
#define ST_CP_PORT PORTD
#define ST_CP_PIN  4
#define SH_CP_PORT PORTA
#define SH_CP_PIN  4

#define DS_low()  DS_PORT&=~ (1 << DS_PIN)
#define DS_high() DS_PORT|= (1 << DS_PIN)
#define ST_CP_low()  ST_CP_PORT&=~ (1 << ST_CP_PIN)
#define ST_CP_high() ST_CP_PORT|= (1 << ST_CP_PIN)
#define SH_CP_low()  SH_CP_PORT&=~ (1 << SH_CP_PIN)
#define SH_CP_high() SH_CP_PORT|= (1 << SH_CP_PIN)

void output_led_state(unsigned long int __led_state)
{
   SH_CP_low();
   ST_CP_low();
   for (long int i=0;i<24;i++)
   {
      if (((1 << i) & __led_state) == (1 << i))
      DS_high();
      else
      DS_low();
      
      
      SH_CP_high();
      SH_CP_low();
   }
   ST_CP_high();
}

output_led_state(0b000000010000000000000000);

output_led_state(0b

 0b000000000000000000000000;

vivod(kanal_1,ON);
vivod(kanal_2,OFF);

static volatile uint8_t   out_buf[BUF_OUT_SZ];
static volatile uint8_t   inp_buf[BUF_INP_SZ];

// inline-функция для обмена данными с регистрами
inline static void spi_io(void){
   for(uint8_t i=0; i<REGISTER_595_CNT; i++){
      SPDR = out_buf[i];
      while(bit_is_clear(SPSR, SPIF));
      if(i < REGISTER_597_CNT)
         inp_buf[i] = SPDR;
      else
         SPDR;
   }
   // импульс загрузки в регистры
   PORT(REGISTER_UPDATE_PORT) &= ~_BV(REGISTER_UPDATE_PIN);
   PORT(REGISTER_UPDATE_PORT) |= _BV(REGISTER_UPDATE_PIN);
}

#define DS_PORT    PORTD
#define DS_PIN     3
#define ST_CP_PORT PORTD
#define ST_CP_PIN  4
#define SH_CP_PORT PORTA
#define SH_CP_PIN  4

#define DS_low()  DS_PORT&=~ (1 << DS_PIN)
#define DS_high() DS_PORT|= (1 << DS_PIN)
#define ST_CP_low()  ST_CP_PORT&=~ (1 << ST_CP_PIN)
#define ST_CP_high() ST_CP_PORT|= (1 << ST_CP_PIN)
#define SH_CP_low()  SH_CP_PORT&=~ (1 << SH_CP_PIN)
#define SH_CP_high() SH_CP_PORT|= (1 << SH_CP_PIN)

_Bool __o[24] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
   
#define ON   1
#define OFF   0

#define OUT_1   __o[0]
#define OUT_2   __o[1]
#define OUT_3   __o[2]
#define OUT_4   __o[3]
#define OUT_5   __o[4]
#define OUT_6   __o[5]
#define OUT_7   __o[6]
#define OUT_8   __o[7]
#define OUT_9   __o[8]
#define OUT_10   __o[9]
#define OUT_11   __o[10]
#define OUT_12   __o[11]
#define OUT_13   __o[12]
#define OUT_14   __o[13]
#define OUT_15   __o[14]
#define OUT_16   __o[15]
#define OUT_17   __o[16]
#define OUT_18   __o[17]
#define OUT_19   __o[18]
#define OUT_20   __o[19]
#define OUT_21   __o[20]
#define OUT_22   __o[21]
#define OUT_23   __o[22]
#define OUT_24   __o[23]

 unsigned char s[3] = {0,0,0};

void output_schift(unsigned char *data)
{
   
   unsigned char msk,i;
   
   for(i = 0; i < 3; i++)
   {
      msk = 0x80;
      
      for(char k = 0; k < 8; k++)
      {
         // сравниваем каждый бит с единицей
         if(data[i] & msk)
         {
            DS_high(); // DATA 1
            SH_CP_high(); // CLK 1
            SH_CP_low(); // CLK 0
         }
         else
         {
            DS_low(); // DATA 0
            SH_CP_high(); // CLK 1
            SH_CP_low(); // CLK 0
         }
         msk = msk >> 1; // сдвигаем биты
      }
   }
   // защелкиваем регистр
   ST_CP_high();
   ST_CP_low();
}

void vivod()
{
   s[0] = 0;s[1] = 0;s[2] = 0;
   unsigned char b0 = 0,b1 = 0,b2 = 0;
   b2 = __o[0]|(__o[1]<<1)|(__o[2]<<2)|(__o[3]<<3)|(__o[4]<<4)|(__o[5]<<5)|(__o[6]<<6)|(__o[7]<<7);
   b1 = __o[8]|(__o[9]<<1)|(__o[10]<<2)|(__o[11]<<3)|(__o[12]<<4)|(__o[13]<<5)|(__o[14]<<6)|(__o[15]<<7);
   b0 = __o[16]|(__o[17]<<1)|(__o[18]<<2)|(__o[19]<<3)|(__o[20]<<4)|(__o[21]<<5)|(__o[22]<<6)|(__o[23]<<7);
   s[2] = ~b2;
   s[1] = ~b1;
   s[0] = ~b0;
   output_schift(s);
}

void out_init()
{
   s[0]=0xFF;s[1]=0xFF;s[2]=0xFF;
   output_schift(s);
   
   PORTA &= ~(1 << 3); Это тот самый оут энейбл!!!
   _delay_ms(500);
}

OUT_1 = ON;
      OUT_2 = OFF;
      OUT_3 = ON;
      
      OUT_15 = ON;
      OUT_24 = ON;
       vivod();

#define BUF_SZ    3

unsigned char buf[BUF_SZ];

void set_bit(unsigned char bit){
   if(bit >= (BUF_SZ * 8)) return;
   
   buf[bit / 8] |= 1 << (bit % 8);
}

void clr_bit(unsigned char bit){
   if(bit >= (BUF_SZ * 8)) return;
   
   buf[bit / 8] &= ~(1 << (bit % 8));
}

static void shift(unsigned char byte){
   unsigned char mask;

   for(mask = 1; mask; mask <<= 1){
      if(byte & mask)
         DS_high();
      else
         DS_low();

      SH_CP_high();
      SH_CP_low();
   }
}

void shift_to_register(void){
   unsigned char i;

   for(i=0; i<BUF_SZ; i++)
      shift(buf[i]);
}

set_bit(12);
clr_bit(8);
shift_to_register();