процедура с указателем на строку в памяти программ, помогите разобраться Опции

[chief_olimp]

Здраствуйте. Ткните где не так кто знает пожалуйста

Код

unsigned char blabla[] = "blablabla";
/// текст и все такое
void find (unsigned char *findbuff)
{
    unsigned int i;
    while (*findbuff != '\0')
   {
    USART0_OutBuf[i++] = *findbuff;
    findbuff++;
   }
}
int main (void)
{
find (blabla);
}

т.е. программа какие то данные из ОЗУ грузит в процедуру и что то так с ними делает
Скажите пожалуйста как такое же провернуть со строкой типа

Код

unsigned char PROGMEM blabla[] = "blablabla";

Спасибо

[rokhan]

Спасибо вы нашли опечатку.

Код

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

Сообщение отредактировал zltigo - Dec 25 2008, 09:50

[zltigo]

У автора - используется двойное копирование + двойная проверка...

А я про Вас - просто среагировал на рекламный сологан "быстрее и веселее" и не найдя на мой взгляд ни того ни другого (совершенно обычно все) написал ремарку. Добавлю еще, что по нынешним временам библиотечные функции отличаются оптимизированностью (и ASM там не редкое явление)и "сделать" их просто так "в лоб" не получится, если только не за счет наложения дополнительных
ограничений.

Может что и можно сделать с помошью библиотечных функций но меня пока не убедили.

А зачем Вас кому-то убеждать ? Могу сказать одно (глядя на написанное Вами), что современные библиотечные функции написаны много-мнго более оптимально и Вам следует, как минимум, для начала воспользоваться ими.
Например, та memcmp(), которой я пользовался для ARM лет пять тому назад, до тех пор, пока IAR не "сделал" и ее выпустив очередную свою версию библиотеки.

CODE

//---------------------------------------------------------------------------
// 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