[critor]

Dans une news précédente, nous vous découvrions une version apparemment très rare de la TI-81, la V2.00.

Par la suite, grâce à un généreux prêt d'un des membres les plus réputés de la communauté TI-z80 anglophone, nous avions pu vous réaliser un test matériel de cette calculatrice.



TI-Planet a toujours oeuvré pour la sauvegarde du patrimoine historique des calculatrices graphiques en voie de disparition.

Nous avons déjà de nombreux sauvetages réalisés, qui incluent entre autres des photos externes et internes, mais surtout le "dumping" (numérisation) du contenu de la ROM avant que le dernier exemplaire au monde n'ait cessé de fonctionner:

• TI-Nspire CAS+
• TI-82 10.0, 11.0 et 12.0
• TI-81 1.6K, 1.1K et 1.5V
• TI-80 3.0 et 4.0

Petite particularité de la TI-81, elle ne dispose pas de prise de communication mini-Jack.

Les TI-81 V2 ont bien l'emplacement pour la prises mini-Jack en interne puisqu'utilisant une carte mère de TI-82, mais les composants nécessaires ne sont pas soudés.

Le dumping s'effectue donc d'une façon fort originale, en exécutant un programme assembleur saisi à la main via une faille, et en filmant le contenu de la ROM qui défile à l'écran.

Découvrez enfin la méthode en image:

Mon nouveau film "TI-81 V2.00" est désormais bouclé, et je vous dis à très bientôt pour la phase OCR!



Lien:
Méthode de dumping TI-81

[nikitouzz]

Voici les resultat du petit concours d'optimisation que j'ai lancé il y a une semaine

En Axe le premier est Runer112 sur les 5 participant Il reporte haut la main avec un code optimiser a 436 octets, en reprenant fidèlement mon code de départ dans ses moindre détaille je tiens a le felicitee pour son code qui est pour moi parfait

il va donc en finale

Code de depart :

Code: Select all

:ClrHome
:[FF818181818181FF]→pic0
:[FFC3A59999A5C3FF]→pic1
:[0000000000000000]→pic9
:0→S
:1→A
:2→B
:ClrDraw
:Repeat getKey(15)
:Pt-Change(A*8,B*8,Pic0)
:DispGraph
:Pt-Change(A*8,B*8,Pic0)
:Pause 100
:If getKey(1) and (B≠7) and (pxl-Test(A*8,B+1*8)=0)
:B+1→B
:S++
:pause 250
:End
:If getKey(2) and (A≠1) and (pxl-Test(A-1*8,B*8)=0)
:A-1→A
:S++
:pause 250
:End
:If getKey(3) and (A≠11) and (pxl-Test(A+1*8,B*8)=0)
:A+1→A
:S+1→S
:pause 250
:End
:If getKey(4) and (B≠1) and (pxl-Test(A*8,B-1*8)=0)
:B-1→B
:S+1→S
:pause 250
:End
:If getKey(3) and (pxl-Test(A+1*8,B*8)=1) and (pxl-Test(A+2*8,B*8)=0) and (A≠10) and (pxl-Test(A+1*8+1,B*8+2)=0)
:Pt-Off(A+1*8,B*8,Pic9)
:Pt-Off(A+2*8,B*8,Pic1)
:A+1→A
:S+1→S
:pause 250
:End
:If getKey(2) and (pxl-Test(A-1*8,B*8)=1) and (pxl-Test(A-2*8,B*8)=0) and (A≠2) and (pxl-Test(A-1*8+1,B*8+2)=0)
:Pt-Off(A-1*8,B*8,Pic9)
:Pt-Off(A-2*8,B*8,Pic1)
:A-1→A
:S+1→S
:pause 250
:End
:If getKey(1) and (pxl-Test(A*8,B+1*8)=1) and (pxl-Test(A*8,B+2*8)=0) and (B≠6) and (pxl-Test(A*8+1,B+1*8+2)=0)
:Pt-Off(A*8,B+1*8,Pic9)
:Pt-Off(A*8,B+2*8,Pic1)
:B+1→B
:S+1→S
:pause 250
:End
:If getKey(4) and (pxl-Test(A*8,B-1*8)=1) and (pxl-Test(A*8,B-2*8)=0) and (B≠2) and (pxl-Test(A*8+1,B-1*8+2)=0)
:Pt-Off(A*8,B-1*8,Pic9)
:Pt-Off(A*8,B-2*8,Pic1)
:B-1→B
:S+1→S
:pause 250
:End
:End


Code d'arrivée :

Code: Select all

:0->^^oDEBUG
:[FF818181818181]->Pic0
:[FFC3A59999A5C3FF]->Pic1
:L1+706->Pic9
:ClrDraw(L1)
:ClrDraw
:2*96+1+L6->P->r2
:(Pic0)Draw()
:...If ^^oDEBUG
:4*96+4+L6->r2
:(Pic1)Draw()
:...
:While 1
:DispGraph
:Pause 100
:4
:While 1
:End!If Select(,TryMv())-1
:3
:While 1
:End!If Select(,TryPs())-1
:4TryPs()
:EndIf getKey(15)
:Lbl KOfs
:[60FF01A0]->GDB0
:Return sign{r1-1+GDB0}
:Lbl CanMv
:ReturnIf +P->r2 and |EDF-|E9381*3plotdot|E0820
:Return {r2}
:Lbl TryMv
:Return!If getKey(->r1)
:Lbl Mv
:ReturnIf KOfs()CanMv()
:r2->P
:S++
:Pause 250
:Pic0
:Lbl DrwMv
:Draw()
:-96->r2
:Pic9
:Lbl Draw
:For(8)
:Select(,{}->{r2}+12->r2)+1
:End
:Lbl SKOfs
:r2-KOfs()
:Return
:Lbl TryPs
:Return!If getKey(->r1)
:ReturnIf KOfs()*2CanMv()
:ReturnIf {SKOfs()+12} xor |EC3
:(Pic1)DrwMv()
:Goto Mv


Code le plus optimisé :

Code: Select all

:0->^^oDEBUG
:[FF818181818181]->Pic0
:[FFC3A59999A5C3FF]->Pic1
:L1+706->Pic9
:ClrDraw(L1)
:ClrDraw
:2*96+1+L6->P->r2
:(Pic0)Draw()
:...If ^^oDEBUG
:4*96+4+L6->r2
:(Pic1)Draw()
:...
:While 1
:DispGraph
:Pause 100
:4
:While 1
:End!If Select(,TryMv())-1
:3
:While 1
:End!If Select(,TryPs())-1
:4TryPs()
:EndIf getKey(15)
:Lbl KOfs
:[60FF01A0]->GDB0
:Return sign{r1-1+GDB0}
:Lbl CanMv
:ReturnIf +P->r2 and |EDF-|E9381*3plotdot|E0820
:Return {r2}
:Lbl TryMv
:Return!If getKey(->r1)
:Lbl Mv
:ReturnIf KOfs()CanMv()
:r2->P
:S++
:Pause 250
:Pic0
:Lbl DrwMv
:Draw()
:-96->r2
:Pic9
:Lbl Draw
:For(8)
:Select(,{}->{r2}+12->r2)+1
:End
:Lbl SKOfs
:r2-KOfs()
:Return
:Lbl TryPs
:Return!If getKey(->r1)
:ReturnIf KOfs()*2CanMv()
:ReturnIf {SKOfs()+12} xor |EC3
:(Pic1)DrwMv()
:Goto Mv


En Basic le gagnant est Linkaro qui remporte le concours avec un score moyen car aucun des 6 participants n'a su me faire un code fonctionnel a 100%.

Il va donc en finale

Code de depart :

Code: Select all

:Lbl 0:0→∟AD(1)
:Menu("JEUX","jouer",8,"quitter",9)
:Lbl 8
:ClrHome
:200→D
:Output(4,6,"00000")
:Output(5,6,"0  0")
:Output(6,6,"0  0")
:Output(7,6,"0  0")
:Output(8,6,"00000")
:Lbl 1
:∟AD+1→∟AD
:randInt(1,9)→A
:Repeat D=0
:D-1→D
:Output(1,1,"    ")
:Output(1,1,D)
:Output(2,1,∟AD(1))
:Output(6,8,A)
:0→B
:getKey→B
:B+A→C
:If C=93 or C=95 or C=97 or C=86 or C=88 or C=90 or C=79 or C=81 or C=83
:Goto 1
:End
:ClrHome
:Output(3,5,"SCORE:)
:Output(4,6,∟AD(1))
:If ∟AD(1)>∟AC(1)
:∟AD(1)→∟AC(1)
:Pause
:Goto 0
:Lbl 9


Code d'arrivée :

Code: Select all

DelVar SClrHome
randInt(1,9→A
For(D,200,1,¯1
Output(2,2,"  "
Output(2,1,D
Output(3,1,S
Output(1,1,A
getKey→B
{92,93,94,82,83,84,72,73,74
If B=Ans(A
Then
S+1→S
randInt(1,9→A
End
End
ClrHome
max(S,∟AC(1→∟AC(1
Disp "SCORE:
S


Code le plus optimisé : ( ici c'est le mien )

Code: Select all

:0->S
:900->C
"Menu("","",1,"",2
:Lbl 1
:randint(1,9->F
:while C
:output(2,3,F
:output(5,1,C
:output(4,1,S
:C-1->C
:{92,93,94,82,83,84,72,73,74
:If getkey=Ans(F
:then
:S+1->S
:randint(1,9->F
:end
:end
:Lbl 2
:output(1,1,""
:output(4,6,"SACHA"


Pour la finale :

Le but est de me programmer un snake, en basic pour linkaro et en Axe pour runer112 le plus simple et le plus optimisé possible.
Le code qui techniquement sera supérieur à l'autre sera vainqueur (ne vous inquiétez pas je vais compter l’écart de puissance entre le basic et l'axe).

La finale commence dés aujourd'hui et finis le 16/08/2012 a 12 heures pile.

Bonne chance a vous runer112 et linkaro


edit by Laurae : majuscules manquantes et erreurs d'orthographe corrigés

[nikitouzz]

Comme je me suis dit que pendant les vacances, il n'y avait rien de special, je me suis permis de lance un petit concours sur Espace-TI ici

J’arrête de recevoir les optimisations lundi 6/08/2012 a 00h00, envoyez-moi vos codes le dimanche car le lundi ça sera trop tard, je les corrige le matin même et à 6-7 heure les resultat seront là

Il s'agit d'un concours d’optimisation, j'y ai inclus deux codes l'un en Axe et l'autre en TI-basic, le but étant de réduire leur taille sans que leur fonctionnement ne change, pour le premier tour.

(eh non il n'y a rien à gagner par contre j'aurais bien offert une nspire_cx cas mais c’était un peu cher ^^ )



Pour participer, envoyez-moi vos réponses en MP ou a cette adresse : sacha.stef@hotmail.fr
attention !!! il faut participer dans une seule catégorie, pas les deux !!!!

Axe : c'est un moteur de jeu donc le screen est plus bas.

Code: Select all

:[FF818181818181FF]→pic0
:[FFC3A59999A5C3FF]→pic1
:[0000000000000000]→pic9
:0→S
:1→A
:2→B
:ClrDraw
:Repeat getKey(15)
:Pt-Change(A*8,B*8,Pic0)
:DispGraph
:Pt-Change(A*8,B*8,Pic0)
:Pause 100
:If getKey(1) and (B≠7) and (pxl-Test(A*8,B+1*8)=0)
:B+1→B
:S++
:pause 250
:End
:If getKey(2) and (A≠1) and (pxl-Test(A-1*8,B*8)=0)
:A-1→A
:S++
:pause 250
:End
:If getKey(3) and (A≠11) and (pxl-Test(A+1*8,B*8)=0)
:A+1→A
:S+1→S
:pause 250
:End
:If getKey(4) and (B≠1) and (pxl-Test(A*8,B-1*8)=0)
:B-1→B
:S+1→S
:pause 250
:End
:If getKey(3) and (pxl-Test(A+1*8,B*8)=1) and (pxl-Test(A+2*8,B*8)=0) and (A≠10) and (pxl-Test(A+1*8+1,B*8+2)=0)
:Pt-Off(A+1*8,B*8,Pic9)
:Pt-Off(A+2*8,B*8,Pic1)
:A+1→A
:S+1→S
:pause 250
:End
:If getKey(2) and (pxl-Test(A-1*8,B*8)=1) and (pxl-Test(A-2*8,B*8)=0) and (A≠2) and (pxl-Test(A-1*8+1,B*8+2)=0)
:Pt-Off(A-1*8,B*8,Pic9)
:Pt-Off(A-2*8,B*8,Pic1)
:A-1→A
:S+1→S
:pause 250
:End
:If getKey(1) and (pxl-Test(A*8,B+1*8)=1) and (pxl-Test(A*8,B+2*8)=0) and (B≠6) and (pxl-Test(A*8+1,B+1*8+2)=0)
:Pt-Off(A*8,B+1*8,Pic9)
:Pt-Off(A*8,B+2*8,Pic1)
:B+1→B
:S+1→S
:pause 250
:End
:If getKey(4) and (pxl-Test(A*8,B-1*8)=1) and (pxl-Test(A*8,B-2*8)=0) and (B≠2) and (pxl-Test(A*8+1,B-1*8+2)=0)
:Pt-Off(A*8,B-1*8,Pic9)
:Pt-Off(A*8,B-2*8,Pic1)
:B-1→B
:S+1→S
:pause 250
:End
:End


un peu d'aide :

TI-basic : c'est un petit jeu tout simple qui est bien lourd pour sa simplicitee

Code: Select all

:Lbl 0:0→∟AD(1)
:Menu("JEUX","jouer",8,"quitter",9)
:Lbl 8
:ClrHome
:200→D
:Output(4,6,"00000")
:Output(5,6,"0  0")
:Output(6,6,"0  0")
:Output(7,6,"0  0")
:Output(8,6,"00000")
:Lbl 1
:∟AD+1→∟AD
:randInt(1,9)→A
:Repeat D=0
:D-1→D
:Output(1,1,"    ")
:Output(1,1,D)
:Output(2,1,∟AD(1))
:Output(6,8,A)
:0→B
:getKey→B
:B+A→C
:If C=93 or C=95 or C=97 or C=86 or C=88 or C=90 or C=79 or C=81 or C=83
:Goto 1
:End
:ClrHome
:Output(3,5,"SCORE:)
:Output(4,6,∟AD(1))
:If ∟AD(1)>∟AC(1)
:∟AD(1)→∟AC(1)
:Pause
:Goto 0
:Lbl 9
:ClrHome
:Output(4,6,"sacha")
:Output(1,1"")


pas besoin de screen pour celui la



voila voila ( phrase que je ne supporte pas entendre ^^ ) il faut m’optimiser tout ça pour le lundi 6/08 et envoyez-moi vos réponses dans une seule catégorie

[critor]

Dans une news précédente nous avions vu qu'il existait des supports permettant de solidariser l'interface de mesures physiques TI-CBL2 de votre calculatrice graphique.

Texas Instruments les appelle 'cradles' en anglais, ce qui se traduit littéralement par 'berceaux'.

Nous vous montrions donc le support permettant de tenir d'une seule main le TI-CBL2 adjoint à une calculatrice avec un boîtier de type TI-83 ou similaire (premières TI-73, TI-76, TI-81, TI-82, TI-89).

Nous remarquions que ce support ne convenait pas aux calculatrices munies d'un boîtier de type TI-84 Plus plus gros que l'on ne pouvait insérer.

Dans une news ultérieure, nous avions vu un support similaire permettant de maintenir la calculatrice en position inclinée pendant une saisie sur le TI-Keyboard.

Le support présenté convenait aux calculatrices avec un boîtier de type TI-84 Plus (TI-89 Titanium):

Nous voyions là qu'inversement, le support ne convenait pas aux calculatrices avec un boîtier de type TI-83, ces dernières ne disposant pas au dos des deux rainures permettant de fixer le pied:

Or, Texas Instruments depuis l'année dernière a sorti de nouvelles calculatrices disposant de boîtiers complètement différents, la TI-84 Pocket.fr en France et la TI-84 Plus Pocket SE en Asie.

On peut donc se demander à quel type de support convient ce nouveau boîtier: TI-83 ou TI-84 Plus?

Les dimensions extrêmement réduites des TI-84 Pocket ne leur permettent pas d'être maintenues stables dans le support TI-83 du TI-CBL2.

Ce n'est pas mieux avec le support TI-84Plus du TI-Keyboard, puisque l'absence de rainure au dos des TI-84 Pocket ne permet pas d'offrir de fixation au pied du support.

Au final, ni le support pour boîtiers TI-83, ni le support pour boîtiers TI-84 Plus ne semble convenir aux nouvelles TI-84 Pocket.





Nous ne vous avons pas parlé d'un autre périphérique: le TI-Robot. Là, il suffisait d'apposer deux bandes de velcroc sur le couvercle de la calculatrice, pour pouvoir ensuite le fixer sur le périphérique et glisser la calculatrice dedans.

Mais problème... Les TI-84 Pocket n'ont pas de couvercle... Depuis le départ leur boîtier n'a absolument pas été prévu pour accueillir un couvercle puisqu'il n'y a aucune rainure!

Là encore, il est impossible de fixer la calculatrice TI-84 Pocket sur le périphérique, aucun couvercle TI existant n'offrant de prise stable au boîtier, ce qui va être très embêtant quand le TI-Robot va rouler et surtout tourner...

En conclusion, le boîtier TI-84 Pocket ne semble donc pas du tout avoir été développé en tenant compte des supports périphériques déjà existants.

Cela peut parfaitement se comprendre par la rareté parfois extrême des périphériques ci-dessus (TI-Keyboard diffusé uniquement en Amérique du Nord, TI-Robot diffusé uniquement en Amérique du Nord et de plus non officiel car développé par une société tierce). Seul le TI-CBL2 est diffusé en Europe, mais avec une visibilité bien moindre que celle des calculatrices.

C'est pour ces raisons-là, que je ne pense pas qu'il y ait de solution de fixation en développement pour les TI-84 Pocket.

[critor]

Après un petit peu plus de 2 mois de développement, Lionel Debroux vient de lancer le beta testing public de la prochaine version de TILP-II: 1.17.

Pour ceux qui ne le savent pas, TILP est un logiciel communautaire libre de transfert pour calculatrices TI. C'est le plus évolué, et le seul qui soit maintenu.
Un de ses principaux avantages est qu'il gère à la fois les calculatrices TI-z80, TI-68k et TI-Nspire. A lui tout seul, il constitue donc une alternative au couple TI-Connect / TI-Nspire Computer Link.

Il fait même parfois mieux que les logiciels officiels, puisqu'il arrive à communiquer avec les TI-85 et TI-82 grises via la câble TI-Graph Link USB, ce dont TI-Connect est incapable!


Un de ses inconvénients majeurs est la nécessité d'utiliser des pilotes différents de ceux de TI, pour des questions de confiance et de licence. Les logiciels de transfert officiels ne peuvent plus fonctionner correctement, tant que les pilotes officiels ne sont pas réactivés.

Toutefois, il y avait eu des progrès sur ce point, avec la possibilité d'installer (hélas manuellement) un filtre de pilotes depuis la version 1.16. Après cette installation, ce filtre s'occupe automatiquement d'utiliser le pilote adapté au logiciel, sans que l'utilisateur ait à intervenir sur le système.



Venons donc enfin à ce qui pour moi constitue la nouveauté principale et la plus extraordinaire de la version 1.17: le dumping (ou numérisation) des ROMs z80 pour les adeptes de l'émulation. TILP permet depuis longtemps cette fonctionnalité absente de TI-Connect: il suffit d'un double-clic sur l'item 'système'.

Le dumping d'une ROM nécessite un programme assembleur. Or, certaines calculatrices graphiques TI dont les plus anciennes, sont dépourvues de commande officielle permettant d'exécuter du code assembleur. Il s'agit des:

• TI-73 / TI-73 Explorer
• TI-82
• TI-85
• TI-92

Dans ces cas-là TILP demandait à ce que l'on installe un kernel, qui permettait ensuite l'exécution de programmes assembleur.

Et bien grâce à une nouvelle faille, Benjamin Moody a réussi un exploit inimaginable et arrive à faire exécuter de l'assembleur sans installation de kernel sur les trois modèles TI-z80 ci-dessus.
Son nouveau programme de dumping est intégré à TILP et permet désormais réellement de récupérer la ROM en un simple double-clic!

Mais ce n'est pas tout... Encore plus extraordinaire, ce programme marche même sur les ROMs TI-82 antérieures à la 16.0 pour lesquelles il n'existe aucun kernel!
A l'époque, nous avions du dumper les ROMs 10.0, 11.0 et 12.0 de la TI-82 péniblement à la main, morceau par morceau. Nous avons justement pu vérifier lors de l'alpha-test privé que les fichiers récupérés sur ces modèles fort rares étaient à 100% identiques avec ceux que nous avions déjà!

Désormais, si nous mettons la main sur d'autres versions jamais dumpées/numérisées de la TI-82 comme les 3*, 4*, 7*, 15.0 ou de la TI-85 comme la 1.0, grâce à TILP 1.17 nous devrions être capables de les récupérer sans y passer une demi-journée!



Source:
http://www.omnimaga.org/index.php?topic ... #msg257193

Liens:
Installeur Windows de TILP II 1.17 beta: http://lpg.ticalc.org/prj_tilp/beta/setup.exe
Patches pas encore committés vers SVN / Git (car il manque de petits trucs): http://lpg.ticalc.org/prj_tilp/beta/pat ... 10.tar.bz2