C code korter schrijven

int a[15]=[1,1,1,1,1, 1,1,1,2,2, 2,3,3,3,3];


for (i=0; i<15; i++) {
PORTB=a[i];
clock();
}

Syntax kan niet helemaal OK zijn, maar je begrijp 't idee wel, neem ik aan.

Ik denk dat een combinatie van for lussen samen met een if structuur in de for lus wel het één en ander kan oplossen.

Niks if-structuur.

Clock omschrijven naar 'write_and_clock (waarde)' en
daar PORTB zetten met waarde, en je kunt dit soort dingen doen:

for (i=0; i<7; i++) write_and_clock (a[waarde])
latch()
for (i=7; i<20; i++) write_and_clock (a[waarde])
latch()
for (i=20; i<30; i++) write_and_clock (a[waarde])

Tja, in PICBasic hebben we daar de DATA en READ voor.
De ruimte voor variabelen in een 16F628 is beperkt dus een oplossing met grote arrays kon wel eens lastig zijn.
Misschien iets met const arrays?

Look up tabellen. Verder kan je eventueel een functie schrijven met 8 argumenten voor het volgende:

PORTB = 0b00001011;
  clock ();
  PORTB = 0b00000011;
  clock ();
  PORTB = 0b00000011;
  clock ();
  PORTB = 0b00000011;
  clock ();
  PORTB = 0b00000011;
  clock ();
  PORTB = 0b00000011;
  clock ();
  PORTB = 0b00000011;
  clock ();
  PORTB = 0b00000011;
  clock ();
  PORTB = 0b00000000;
  latch ();

Bedankt voor de reacties!

Ik heb nu de code van één afbeelding korter gemaakt door gebruik te maken van arrays.

code

Alleen bij deze code zie je de eerste afbeelding trillen en de andere 3 niet. Kost deze verkorte versie zoveel meer tijd dan met de lange code?

[Bericht gewijzigd door Karim op donderdag 7 mei 2009 18:32:48 (95%)]

Host die lading code eens ergens je maakt er een scroll topic van, niemand gaat dat overtypen of helemaal doorlezen op een forum.

http://www.circuitsonline.net/forum/faq/2

Ik snap wel dat dat fout gaat. Je voert nu eerst die forloop uit en vervolgens ga je de rest van die ontiegelijke reeks zooi uitvoeren wat zoveel tijd kost dat het veel te lang duurt voordat die for-loop opnieuw wordt uitgevoerd.

Zorg eerst eens dat je begrijpt hoe je via SPI data naar die schuifregisters stuurt, zodat je het kunt automatiseren.

Vervolgens moet je uitzoeken hoe in de juiste volgorde die data gaat uitsturen. Daarvoor moet je al je data in array's zetten. Wellicht dat een 2-dimensionale makkelijker is.

Je moet met tellers bijhouden wat je hebt uitgestuurd en zo de juiste data uit de array halen.

En doe me een lol en pleur je code in een txt-file die je ergens host als het meer dan 20 regels is .

En maak op z'n minst die clock() functie wat handiger:

void clock(char d)
{
    PORTB = d;				// data klaarzetten en CLK laag
    Delay_ms(1);			// Effe wachten
    PORTB.F4 = 1;			// CLK hoog
}

// ...

    clock(0b00001101);
    clock(0b00000101);

Dat maakt die sliert code al de helft korter.

En werk met array's, anders blijft het een hopeloze zaak...

Ik heb alles geprobeerd in arrray's te zetten maar na twee afbeelding staat het RAM geheugen zo vol dat de derde er niet meer bij kan. Wat kan ik doen om wel alles erin de zetten?

@M14: Ik bedoel dat bij de eerste afbeelding alles veel lang duurt dan toen bij de andere drie afbeeldingen. Je zit duidelijk dat elke rij één voor één aan gaat. De snelheid is ongeveer 100 keer kleiner dan bij de andere drie afbeeldingen. Want 10 keer de for-loop uitvoeren duurt bijna even lang als 1000 keer de while-loop door te lopen.

Op 7 mei 2009 22:04:50 schreef Karim:
Ik heb alles geprobeerd in arrray's te zetten maar na twee afbeelding staat het RAM geheugen zo vol dat de derde er niet meer bij kan. Wat kan ik doen om wel alles erin de zetten?

De inhoud van de array op gepaste momenten vullen met nieuwe data.

Of de array in flash-geheugen plaatsen, en vandaar rechtstreeks uitlezen. Die truuk lukt in ieder geval bij AVR's. Ik veronderstel dat het voor PIC's ook doenbaar is, maar vraag me niet hoe...

Op 7 mei 2009 22:22:45 schreef pros:
Of de array in flash-geheugen plaatsen, en vandaar rechtstreeks uitlezen. Die truuk lukt in ieder geval bij AVR's. Ik veronderstel dat het voor PIC's ook doenbaar is, maar vraag me niet hoe...

Dat is een kwestie van in de handleiding van je compiler kijken. Bijna Alle embedded compilers hebben keywords om constant arrays in ROM te krijgen. Voor de MCC18 compiler bijvoorbeeld:

#pragma romdata const_table
const rom char my_const_array[10] = { 0,1,2,3,4,5,6,7,8,9 };
#pragma romdata

Maar dat verschilt per compiler (Microchip/Hitech/SCC etc), dus in de handleiding van jouw compiler kijken.

Op 7 mei 2009 22:04:50 schreef Karim:
Ik heb alles geprobeerd in arrray's te zetten maar na twee afbeelding staat het RAM geheugen zo vol dat de derde er niet meer bij kan. Wat kan ik doen om wel alles erin de zetten?

@M14: Ik bedoel dat bij de eerste afbeelding alles veel lang duurt dan toen bij de andere drie afbeeldingen. Je zit duidelijk dat elke rij één voor één aan gaat. De snelheid is ongeveer 100 keer kleiner dan bij de andere drie afbeeldingen. Want 10 keer de for-loop uitvoeren duurt bijna even lang als 1000 keer de while-loop door te lopen.

Het zou kunnen dat je bij die processor geen hele grote array's achter elkaar kunt zetten. Heeft te maken met hoe het geheugen in dat ding achter elkaar zit. Kun je evt. even nakijken in de datasheet.

Verder vraag ik me het volgende af. Klopt het dat je nu bit voor bit uitklokt op PORTB, waarvan bit0 naar schuifregister 1 gaat, bit1 naar schuifregister 2 en bit 3 naar schuifregister 3? Post je schema eens? Want ik vermoed dat je die schuifregisters op een heel onhandige manier gebruikt.

Normaal gezien zou je verwachten dat je alle schuifregisters als daisychain achter elkaar zet en alleen 1 clocklijn, 1 datalijn en 1 enable lijn gebruikt. En die ga je niet zelf aansturen, maar laat je door de ingebouwde SPI-hardware van de PIC doen. Zodoende hoef je steeds per keer maar 1 byte naar een register te schrijven. De PIC zorgt dan voor de rest van het versturen (clock, data enz).

[Bericht gewijzigd door Anoniem op vrijdag 8 mei 2009 11:08:45 (15%)]