l supporto tecnico a SX-Key della Parallax è fornito mediante email a sxtech@parallaxinc.com. A domanda riceverete risposta  e sarà messa a disposizione di altri utenti di SX-Key. Prima di inviare una email consultate attentamente  la presente pagina.

Domanda #1: Che collegamenti sono necessari per programmare e mettere a punto il mio codice nel chip SX?

Domanda #2: Come si può far funzionare il Clock a bordo della SX-Key?

Domanda #3: Che differenza esiste fra la SX-Key e la SX-Blitz?

Domanda #4: Posso fare funzionare  un codice esistente 5X nel circuito integrato di SX?

Domanda #5: Il mio programma contiene una tabella di salto (tabella di look-up). E' usato per funzionare bene ma ora che è finito non funziona per quasi tutto il tempo. Che cosa è errato?

Domanda #6: Una delle caratteristiche del programma sxdemo per la scheda demo di SX è la conversione ANALOGICO-DIGITALE per mezzo di un singolo pin I/O e 3 elementi passivi (ci sono 2 canali A/D). Potete fornire teoria e codice di base?

Domanda #7: Stò ormai cominciando a programmare ed utilizzare l'SX-Key, ho cominciato dalla documentazione e mi è sembrato che debba in pratica imparare quasi tutto l'assembler specifico Parallax rispetto ai codici Microchip citati nei datasheet della Scenix. Per mancanza di tempo ho dovuto ripiegare a programmare dei PIC utilizzando l'assembler microchip e sono un pò riluttante nell'incamminarmi sulla curva di apprendimento del "nuovo "set di istruzioni.  Corretto? Devo usare i mnemonici di Parallax?

Domanda #8: Che cosa accade quando state elaborando un' interrupt e accade un' altro interrupt? Dalla lettura della documentazione, sembra che il gestore degli interrupt, che  pensa ad occuparsi delle sorgenti multiple di interrupt, si suppone debba controllare tutti i possibili interrupt prima di togliere il controllo al gestore. Il fatto è, che il circuito integrato SX sia abbastanza capace " di perdere " un interrupt anche sotto il controllo del gestore. Nel mio sistema del servocomando vi è una necessità per l'SX di generare impulsi estremamente esatti mentre simultaneamente deve rispondere ad un controller esterno che trasmette gruppi di dati per posizionare ciascun servo 24 - 30 volte al secondo.

Domanda #9: Mi sono reso conto che ci sono modi difficili e modi migliori per creare la struttura dei programmi. Mentre il manuale del sistema di sviluppo di SX-Key mi dice molte cose, noto che data la mia poca esperienza e la scarsa strutturazione dei miei programmi entro in difficoltà. Non sono un debuttante in fatto di programmazione, ma potrei avere bisogno di qualche consiglio. Per esempio, quando provo ad usare le procedure " di CHIAMATA ", ho bisogno spesso di qualcosa tipo una funzione Push / Pop e ristabilire i registri di W, di FSR e di STATUS che funzionano da qualsiasi pagina di istruzione. Ho provato alcune volte per farne uno, ma ho delle difficoltà poiché ho soltanto una coppia di registri globali.

Domanda #10: Da non molto ho comprato 25 SX18AC/DP dalla vostra azienda ed uso la rev. E di SX-key per programmarli. Ogni circuito integrato può essere programmato, ma su nessuno riesco a fare il debug. Perchè?

Domanda # 11: Riguardo alla domanda # 6, descrivete un metodo per
immettere su un ingresso, un segnale analogico compreso fra 0-5 volt con risoluzione di 8  bit. Può l' accumulatore utilizzato in questo esempio tenere 4095 campioni, fornendo un risultato ANALOGICO-DIGITALE a 12 bit ?

Domanda   #12: Nell'assembler SX key esiste un trucco (una macro o altro...) per fare in modo che l'assembler aggiunga l'istruzione PAGE solo quando necessario nei riferimenti forward ? Amo SX-KEY e l'IDE   ma stò scoprendo che le istruzioni/macro CJXX non sono facili se mettono l'istruzione PAGE tra lo skip ed il jmp quando si utilizzano riferimenti @address per la sicurezza di programmi più grandi di una pagina,per esempio ecco il listato seguente.

RISPOSTE:

Domanda # 1: Che collegamenti sono necessari per programmare e mettere a punto il mio codice nel chip SX?

I collegamenti Vdd, Vss, OSC1 e OSC2 devono essere fatti fra la SX-Key ed il chip SX. I 5 VCC devono essere collegati a Vdd per alimentare il circuito integrato di SX e la SX-Key. Inoltre, la GND del gruppo di alimentazione deve essere collegata al Vss di SX e della SX-Key. Il segnale del clock può essere fornito dalla SX-Key

Domanda # 2: Come si può far funzionare il Clock  a bordo della SX-Key?

In primo luogo selezionare la frequenza; potete o specificarli nel vostro codice sorgente usando la direttiva "freq" o potete cliccare sopra Run>Clock nel software di SX-Key ed usare semplicemente la slide-bar per selezionare la frequenza voluta.

Domanda # 3: Che differenza c'è fra lo SX-Key e lo SX-Blitz?

La SX-Key è il nostro kit completo, programmatore ed emulatore per i chip SX. Presenta a bordo un Clock per far funzionare il chip SX a qualsiasi frequenza fra 400KHz e 110MHz. Lo SX-Blitz è il nostro programmatore a basso costo per i circuiti integrati SX. Anche se usa lo stesso software dello SX-Key, non può emulare, né può generare un segnale di Clock per fare funzionare l'SX.

Domanda # 4: Posso fare funzionare un codice esistente '5X nel chip SX?

Sì. Quando nel software di SX-Key si clicca sopra Run>Device. Una volta nel menu device, cliccare sopra il bottone "Load Hex" e specificare il file .hex o .obj che desiderate caricare. Verificare che il settaggio del fusibile sia giusto quindi cliccare sopra "Program".

Domanda # 5: Il mio programma contiene una tabella di salto (tabella di look-up). E' usato per funzionare bene ma ora che è finito non funziona per quasi tutto il tempo. Che cosa è errato?

Questo problema può accadere per un limite architettonico dello SX. L' istruzione 'JMP PC+W ' è realmente una istruzione 'add PCL,w'. Considerate che sia 'W ' che 'PCL ' sono entrambi registri a 8-bit. Il funzionamento è simile a questo:

Considerare il suddetto codice; un sottoprogramma chiamato dal codice principale. Supponete ora che il valore corrente dell' indice sia 3 (che è caricato in W) ed il valore corrente del contatore di programma (PC) all' istruzione PC+W sia 0F0h. Così appena viene eseguita l' istruzione jmp PC+W ecco che cosa accade:

PC = PC + W + 1 'Equazione
PC = F0 + 3 + 1 'Equazione con dati

PC = F4 'Equazione risolta

Così il valore 0F4h è caricato nel PC e 0FFh è copiato nel registro W e
l' istruzione retw è eseguita nel ritorna al main. Ciò è come funziona una piccola tabella. Conoscendo questo, è facile capire quando si sviluppa il formato di una  tabella, perchè a volte non funzionano.

Considerate lo stesso esempio sopra salvo che ci sono 64 byte nella tabella. Supponete che il valore corrente dell' indice sia 20h e che il valore corrente del contatore di programma (PC) nell' istruzione jmp PC+W sia 0F0h. Così, quando
l' istruzione jmp PC+W viene eseguita, ecco che cosa accade:

PC = PC + W + 1 'Equazione
PC = F0 + 20 + 1 'Equazione con i dati (esadecimali)
PC = 110  'Equazione risolta

Tuttavia, il registro PC è soltanto di otto bit e non può tenere 110h così il valore risultante nel PC è 10h. Quindi i salti nel vostro programma saranno bizzarri. La morale della storia è che dovreste creare tabelle di salto con contorni esadecimali uniformi quali 200h, 400h, 600h. Ciò è fatto facilmente premendo i tasti Ctrl-L all'interno dell' ambiente di software di SX-Key. Ctrl-L induce l' assemblatore incorporato a generare un list-file. Il file-list mostra tutto ciò che riguarda il vostro codice sorgente, il codice hex generato e le posizioni in cui il codice hex risiede all'interno del chip.

Per correggere il suddetto esempio, aggiungere semplicemente un' istruzione 'org' per individuare la tabella di salto ad un contorno della pagina come indicato sotto. Ed assicurarsi che usate il comando 'Page' se siete tra una pagina e l'altra.

Domanda #6: Una delle caratteristiche del programma sxdemo per la scheda demo di SX è la conversione ANALOGICO-DIGITALE per mezzo di un singolo pin I/O e 3 elementi passivi (ci sono 2 canali A/D). Potete fornire teoria e codice di base?

Per spiegare questo guarda lo schema dell' ingresso/uscita analogici ed i relativi frammenti di codice usando l' illustrazione indicata sotto.

Dati: qualsiasi tensione (0-5VDC) può essere presente sull' entrata analogica, la soglia di un pin di I/O di SX configurato come input è di 2,5 VCC, RC.1 (il pin di sense) è configurato come input, RC.0 (il pin di risposta) è configurato come uscita.

Qui ci sono i frammenti pertinenti di codice:

Ecco come funziona:

Il pin di sense è letto (sarà o 0 o 1) ed il complemento del segnale è messo sul pin di risposta. Ciò viene eseguito 255 volte per un campione inducendo la tensione media sul pin di sense ad essere di 2,5 volt. Un accumulatore viene incrementato ogni volta che il pin di sense viene letto come un 1. Dopo 255 campioni,
l' accumulatore contiene un numero che è il risultato ANALOGICO-DIGITALE 8-bit!

Avete bisogno di ulteriori spiegazioni? Immaginate che 5 VCC siano presenti
sull' entrata analogica. Qesto indurrebbe il pin di sense ad essere letto come 1. Il software ritornerebbe il complemento di questo (0) sul pin di risposta e
l' accumulatore verrebbe incrementato. Il condensatore, C1, comincia a scaricarsi un poco. Le iterazioni successive avrebbero lo stesso comportamento fino a che tutte e 255 iterazioni sono eseguite, la carica media del condensatore settata a 2,5 VCC e 255 (1s) viene accumulata. Voila! La rappresentazione per 5VDC è 255!

Ancora di più? Immagina che 0 VCC sono presenti sull' entrata analogica. Questo indurrebbe il pin di sense a essere letto come 0. Il software produrrebbe il complemento di questo (1) sul pin di risposta e l' accumulatore non verrebbe incrementato. Il condensatore, C1, comincia a caricarsi un poco. Le iterazioni successive avrebbero lo stesso comportamento fino a che tutte e 255 le ripetizioni non accadono, la carica media del condensatore diventa 2,5 VCC e 0 (1s) è stato accumulato. Voila! La rappresentazione per 0VDC è 0!

Tenendosi al corrente di come deve lavorare per effettuare una carica media su C1 di 2,5 VCC, l' SX può determinare la grandezza della tensione (0-5) sul pin di ingresso analogico.

Qual'è il tempo di esecuzione ?
La velocità di esecuzione dipende dalla periodicità di interruzione. Poiché il programma SX demo interrompe ogni 163 cicli di Clock e funziona a 50 Mhz, lo useremo come esempio. Ogni istruzione prende 1 ciclo di clock, coscicchè semplicemente prendiamo il reciproco di 50 megahertz e scopriamo il tempo necessario per eseguire un' istruzione:

1/50.000.000 = 20 di nanosecondi (nS)

allora moltiplicano il tempo di istruzione per il numero di istruzioni fra le interruzioni per trovare la periodicità dell' interruzione di RTCC.

163 cicli di Clock * 20 nSecs = 3,26 microsecondi (uS)

Per concludere, moltiplicando la periodicità di interruzione per il numero di interruzioni richieste, troveremo il tempo di conversione per una conversione completa.

3,26 uSecs * 256 interruzioni = 834,56 uSecs

Domanda #7: Stò ormai cominciando a programmare ed utilizzare l'SX-Key, ho cominciato dalla documentazione e mi è sembrato che debba in pratica imparare quasi tutto l'assembler specifico Parallax rispetto ai codici Microchip citati nei datasheet della Scenix. Per mancanza di tempo ho dovuto ripiegare a programmare dei PIC utilizzando l'assembler microchip e sono un pò riluttante nell'incamminarmi sulla curva di apprendimento del "nuovo" set di istruzioni.   Corretto? Devo usare i mnemonics di Parallax?

Per rispondere alla vostra domanda: per usare lo SX-Key, SX-Blitz; Credo così. Considerate che i mnemonici di Parallax possono essere divisi in due gruppi:

1) comandi a istruzione singola

2) comandi a istruzione multipla

Tutti i comandi a istruzione multipla possono essere effettuati con i singoli comandi di istruzione. Esempio:

Così, incollando comandi a istruzione singola può rendere l'apprendimento un poco più facile. In più, mentre ci sono parecchie istruzioni 'mov' con il linguaggio Microchip, ce ne è soltanto uno da imparare con Parallax:

Per molti , i mnemonici di Parallax rendono il vostro codice molto più facile da leggere e le ramificazioni dovute usando i mnemonici a istruzioni multiple si trasformano rapidamente nella seconda natura. Anche la Microchip ha adottato vari dei nostri mneominci nel corso degli ultimi anni. Dopo tutto piuttosto digitereste:

Inoltre, alcuni dei comandi multipli di istruzioni sono molto convenienti. Prendete, per esempio, l' istruzione 'CJA'. Avreste bisogno di quattro comandi discreti per effettuare questo comando. Questo significa che avete quattro volte la possibilità di includere errori di logica e di tipo.

I mnemonici dell' assemblatore sono stati ideati sin dal 1990 e sono stati certamente provati.

Domanda #8: Che cosa accade quando state elaborando un' interrupt e accade un' altro interrupt? Dalla lettura della documentazione, sembra che il gestore degli interrupt, che  pensa ad occuparsi delle sorgenti multiple di interrupt, si suppone debba controllare tutti i possibili interrupt prima di togliere il controllo al gestore. Il fatto è, che il circuito integrato SX sia abbastanza capace " di perdere " un interrupt anche sotto il controllo del gestore. Nel mio sistema del servocomando vi è una necessità per l'SX di generare impulsi estremamente esatti mentre simultaneamente deve rispondere ad un controller esterno che trasmette gruppi di dati per posizionare ciascun servo 24 - 30 volte al secondo.

Per ulteriori informazioni, date un'occhiata al sistema di sviluppo di SX-Key alla sezione manuale intitolata "disabilita interrupt automatici". Gli Interrupt che "arrivano" mentre l' SX sta già elaborando un'altro interrupt sono ignorati. Nel migliore dei casi, il programmatore dovrebbe provare a strutturare il codice in maniera che non sia possibile per gli interrupt di coincidere. Realisticamente, questo non è sempre possible

Per esempio, considerate due sorgenti di interrupt: RTCC e RB0 ed ISR che attualmente sta assistendo il roll-over di RTCC. Se disabilitate gli interrupt regolando il bit di RTI in cima alla procedura di servizio di interrupt, l' interruzione seguente su RB0 sarà accodata. Dovete abilitare gli interrupt annullando il bit di RTI appena prima la conclusione della vostra procedura di servizio di interrupt. Se l' interrupt RB0 arriva prima che gli interrupt siano disabilitati in cima alla procedura di servizio di interrupt, quell' interrupt sarà ignorato. In questa applicazione particolare, può essere conveniente controllare semplicemente il registro in attesa prima del ritorno dalla sezione sistematica di servizio di interrupt che maneggia l' interrupt di roll-over di RTCC.

Per quanto fatto, forse il metodo migliore dovrebbe essere di avere un' interrupt (RTCC) ad un alto tasso ed integrare le procedure seriali di comunicazione e le procedure per gli impulsi ai servo. In questo modo, i vostri servi riceverebbero quasi sempre impulsi precisi e l' errore possibile delle procedure seriali di comunicazione potrebbe essere misurato e gestito facilmente. Questa tecnica descrive come abbiamo effettuato la comunicazione seriale e le procedure del temporizzatore nel programma di SXDemo.src (disponibile da http://www.parallaxinc.com). Tenete presente: più alto è il tasso di interrupt, più basso l' errore possibile.

Domanda #9: Mi sono reso conto che ci sono modi difficili e modi migliori per creare la struttura dei programmi. Mentre il manuale del sistema di sviluppo di SX-Key mi dice molte cose, noto che data la mia poca esperienza e la scarsa strutturazione dei miei programmi entro in difficoltà. Non sono un debuttante in fatto di programmazione, ma potrei avere bisogno di qualche consiglio. Per esempio, quando provo ad usare le procedure " di CHIAMATA ", ho bisogno spesso di qualcosa tipo una funzione Push / Pop e ristabilire i registri di W, di FSR e di STATUS che funzionano da qualsiasi pagina di istruzione. Ho provato alcune volte per farne uno, ma ho delle difficoltà poiché ho soltanto una coppia di registri globali.

Se il vostro programma è molto piccolo, potete scriverli senza considerazione della  architettura. L' assemblatore non darà problemi nell'assemblaggio, eccetto gli errori logici, probabilmente funzionerà. Comunque durante lo sviluppo del programma, potete espandere nella metà superiore d'una pagina per ricevere gli errori delle routine che risiedono nella metà superiore della pagina. Allora pensate di organizzare il vostro codice per individuare i sottoprogrammi nella metà inferiore ed il codice principale nella metà superiore, voila! Funziona ancora. Ma, soltanto fino a chè il vostro codice si sviluppa ancora un poco e, senza avvertimenti
dall' assemblatore, un cambiamento secondario può causare il crash del programma! Questo ciclo continua fino a che il programmatore non rileva il successo o il guasto. Il primo programma grande può essere un viaggio arduo nel migliore dei casi.

Un modo migliore è quello di cominciare con una struttura in mente prima che la codificazione cominci. La struttura assicura che l' assemblatore non dia problemi forzandovi a considerare l' architettura dello SX prima che i problemi si evolvano. La struttura forza l' assemblatore a generare i messaggi di errore quando il codice si sviluppa oltre la portata o la gamma progettata, quindi avvisando in anticipo il programmatore ed evitando il cane che si morde la coda.

Questa è una lista di situazioni che il programmatore puo' considerare quando scrive un programma per lo SX.:

1. Quattro pagine separate - non attraversabili facilmente. L' incrocio della pagina non è automatico e deve essere ottenuto esplicitamente.

2. Due metà per pagina - dovrebbero essere usate differentemente. Poiché i sottoprogrammi devono essere situati nella metà inferiore di tutta la pagina, ha il significato che il codice principale dovrebbe essere nella metà superiore.

3. 1 + 2. Poiché essenzialmente abbiamo quattro zone per il codice principale e quattro zone per i sottoprogrammi, il programmatore dovrebbe pensare al suo programma in questi termini.

Questi sono alcuni concetti vaghi, che lasciano intravedere la struttura. I commenti richiamano il programmatore dove disporre il codice.

		device	SX28L
		reset	Initialize	'allo start, va alla routine di Initialize
		freq	4_000_000

		org	8	'Start dello spazio RAM
Temp1	ds	1
Temp2	ds	1

;***************************************************************************
ISR		org	000h	'Start dello spazio codice
		inc	Temp1	'prima la routine di gestione Interrupt
		reti
;***************************************************************************
AddEmUp	add	Temp1,Temp2 	;inserire qui le subroutines usate dal 
		ret		;codice main di Page0 

;***************************************************************************
Initialize	clr	Temp1		;inserire il codice di boot qui.
		clr	Temp2
;***************************************************************************
Page0				;inserire qui il codice main per page0
		call	@SubTwo	;chiamata Far
		call	AddEmUp	;subroutine locale
		page	200h
		jmp	Page1
;***************************************************************************
SubTwo	org	200h		;inserire subroutines usate dal codice main di page1.
		dec	Temp1	
		dec	Temp2	
		retp		;istruzione retp - ora è facile il richiamo altre pagine.
;***************************************************************************
Page1				;inserire qui il codice main per page1
		call	@AddEmUp ;chiamata(usando ret)
		page	200h		;
		call	SubTwo	;chiamata locale
		page	400h
		jmp	Page2
;***************************************************************************
AddTwo	org	400h		;inserire qui le subroutines usate dal
		inc	Temp1	;codice main di page2.
		inc	Temp2
		retp
;***************************************************************************
Page2				;inserire qui il codice main per la page1
		call	AddTwo
		page	600h
		jmp	Page3
;***************************************************************************
DivTwo	org	600h		;inserire qui le subroutines usate dal
		clc		;codice main di Page3 .
		rr	Temp2
		ret
;***************************************************************************
Page3				;inserire qui il codice main per la page3

		call	DivTwo
		page	000h
		jmp	Page0
;***************************************************************************

Seguite il codice dall' etichetta di inizializzazione affinchè l' SX cominci l'esecuzione dopo l'accensione. La subroutine 'do nothing' mostra le loro posizioni relative, il modo adeguato di chiamarle ed il modo adeguato di cancellare dopo la chiamata, se necessario. Notare le differenze nel modo in cui i sottoprogrammi sono maneggiati quando usano un' istruzione 'retp ' (come in 'AddTwo') in contrasto alla istruzione 'ret' in tutti gli altri sottoprogrammi.

Oltre a queste informazioni, bisogna prendere precauzioni quando si usano le tabelle di salto, esse sono richieste tipicamente per essere organizzate unformemente entro i limiti. In questo caso un altro metodo può essere   usato chiamto 'jump Table' o tabella di salto.

La 'tabella di salto ' è utile quando ottenete il messaggio di errore, "destination address must be in lower half of page", "l'indirizzo di destinazione deve essere nella metà inferiore della pagina" e non c'è più spazio nella metà inferiore della pagina. Per questo dovete soltanto ricordare che le chiamate hanno soltanto questi limiti e non salti. Conoscendo questo, la chiamata ai sottoprogrammi può essere riscritta cosi':

		org	000h
_AddEmUp	jmp	AddEmUp
_DivTwo	jmp	DivTwo
_AddTwo	jmp	AddTwo
_SubTow	jmp	SubTwo

		org	100h	;Subroutines nella meta' sup. della pagina
;***************************************************************************
AddEmUp	add	Temp1,Temp2
		ret
;***************************************************************************
DivTwo	clc
		rr	Temp2
		ret
;***************************************************************************
AddTwo	inc	Temp1
		inc	Temp2
		retp
;***************************************************************************
SubTwo	dec	Temp1
		dec	Temp2
		retp
;***************************************************************************

Spesso W ed FSR sono usati per passare argomenti a e dal sottoprogramma ed il codice principale. La maggior parte della gente non utilizza il registro di STATUS per questo poiché  tante istruzioni alterano il contenuto. Considerate una tecnica in cui chiamereste alcuni registri globali come Temp1, Temp2, ecc. Usate questi per passare variabili a e dai sottoprogrammi, per tenere i valori di interim e i contatori di ciclo.

Usando questa tecnica puoi conservare RAM poichè (Temp) può essere riutilizzato

Domanda #10: Da poco ho comprato 25 SX18AC/DP dalla vostra azienda ed uso la rev. E di SX-key per programmarli. Ogni circuito integrato può essere programmato, ma su nessuno riesco a fare il debug. Perchè?

Alcuni vecchi SX non supportano il debug. I vecchi datecodes sono numeri a quattro cifre. I chip SX con i datecodes prima dei 9810 non supportano il debug.
I nuovi datecodes sono in formato AAXXXXAB e occrre usare SXKey28L.exe.

I nuovi chip hanno una disposizione differente del fusibile e devono essere programmati con il nuovo software. Gli stessi SX-Key lavorano sia con i vecchi che i nuovi stili ma dovete usare il software corretto per il chip SX che state usando. Il datecode vecchio stile è nel formato XXXX e dovete usare SXKey.exe. Il nuovo datecode è nel formato AAXXXXAB e dovete usare SXKey28L.exe.

Domanda #11: Riguardo alla domanda # 6, descrivete un metodo per
immettere su un ingresso, un segnale analogico compreso fra 0-5 volt con risoluzione di 8  bit. Può l' accumulatore utilizzato in questo esempio tenere 4095 campioni, fornendo un risultato ANALOGICO-DIGITALE a 12 bit ?

Esso  può essere fatto. Avrete bisogno di ' creare ' registri a 12-bit concatenando due registri a otto bit insieme. Esempio:

adc_accum ds 2

inc adc_accum snz inc adc_accum+1

Dovete controllare se c'è ' un roll-over ' esaminando il dodicesimo bit (che è il quarto bit di adc_accum+1). Una volta che un roll_over accade, dovete cancellare entrambi i registri poiché non sarebbe più fatto inerentemente.

Domanda #12:Nell'assembler SX key esiste un trucco (una macro o altro...) per fare in modo che l'assembler aggiunga l'istruzione PAGE solo quando necessario nei riferimenti forward ? Amo SX-KEY e l'IDE  ma stò scoprendo che le istruzioni/macro CJXX non sono facili se mettono l'istruzione PAGE tra lo skip ed il jmp quando si utilizzano riferimenti @address per la sicurezza di programmi più grandi di una pagina,per esempio ecco il listato seguente:

Il quale allora salta in entrambi  i casi e può saltare alla pagina errata piuttosto che:

MOV W, reg1
MOV W, reg2-W
PAGE @label1
SC
JMP @label1

questo è quello che dovrebbe essere generato. Attualmente l'istruzione PAGE dovrebbe essere automaticamente aggiunta solo quando il sorgente ed il target sono su differenti pagine. Ho fatto i seguenti cicli for repeat until ma l'if then appare impossibile senza fare l'Hardcoding, l'istruzione PAGE come qualsiasi riferimento a label di forward genera un errore: undefined symbol. Ho provato l'SXKey 52 v1.12 con la rev. E/F, l'SXKey 28L v1.07 con la revi E, l'SXKey 28 v1.07 con la rev E con gli stessi risultati.....

eq equ0
lt equ1
ne equ2
gt equ3

repeat MACRO
RepeatLabel= $
ENDM

until MACRO 3
expand
stc
movw,\1
movw,\3-w
targetPg = (RepeatLabel)/$200
basePg = ($+2)/$200
noexpand
IF (RepeatLabel)/$200 <> ($+2)/$200
expand
page RepeatLabel
noexpand
ENDIF
IF \2 = eq
expand
sz
noexpand
ENDIF
IF \2 = ne
Expand
snz
noexpand
ENDIF
IF \2 = lt
expand
snc
noexpand
ENDIF
IF \2 = gt
expand
sc
noexpand
ENDIF
expand
jmp RepeatLabel
noexpand
ENDM

ifthenMACRO 4
expand
stc
movw,\1
movw,\3-w
page \4
noexpand
IF \2 = eq
expand
sz
noexpand
ENDIF
IF \2 = ne
Expand
snz
noexpand
ENDIF
IF \2 = lt
expand
snc
noexpand
ENDIF
IF \2 = gt
expand
sc
noexpand
ENDIF
expand
jmp \4
noexpand
ENDM

la seguente risposta è un piacere da parte di Erisc Smith. Attualmente ogni volta che l'SX prova a bypassare un'istruzione PAGE o BANK egli bypassa anche l'istruzione successiva. Questo non è documentatao negli ultimi datasheet; Loren Blaney ha scoperto ciò per caso. Comunque è tutto riportato nel manuale SX corrente.