crossing page boundary PIC16F877A

Goedendag,

Wie kan mij helpen met het volgende;

Ik ben al een aantal maanden in m'n vrije uurtjes bezig om een programma te schrijven voor een Pic16f877A.
Zodoende is het programma inmiddels aardig groot aan het worden.
Ik gebruik MPlab/assembler voor het schrijven van mijn programma. Tot nu toe heb ik alle problemen kunnen oplossen
en werkt het gelukkig goed.
Maar nu krijg ik nadat ik de opdracht "make project" gegeven hebt de melding: "crossing page boundary - ensure page bits are set"

Als ik mijn programma weer iets inkort krijg ik de melding niet.

Als het programma het programmemory adres 07FFh niet voorbij gaat krijg ik de melding niet.
Maar zodra mijn programma groter is en voorbij adres 0800h
gaat krijg ik deze melding.

Het zal vast wel iets eenvoudigs zijn maar aangezien ik nog niet veel ervaring heb en ook in de datasheet niet kan vinden hoe ik de page bits moet setten wil ik vragen of iemand mij kan uitleggen wat hier aan te doen is.

Alvast bedankt

groetjes louis

kut hè, die page bits bij de PIC :-)

";-) Problemen bestaan niet, wel een gebrek aan kennis!!!"

En uiteraard aan ervaring :-)

Lees hoofdstuk 2 van de datasheet maar eens heel goed, dan heb je de kennis in huis :-P

[Bericht gewijzigd door Dynamic Resonance op ]

Eenvoudig is het niet. Kijk eens in de datasheet bij de uitleg over het programma geheugen. Je zult dan zien dat het memory ingedeeld is in pages.
Op het moment dat de programcounter over een page-boundary gaat, krijg je een overflow op je program counter (die is eigenlijk te klein).
Daarom heb je het extra register PCLATH waar je de hogere bits kunt zetten.
Je moet hiermee oppassen als je met GOTOs en CALLs bezig bent.
Lees eerst dat stukje datasheet maar eens.

Bedankt voor jullie snelle reacties.

Dat deze pic memory page0 t/m 3 had ik al wel gezien.
Maar mijn probleem is dat ik momenteel een programma heb van 2400 regels en nu even geen idee heb hoe ik nu verder moet naar page1
Het switchen tussen bank0 1,2 of 3 in het programma zelf is geen probleem.
In mijn programma gebruik ik veel goto's en call instructies.
Maar hoe weet ik nu in welke page het programma zich op een bepaalt moment bevindt?
Hoe kan ik in assembler mijn programma naar een ander page
verwijzen?

Compileer je code eens. Kijk vervolgens eens naar het program memory. Je kunt dan precies zien waar je code terecht is gekomen.
Het switchen tussen de pages kun je doen met PCLATH.
Let op: Dit is tricky business!

EDIT//
Er is een MPASM directive "pagesel"
Hiermee kun je in je code de juiste jump maken.
Nogmaals..tricky..

[Bericht gewijzigd door DIY op ]

Het compileren had ik al gedaan.
Zodoende ben ik er ook achter gekomen dat de melding zich voordoet na adres 0800h.

Als ik het goed begrijp moet je om te kunnen switchen tussen pages eerst weten in welke page je moet zijn en waar het programma een bepaalde goto of call instuctie neergezet heeft.

Als ik de data bekijk (alleen maar hexadicimaal) lijkt me
dat haast onmogelijk.

In mijn programma gebruik ik memorypage 3 voor dataopslag
omdat de interne eeprom te klein is.

Ik kan dat gebruiken omdat ik weet wat de gebruikte adressen zijn en wat er dus zou moeten staan.

Maar als MPlab mijn geschreven programma compileert staat alle data als hexadicimaal achter elkaar en is het voor mij eigenlijk maar raden wat waar staat

Op 24 maart 2005 17:37:13 schreef Louis:
Maar als MPlab mijn geschreven programma compileert staat alle data als hexadicimaal achter elkaar en is het voor mij eigenlijk maar raden wat waar staat

Kijk eens bij "view ->disassembly listing" ;)

Je hebt helemaal gelijk.
stom dat ik daar niet eerder bij stil gestaan heb.
Maar goed nu kan ik hopelijk verder

bedankt voor je info

Als je de 2K grens kruist krijg je inderdaad de ellende met het manipuleren van de page bits. En als je dan later een routine veranderd heb je de kans dat een adres in een keer weer over die grens verschuift en je programma niet meer werkt.
Dus een oplossing is het pagesel directive voor elke jump/call maar daar wordt je niet vrolijk van, je code wordt groter en trager en skip instructies zijn niet lekker meer bruikbaar als ze gevolgd worden door een goto.
Vergelijk het met een banksel directive elke keer als je een SFR adresseert.

Als het geen spaghetti code is, plaats dan een compleet functioneel blok boven de 2K grens met het org directive. Dan weet je dat je binnen dit blok PCLATH niet hoeft te manipuleren (alle routines zitten in de zelfde 2K page) en alleen bij de aanroep naar dit blok PCLATH moet zetten en terugzetten.

Een van mijn ontwerpjes had een floating point library: dit zijn een stuk of 20 routines waarvan je er slechts 6 vanuit je hoofdprogramma aanroept (add,substract,multiply,load,save etc), de overige 14 waren hulproutines . De hele library schuif je dus omhoog naar een aparte page en alleen wanneer je een floating point routine routine aanroept weet je dat je PCLATH moet zetten en restoren (en dat kan je weer oplossen met een MACRO).

Dus met een gestructureerde opzet blijft je code overzichtelijk. (Of gebruik een hogere taal, dan lost de compiler het voor je op)

Ongeveer de helft van mijn programma bestaat uit voorgeprogrammeerde teksten die naar het display geschreven kunnen worden.
Ik heb het opgelost door deze teksten in memorypage 1 te zetten.
Dus eerst org 0800H(begin page 1) en dan deze programmaregels.
Het hoofdprogramma staat in page 0 en met behulp van een call instructie kan ik deze teksten op het display laten verschijnen.
Wel moet ik nu voor elke call instructie PCLATH manipuleren
en na de return van de call instructie PCLATH nogmaals manipuleren om weer in page 0 te komen.
Het is wel wat omslachtig maar het werkt.
Wel iets om volgende keer rekening mee te houden voor het geval het weer een groot programma gaat worden.
Nogmaals bedankt voor jullie uitleg.