Ich vermute mal, dass die ein Bytearray bitseriell befüllen willst, mit dem Takt über einen Interrupt.
Das hiesse aber, daß weder der Index noch bitcount irgendwelche beliebigen Werte einnehmen, sondern immer der Reihe nach, d.h. Bit 0-7, schalten auf nächstes Byte und wieder 0-7.

Da ist es effizienter, die Bits nicht einzeln zu setzen, sondern mit shift reinzuschieben
Und nicht mit Array-Index, sondern mit einen Pointer, der nach 8 Bit immer inkrementiert wird

Dazu brauchst du
eine Word-Variable für den pointer und
einen Byte-Zähler für die Bits

die setzt du zu Beginn auf die Anfangsadresse des Array und auf Null
z.B.
Code:
DIM array (nn) AS BYTE
DIM pointer AS WORD
DIM Bits  AS Byte

      Bits = 0
      pointer = VARPTR(array(1))


In der ISR:
      LOADADR  pointer, Z
      LDD  XL , Z + 0         (low pointer
      LDD  XH , Z + 1        (hig pointer

      LD    R24, X              aktuelles array-byte
      CLC                         clear carry
      SBIC    portx , inp-pin        ' Input -pin = 0/1 ? 
      SEC                          set carry
      ROL   r24                   bit reinschieben
      ST     X, R24             aktuelles byte speichern 
      LDD  R24,  Z + 3      (Bitcounter)
      INC   R24                 bitcounter+1
      ANDI  R24 , 7           es gilt nur 0-7
      BRNZ   _next_bit
 _next_byte:
      ADIW    X, 1             pointer+1      
      STD      Z + 0, XL          neuen low pointer speichern
      STD      Z + 1, XH         neuen hig pointer speichern
 _next_bit:
      STD  Z + 3, r24             (Bitcounter speichern
-- ISR fertig
Es zahlt sich auch aus, die ISR mit "nosave" zu definieren und nur die Register (und den Status) zu pushen, die du tatsächlich brauchst. Bascom pusht sonst alles von rechts bis links


Was da fehlt, ist die Endebedingung, also ein Signal, wenn es genug ist.
Ich weiss nicht, was du da brauchst

Wenn irgendwas unklar ist, frag nur.

(das ganze mit vorbehalt von Schreibfehlern und anderen Schweinereien)