find (text_clcc);

PROGMEM char text_clcc[] = "clcc";

//процедура поиска слова в буффере
void find (const void *findbuff)
{
    findOK = false;
    unsigned int i=0;
    unsigned char temp,j=0;  
    while(1)
    {
        temp = pgm_read_byte(findbuff++);
        if(temp==0) break;
        FIND[i++] = temp;
    }    
    i=0;
    while (i != USART0_InBufSize)
    {
    if (USART0_InBuf[i] == FIND[j])
         {
            i++;j++;findOK = true;
            if (FIND[j] == 0x00) break;
        }
        else
        {
            i++;
            if (findOK == true)
            {
                j=0; i--;
                findOK = false;
            }
        }
    }
}

На счет тегов могли бы просто помочь с сылкой а не заявлением.

//---------------------------------------------------------------------------
// memcmp()
// compare unsigned char s1[n], s2[n]
// int (memcmp)(const void *s1, const void *s2, size_t n)
//---------------------------------------------------------------------------
RSEG CODE:CODE:NOROOT(2)
ARM

memcmp:
mov r3,r0 // Copy 1st arg, p1
mov r0,#0 // Set return value = 0
teq r2,#0 // Is n == 0 ?
bxeq lr // Return if n == 0

stmdb sp!,{r4-r6,lr} // Save registers on stack

cmp r2,#12 // Is n > 12 */
ble ByteLoop // If n <= 12, jump

sub r0,r3,r1 // p1 - p2
ands r0,r0,#3 // (p1 - p2) & 3
beq WordCompare // Jump if byte offsets match

// The strings begin at different byte offsets WRT word boundaries.
// Loop below processes only a single pair of bytes per iteration.
ByteLoop:
ldrb r0,[r3],#1 // b1 = next byte from string 1
ldrb r4,[r1],#1 // b2 = next byte from string 2
subs r0,r0,r4 // b1 - b2
bne ByteBreak // if b1 != b2, break out of loop
subs r2,r2,#1 // --n (decrement loop counter)
bne ByteLoop // Loop again if n > 0

ByteBreak:
TheEnd:
ldmia sp!,{r4-r6,lr} // Return
bx lr


// The two strings have same starting byte alignment WRT word boundary.
// Set up inner loop that compares a pair of words per iteration.

WordCompare:
add r5,r3,r2 // e1 = p1 + n (point to trailing byte)
and lr,r3,#3 // align = p1 & 3 (initial byte offset)
bic r3,r3,#3 // p1 &= ~3 (point to word boundary)
bic r1,r1,#3 // p2 &= ~3
add r2,r5,#3 // e1 + 3
sub r2,r2,r3 // e1 + 3 - p1
mov r2,r2,lsr #2 // N Words = (e1 + 3 - p1) >> 2

mvn r6,#0 // Initialize mask to all 1s
mov r0,lr,lsl #3 // Convert byte offset to bit offset
mov r6,r6,lsl r0 // Poke holes in mask for invalid bytes
ldr r0,[r3],#4 // w1 = *p1++
and r0,r0,r6 // Isolate starting bytes in 1st string
ldr r4,[r1],#4 // w2 = *p2++
and r4,r4,r6 // Isolate starting bytes in 2nd string


// Inner loop:
// Compare the two strings one word at a time to look for a mismatch.
// If the two strings match, return 0.
WordLoop:
subs r0,r0,r4 // w1 - w2
bne WordBreak // if w1 != w2, break out of loop
ldr r0,[r3],#4 // w1 = *p1++
subs r2,r2,#1 // --nWords
ldr r4,[r1],#4 // w2 = *p2++
bne WordLoop // Loop again if more words in string
mov r0,#0 // Set return argument = 0
b TheEnd // All done. Return


// The strings may still match if the apparent mismatch happened in
// the final pair of words from the two strings (in trailing bytes).
WordBreak:
teq r2,#1 // N Words == 1? (mismatch at EOS?)
bne FindMismatch // Jump if nWords != 1

ands r5,r5,#3 // Is trailing byte word-aligned?
beq FindMismatch // Jump if word-aligned (real mismatch)

mvn r6,#0 // Initialize mask to all 1s
mov r5,r5,lsl #3 // Convert byte offset to bit offset
mvn r6,r6,lsl r5 // Poke holes in mask for invalid bytes
ands r0,r0,r6 // Mask off trailing bytes, string 1
beq TheEnd // If w1 == w2, return val = 0


// We detected a mismatch in the current pair of words from the strings.
// But in which byte position within the words did the mismatch occur?
FindMismatch:
add r3,r0,r4 // Restore value w1

NextByte:
and r0,r3,#0xff // b1 = w1 & 0xff (isolate byte)
and r2,r4,#0xff // b2 = w2 & 0xff
subs r0,r0,r2 // Return val = b1 - b2 ?

bne TheEnd // If val != 0 - Return

mov r3,r3,lsr #8 // w1 >>= 8 (position next byte)
mov r4,r4,lsr #8 // w2 >>= 8
b NextByte // If b1 != b2, loop again

const char slovo[] = "slovo";
if (slovo[0]=='s')
{
}

void find(char* inb)
{
fndOK=-1;
char inc=*inb;
int i=0;
int slen=strlen(inb);
int pp=USART0_InBufSize-slen;

while(i<pp)
{
if(USART0_InBuf[i]==inc)
if(memcmp(&USART0_InBuf[i],inb,slen)==0)
{
fndOK=i;
break;
}
i++;
}
}

find (text_clcc);

PROGMEM char text_clcc[] = "clcc";

void find(prog_char const * inb)
{
    prog_char const * found = strstr_P(USART0_InBuf, inb);
    if (!found)
        fndOK=-1;
    else
        fndOK = found - USART0_InBuf;
}