Ca non plus :

	.org 9319h
 
start:
	ret  
  
	.end  
END
Compilé avec z80asm ce code ne fonctionne pas...

org 9327h
	ret
end
J'sais pas c'est bizarre, mais spasm peut faire des programmes TI 83, et j'ai déjà testé avec tasm, même résultat. A mon avis tu devrais essayer d'voir avec les vieux tutos qui trainent sur ticalc...

D'toute manière le code produit par le compilo est le même avec ./28 que ./30 et ./31 (y'a juste l'adresse de départ qui change), donc c'pas la peine de faire plusieurs postes pour ça.
Ok bah ça m'enlève déjà un gros doute.
(Sachant que z80asm sait faire des prog pour ti83 également)

J'ai essayé d'utilisé bin8x et ça me donne la même erreur.

le code produit par le compilo est le même [...] donc c'pas la peine de faire plusieurs postes pour ça. 


Arf désolé je ne m'en suis pas rendu compte.

Par ailleurs je viens de tester LongWorm :
Il tourne avec send(9.
Il est facilement compilable avec spasm.
Mais il marche pas quand je le compile moi-même.
LW.ASM

; Long Worms 1.0 is Coded by: Tim Hegyi (tim_hegyi@hotmail.com)

; Feel free to copy or change the source code... By pleas e-mail me if you do that.

; This is my first asm game.. wow!



#DEFINE EQU .equ

#include "ti83asm.inc"

#include "tokens.inc"

#DEFINE way	9327h

#DEFINE curco	8280h

#DEFINE curcoo	8285h ;you can delete this.. if you wan't to

#DEFINE xcoord	8270h

#DEFINE ycoord	8275h

.org $9327

prog_s:

	call _clrlcdfull

	call _runindicoff

	;call _gfbufclr

	ld hl,1

	push hl

	ld hl,32

	ld (ycoord),hl

	ld hl,48

	ld (xcoord),hl

	ld hl,1

	ld (way),hl

	call _homeup

	ld hl,fp

	call _puts

	ld hl,17

	ld (pencol),hl

	ld hl,25

	ld (penrow),hl

	ld hl,codedby

	call _vputs

	ld hl,8

	ld (pencol),hl

	ld hl,35

	ld (penrow),hl

	ld hl,email

	call _vputs

	ld hl,31

	ld (pencol),hl

	ld hl,55

	ld (penrow),hl

	ld hl,pent

	call _vputs





	;call _newline

	;ld a,(highscore)

	;ld l,a

	;ld h,0

	;call _dispHL







	call _getkey

	call _clrlcdfull

	ld b,0

	ld c,54

	ld d,96

	ld e,54

	ld h,1

	call _iline

	ld hl,1

	ld (pencol),hl

	ld hl,1

	ld (penrow),hl

	ld hl,tit

	call _vputs

	ld a,1

	ld (curco),a



mainloop:

; loop so the worm dosen't go so fast.

; but the "loop" code can be smaler but i cuden't do that...



ml:

	ld a,(curco)

	inc a

	ld (curco),a

	sub 255

	jp z,el

	jp ml

el:

	ld a,1

mll:

	ld a,(curco)

	inc a

	ld (curco),a

	sub 255

	jp z,ell

	jp mll

ell:

	ld a,1

mlll:

	ld a,(curco)

	inc a

	ld (curco),a

	sub 255

	jp z,elll

	jp mlll

elll:

	ld a,1



mllll:

	ld a,(curco)

	inc a

	ld (curco),a

	sub 255

	jp z,ellll

	jp mllll

ellll:

	ld a,1



mlllll:

	ld a,(curco)

	inc a

	ld (curco),a

	sub 255

	jp z,elllll

	jp mlllll

elllll:

	ld a,1



mllllll:

	ld a,(curco)

	inc a

	ld (curco),a

	sub 255

	jp z,ellllll

	jp mllllll

ellllll:

	ld a,1

mlllllll:

	ld a,(curco)

	inc a

	ld (curco),a

	sub 255

	jp z,elllllll

	jp mlllllll

elllllll:

	ld a,1

mllllllll:

	ld a,(curco)

	inc a

	ld (curco),a

	sub 255

	jp z,ellllllll

	jp mllllllll

ellllllll:





	;get keys



	ld a,0ffh

	out (1),a

	ld a,0feh

	out (1),a

	in a,(1)

	cp 253

	jp z,only_left

	cp 251

	jp z,only_right

	cp 254

	jp z,only_down

	cp 247

	jp z,only_up

	ld a,0ffh

	out (1),a

	ld a,0fdh

	out (1),a

	in a,(1)

	cp 191

	jp z,Crash

back_gk:



	ld a,(way)

	sub 1

	jp z,left

	ld a,(way)

	sub 2

	jp z,up

	ld a,(way)

	sub 3

	jp z,right

	ld a,(way)

	sub 4

	jp z,down

bf_rk:



	

	ld a,(xcoord)

	ld b,a

	ld a,(ycoord)

	ld c,a

	ld d,3

	call _ipoint

	sub 0

	jp z,hh

	jp Crash



hh:



	ld a,(ycoord)

	cp 0

	jp z,crash



	ld a,(xcoord)

	cp 97

	jp z,crash



	ld a,(xcoord)

	cp 0

	jp z,crash



	ld a,(xcoord)

	ld b,a

	ld a,(ycoord)

	ld c,a

	ld d,1

	call _ipoint



	pop hl

	ld de,1

	add hl,de

	push hl



	ld a,1



	jp mainloop







Only_Up:

	ld hl,4

	ld (way),hl

	jp back_gk

Only_Down:

	ld hl,2

	ld (way),hl

	jp back_gk

Only_Left:

	ld hl,1

	ld (way),hl

	jp back_gk

Only_Right:

	ld hl,3

	ld (way),hl

	jp back_gk









up:

	ld a,(ycoord)

	dec a

	ld (ycoord),a

	jp bf_rk

down:

	ld a,(ycoord)

	inc a

	ld (ycoord),a

	jp bf_rk

left:

	ld a,(xcoord)

	dec a

	ld (xcoord),a

	jp bf_rk

right:

	ld a,(xcoord)

	inc a

	ld (xcoord),a

	jp bf_rk



Crash:

	call _clrlcdfull

	ld hl,1

	ld (currow),hl

	ld hl,1

	ld (curcol),hl

	ld hl,score

	call _puts

	ld hl,1

	ld (currow),hl

	ld hl,6

	ld (curcol),hl

	pop hl

	call _disphl

	call _newline

	ld hl,mb

	call _puts		

	call _newline

	ret



score:

	.db "Score: ",0

tit:

	.db "Long Worms By Tim Hegyi",0



mb:	;    1234567890123456

	.db " By:  Tim Hegyi ",0



fp:

	.db "                "

	.db " Long Worms 1.0 ",0

codedby:

	.db "Coded by: Tim Hegyi",0

email:

	.db "tim_hegyi@hotmail.com",0

pent:

	.db "Hit any key!",0



.end



Je commence vraiment à desespérer.
En examinant les codes binaires, je me suis rendu compte que mes codes générés par spasm ou z80asm ne correspondent pas du tout...

Sur les 2 programmes qui s'éxecutent (on peut voir que l'un d'eux est compilé avec chaos assembler) :


Un magic number tout d'abord : **TI83**
(rajouté par bin2var, bin8x ou binto83p)

Des octets libres pour l'ajout éventuel d'un commentaire.
(bin2var et chaos assembler ne s'en privent pas)

Ensuite au 60 ème octet le nom du programme.
8 octet lui sont apparemment reservé...Ou alors sa taille est spécifiée juste avant (il y a des octet initialisés)
Mais je penche pour la taille fixe de 8 char.
(Je crois d'ailleurs qu'il ne faut pas dépasser cette taille pour un nom de programme)

D'abord 4 octet pour le début du programme.
L'adresse de départ semble y être stockée.

Ensuite le code à proprement parler :
43 44 35 35 34 37 : CD 5547 pour _ClrLcdFull
43 44 39 35 34 37 :CD 9547 pour runindicoff

etc...

Puis la chaine de fin :
Le fameux end:000:end si je ne me trompe pas...

30 3F D4 3F 30 30 3F D4 + 2 octet qui trainent.
Qui donne en chaine de char interpreté par hexedit : 0?.?0000?.

Sur ce que je compile, il n'y a rien de commun a part le magic number et les romcall qui apparaissent "CD 5547" donc comme il faut.
Voila dites moi si je me trompe...?

trombz3gP (hex.png)


Edit : En fait j'ai trouvé un document là dessus :
I) Normal files such as Program file (*.82p)

--------------------------------------------



  The following is a table of the bytes that make up the header of the *.82p

file:



  Byte(s)					 What It Contains

  ---------------------------------------------------------------

  0x00-0x10	0-10				 **TI82** 0x1A 0x0A 0x00

  0x0B-0x34	11-52                            Comment

  0x35-0x36	53-54                            (68-69)+4+3+[strlen(Name)=8]

			begin of var header	---------- 

  0x37-0x38	55-56                            0x0B 0x00

  0x39-0x3A	57-58                            Repeats 68-69

  0x3B		59                               0x05 unprotected

		                                 0x06 protected

  0x3C-0x43	60-67                            Name of program (8 chars)

			end of var header	----------

			begin of data part	----------

  0x44-0x45	68-69                            (70-71)+2

  0x46-0x47	70-71                            Length of file (n) to end minus Checksum

  0x48-(n-2)	72-(n-2)                         Actual program

  		(n-1)-(n)                        Checksum

			end of data part	----------



The checkum is the sum of all bytes starting at the var header (0x0B).

(EDIT : au fait merci à Romain Lievins pour cette doc)

Apparement le format de fichier est le même pour 82 et 83...?
J'ai (ENFIN!) réussi à faire tourner un programme sur ti83 !!!

Mais le problème demeure.
J'ai compilé ce code avec TASM, puis utilisé Obj83 puis testé avec VTI.

Voila le code:
(Il s'agit d'un code tout ce qu'il y a de plus classique que nous avons maintes fois cité plus tôt...)

.NOLIST
#define equ .equ
#define EQU .equ
#define end .end
#include "ti83asm.inc"
#include "tokens.inc"
.LIST
.org 9327h
	call _CLRLCDFULL
	ret
.end
END
J'vois toujours pas d'où peut venir le problème... ion.inc peut être, mais pour moi ça buggait quand même avec ti83asm.inc et tokens.inc, et ça m'étonnerai qu'ça vienne de spasm.
Pour moi il y a clairement un problème.

Je me demande si un jour quelqu'un a réussi a compiler un code pour ti83 avec spasm/z80asm/zasm sous linux (spasm existe sous windows).
De mon cote, après plus de 200 hello world foireux, des topics sur 3 forums, plusieurs conversations sur irc, je n'ai trouvé personne qui fasse de l'assembleur pour ti83 sous linux...
(Mais je ne suis pas catégorique, il ne s'agit que de suppositions)

Je m'explique :

z80asm et spasm générent le même code.
Du moins sur les échantillons testés...
Par exemple pour ce code :
.NOLIST

#define equ .equ

#define EQU .equ

#define end .end

#include "ti83asm.inc"

#include "tokens.inc"

.LIST

.org 9327h

	call _CLRLCDFULL
	ret

.end

END


Donne (avec z80asm et spasm) :
CD 55 47 C9                                         .UG.


Avec CD = call
55 47 = addresse de la rom call.
C9 = ret

(de même 21 01 00 équivaut à "ld hl,1" etc...)

Tasm, lui, pour le même code génére :
 3A 30 37 39  33 32 37 30  30 43 44 35  35 34 37  :07932700CD5547
 43 39 45  42 0D 0A 3A  30 30 30 30                       C9EB..:0000
 30 30 30 31  46 46 0D 0A                                       0001FF..

Beaucoup plus long, et rien de commun au niveau de l'hexa.
Ici on a :
0D 0A 3A 30 30 30 30 30 30 30 31 46 46 0D 0A
Qui doit correspondre à la chaine End:0000:End
Ou du moins le délimiteur qui dit "ici c'est fini".

Avec zasm (toujours le même code) :
3A 30 34 30  30 30 30 30  30 43 44 35  35 34 37 43  :04000000CD5547C
39 43 41 0D  0A 3A 30 30  30 30 30 30  30 31 46 46  9CA..:00000001FF
0D 0A                                                                            ..


Ca ressemble... mais comme après bin8x ou bin2var ne font pas du tout le même boulot que Obj83.exe, au final ce ne sera pas bon !
(ils oublient de transformer 0D 0A 3A 30 30 30 30 30 30 30 31 46 46 0D 0A en 3F D4 3F 30 30 30 30 3F D4 )


Pour conclure, je pense que le code généré par spasm et z80asm ne correspond pas à ce qu'attend la ti83.
On ne peut pas se dire qu'il y a un probleme de compilation, car les 2 outils produisent le même code, et de plus z80asm (tout comme spasm?!) est un outil fiable.

De plus, compiler pour TI83PLUS marche parfaitement.
Mon idée est que la TI83PLUS est plus "tolérente"...
Notamment la méthode Asm( ne doit pas executer le code de la même manière que Send(9 ...

Je ne me suis évidemment pas arrété là...grin
J'ai remarqué qu'il y a correspondance entre les code spasm/z80asm et TASM.

Regardez bien : CD 55 47 C9 apparait à droite dans l'équivalence en caractère pour TASM et en tant que code hexa pour spasm/z80asm.
De plus, TASM rajoute une chaine de fin qui est absente du code de z80asm/spasm.
Autre chose, mais qui ne semble pas nécessaire pour l'instant :
L'adresse 9327 apparait chez TASM et pas chez spasm/z80asm.
Elle ne semble pas absolument nécessaire... (c'est plutôt étonnant!)

zasm (compilateur du projet LPG) est assez proche de TASM niveau code.
Mais il y a des variantes, et le code 83P avec bin8x ou bin2var ne donne rien qui aille.

Finalement, voici un convertisseur, à appliquer sur un code .bin avant de le passer à la moulinette bin2var :
#include <stdio.h> /* standard input output header */
#include <malloc.h> /* malloc */
#include <string.h> /* strcpy */
/* You should use spasm or maybe z80asm to compile your files */
/* zasm seems not working :( */
/* After generate the new *****.bin, you must use bin2var (bin8x seems not working) to generate a 83p file */

int main(int argc, char * argv[]) {


FILE * fpr;
FILE * fp;
int e;
char * outfilename;
char c;
char end[] =
{0x3F ,0xD4  ,0x3F ,0x30 ,0x30 ,0x30  ,0x30 ,0x3F ,0xD4};

printf("bin2bin83 by Thibault Duponchelle <t.duponchelle@gmail.com>\n\n");
/* open bin files */
if(argc<2) {
	printf("*******Not enough args*******\n");
	printf("usage : bin2bin83 input.bin [output] \n");
	printf("output is not necessary, by default \"output.bin\" will be generated.\n");
	printf("output parameter must be like this : \"WORM\" NOT like \"WORM.BIN\".\n");
	printf("Example : 'bin2bin83 foo.bin BAR'\n");
	printf("The output will be \"BAR83.bin\".\n(note : '83.bin' have been automatically added).\n");
	return 0;
} else {
	if((fpr = fopen(argv[1], "r+b"))) {
		if(argc>2) {
			outfilename=malloc(strlen(argv[2])+6);
			strcpy(outfilename,argv[2]);
			strcat(outfilename,"83.bin");
			if(!(fp=fopen(outfilename,"w+b"))) {
				printf("CAN NOT open output.bin");
				fclose(fpr);
				return 1;
			}
		}else {
			outfilename=malloc(strlen("output.bin")+1);
			strcpy(outfilename,"output.bin");
			if(!(fp=fopen(outfilename,"w+b"))) {
				printf("CAN NOT open output.bin\n");
				fclose(fpr);
			return 1;
			}
		}
		
		while((e=fgetc(fpr))!=EOF)
		{
			//printf("%c= %02X ",c, c); //Print hexa code could bug the console ;D
			fprintf(fp,"%02X",e);
		}
		fwrite(&end,9,1,fp);
		printf("output : %s\n",outfilename);
		fclose(fp);
		fclose(fpr);

	} else {
		printf("CAN NOT open %s\n",argv[1]);
	}
printf("Please send me your feedback : <t.duponchelle@gmail.com>\n");
return 0;
}

}


Compiler ce fichier puis :
>spasm toto.asm
>./bin2bin83 toto.bin tata.bin
>bin2var tata.bin TATA.83P

Et là ca marche !!!

C'est quand même hallucinant, tous les octets du fichier binaire d'entrée sont modifiés...
Mais le fichier final est correct et il comporte en plus la chaine de fin représentée ici par :
char end[] =
{0x3F ,0xD4 ,0x3F ,0x30 ,0x30 ,0x30 ,0x30 ,0x3F ,0xD4};


Voila, si quelqu'un peut me dire si je me trompe, si ce n'est pas absolument nécessaire...
Je serai content de l'entendre.

Mais en attendant, même LongWorm.z80 compile avec ça grin

J'espère que ce sera utile à quelqu'un.

Dites moi s'il faut y apporter des modifications, si j'ai fait une erreur quelque part (sur l'Asm, le C est baclé)
Rien n'est gravé dans la pierre.

Thibault Duponchelle