pic18f4520 registers vullen met getal.

goede morgen.

Wil graag een getal van 10 cijfers in registers zetten.
elke digit in een register.
Nu doe ik het zo, maar dat lijkt mij eenvoudiger te kunnen.

B.V getal 1234567890

movlw .1
movwf DIGIT1

enz.

misschien dat iemand een mooie manier weet om dit te verwezenlijken.

B.V.D almera

Mijn mening is dat assembly leuk is om een keer gezien te hebben, maar je moet in deze tijd niet meer er serieus mee aan de slag gaan. Er zijn veel te veel dingen die 25 jaar ervaring kosten om "echt goed" te doen, terwijl je tegen die tijd al veel betere programmas in C, basic of wat anders had kunnen schrijven.

Dus: 


  int i;
  char data="1234567890";

  for (i=0;i<10;i++)
     reg[i] = data[i];

Van AVR weet ik dat de compiler er van uitgaat dat zo'n array-indexering voorbij een "page" boundary (256 bytes) kan komen. Dat maakt de gegenereerde code inefficient. Gebruik een 32-bit microcontroller als je dat vervelend vindt.

Compilers zijn tegenwoordig veel slimmer dan je misschien zou verwachten.
Die index wordt 16-bits als je die als int declareert. Bij een 'char' index is dat niet meer.

Maar met optimisation krijg je nog sterkere effecten.



main()
{  unsigned char i;
   const char data[]="1234567890";
   char reg[10];

   for (i=0; i<10; i++)
      reg[i] = data[i];

   for (i=0; i<10; i++)
      PORTA = reg[i];
}

Met 'O3' worden de 'reg' array niet meer aangemaakt, de eerste for() verdwijnt en de 2e loop wordt omgerekend naar een reeks schrijf-opdrachten naar PORTA. De compiler is blijkbaar slim genoeg om te bepalen wat beter resultaat geeft.


   char reg[10];
   for (i=0; i<10; i++)
      reg[i] = data[i];

   for (i=0; i<10; i++)
      PORTA = reg[i];
  e0:	8c 85       	ldd	r24, Y+12	; 0x0c
  e2:	8b bb       	out	0x1b, r24	; 27
  e4:	8d 85       	ldd	r24, Y+13	; 0x0d
  e6:	8b bb       	out	0x1b, r24	; 27
  e8:	8e 85       	ldd	r24, Y+14	; 0x0e
  ea:	8b bb       	out	0x1b, r24	; 27
  ec:	8f 85       	ldd	r24, Y+15	; 0x0f
  ee:	8b bb       	out	0x1b, r24	; 27
  f0:	88 89       	ldd	r24, Y+16	; 0x10
  f2:	8b bb       	out	0x1b, r24	; 27
  f4:	89 89       	ldd	r24, Y+17	; 0x11
  f6:	8b bb       	out	0x1b, r24	; 27
  f8:	8a 89       	ldd	r24, Y+18	; 0x12
  fa:	8b bb       	out	0x1b, r24	; 27
  fc:	8b 89       	ldd	r24, Y+19	; 0x13
  fe:	8b bb       	out	0x1b, r24	; 27
 100:	8c 89       	ldd	r24, Y+20	; 0x14
 102:	8b bb       	out	0x1b, r24	; 27
 104:	8d 89       	ldd	r24, Y+21	; 0x15
 106:	8b bb       	out	0x1b, r24	; 27

PS: Getest op AtMega32

Feitelijk is de declaratie al voldoende, de compiler doet de rest :


   char reg[] = "1234567890";

Het hangt er ook sterk vanaf hoe je je registers definieert, en waar het getal vandaan komt.

Meestal gebruik je arrays in dit soort gevallen, ipv een reeks aparte variabelen. Dan kun je volstaan met een copy loopje.

Waar komt dat 10 digit getal vandaan? Is dat een constante of zo?