(Note légale : en plus de la licence globale de ce site, ce document et les codes de programmes inclus sont sous la licence GPL.)
Les calculatrices graphiques Casio, à l'instar de celles des autres marques, peuvent transférer certaines de leurs données vers d'autres calculatrices, ou vers un ordinateur, à l'aide de logiciels adéquats. Un problème se pose alors : celui des formats, ouverts ou non, et donc de l'indépendance des utilisateurs vis à vis de ces formats.
Cette étude va présenter les différents formats existants pour stocker des informations provenant d'une calculatrice (des données), dans l'optique suivante : déterminer s'il existe (ou sinon quelles devraient être les caractéristiques) d'un format de fichier ouvert permettant la diffusion de données entre utilisateurs (indépendamment de leurs logiciels/matériels) et l'édition de ces données.
Pour le moment, cette étude se limite aux données de type programmes
et backups
, qui sont celles dont le besoin de transfert/d'édition est le plus important. Je m'intéresserai peut-être aux autres données dans le futur, et mettrai à jour ce document. Néanmoins, toute contribution sera agréablement acceptée.
Table des matières :
- Le format brut
- Le format Calculator Text Format
- Le format cas
- Le format Fa-122/123 (cat)
- Le format Fa-124 (g1r)
- Le format Fx-Interface (fxi)
- Le format cafix
- Le format Fx-Interface Backup (fxb)
- Le format Fx-Interface Pro Backup (fxm)
- Le format Fx-Interface Pro (fxd)
- Conclusion : le format newcat
Le format brut
Le format brut
ou format raw
, est celui utilisé de façon interne par la calculatrice.
Pour les programmes, ce format consiste en un texte dont les caractères de base sont codés en ASCII sur 8 bits, c'est à dire les caractères A
à Z
, a
à z
, 0
à 9
, espaces , : ( ) . { } [ ] = ' " ~ * / #
.
Les sauts de lignes sont codées par un caractère de code 0D (13 - CR), la fin du programme par un caractère FF (255).
Les caractères spéciaux de la calculatrice (racine carrée, Pi, sin, etc) sont représenté par des codes ASCII-like, sur un octet, en utilisant les espaces restants (de 00 à FF, en excluant F7 et 7F (voir plus bas).
Les commandes (accessibles depuis les menus, en fait tout ce qui est inséré comme un caractère, mais qui s'affiche comme un mot - exemples : If , Locate , List ) sont elles codées sur deux octets, le premier commençant par F7 (247) ou 7F (127), et le second pouvant être un caractère entre 00 et FE.
Le format Calculator Text Format (ctf)
Le format CTF est un format ouvert créé pour enregistrer des programmes casio sous forme d'un fichier texte aisément éditable. Ce fichier peut aussi être lu facilement par les humains, afin de faciliter la lecture et le transfert de ceux qui ne possèdent pas de câble pour communiquer avec l'ordinateur. Vous pouvez consulter les spécifications du format CTF, en version pre-1 (Revision A). Ce format est enregistré dans des fichiers ayant l'extension .ctf ou .txt, et est utilisé par le logiciel libre de transfert CaS. Ce format n'est pas capable de différencier les programmes effectuants des calculs sur les bases pour le nouveau basic casio.
Le format cas
Le guide nous apprend ceci sur le format cas :
C'est le format officiel original de casio pour transférer des fichiers depuis votre ordinateur vers votre calculatrice par un câble.
C'est un format binaire qui est illisible par les humains sans un programme idoine
Le programme Casemul (émulateur de calculatrice graphique casio, sous Microsoft Windows - je n'ai pas trouvé de site officiel, une recherche Google vous donnera plusieurs où le télécharger) utilise un format dont l'extension est cas
. J'ignore s'il s'agit du même format que celui cité par Roy F. A. Maclean, mais c'est la seule occasion que j'ai eu de travailler avec des fichiers cas
.
Je n'ai donc pas étudié en détail ce format.
Le format Fa-122/123 (cat)
Le format cat est celui utilisé par les programmes FA-122 et FA-123, et est lisible par FA-124. Ce format est un format textuel, utilisant uniquement des caractères ASCII, avec des retours à la ligne en CRLF (0D 0A - 10 13).
En partant du format brut, on encode au format cat en convertissant les caractères spéciaux et les commandes avec des équivalences textuelles (par exemple, la commande If, codée en F7 00, devient \If
). Malheureusement, cat ne propose pas un équivalent pour tous les caractères spéciaux, aussi certains restent sous leur forme brute. Pour plus de détails, voici une table d'équivalence format brut/format cat sous forme de trois dictionnaires python, l'un pour les commandes, le second pour les caractères spéciaux, et le troisièmes pour d'autres caractères spéciaux, qui doivent être convertis en derniers (car ils sont présents dans des équivalences précédentes).
Le format cat peut contenir plusieurs données dans le même fichier. Les différentes données sont enregistrées à la suite dans le fichier, sous cette forme :
%Header Record
Format:TXT (1)
Communication SW:0
Data Type:PG (2)
Capacity: (3)
File Name:MyPrgm
Group Name:
Password: (4)
Option1:NL (5)
Option2:
Option3:
Option4:
%Data Record
Le programme, avec les equivalences, comme explique ci dessus
%End
- L'existence de cette ligne pourrait indiquer que les données peuvent être enregistrée dans un autre format que le format texte. Ou peut-être est-ce pour les images et autres données qui ne peuvent pas vraiment être enregistrée comme texte ? Je n'ai pas fait plus de recherches à ce sujet.
- Le
PG
veut certainement dire programme. N'ayant pas cherché pour les autres types de données, je ne connais pas leurs identifiants.
- Dans les fichiers cat, cette ligne est suivie d'un nombre, probablement la taille du programme en octet. Mais est-ce la taille sur la calculatrice (format brut) ou la taille avec les équivalents textuels ? Je ne me suis pas attardé sur ce point.
- D'après certaines lecture, le mot de passe serait ici stocké en clair.
- L'option 1 défini si le programme est normal (
NL
) ou utilise des calculs sur les bases (BN
).
Le format Fa-124 (g1r)
Le format g1r est le format du logiciel FA-124, utilisé par les modèles les plus récents de calculatrices casio (celles avec les câbles USB). Les programmes contenus dans ce genre de fichiers sont au format brut et sont entourés d'un bloc fixe de données contenant le nom du programme, et d'autres données dont la taille et le contenu sont très variables. Pour extraire les programmes d'un fichier g1r, on peut utiliser l'expression rationnelle suivante (ici en python avec le module re) :
g1r_file = open(filename, 'r')
# Expression rationnelle :
data_pattern = re.compile('''
(PROGRAM) # type de donnée, uniquement programme avec cette expression
[\x00]{12} # Séparateur
[\x01] # un 0x01 caractère (séparateur)
system # La chaîne 'system'
[\x00]{2} # Séparateur
([^\x00]{1,8}) # nom du programme
[\x00]{0,7} # caractères 0x00 qui complètent le nom
[\x01] # marqueur de fin du nom
[\x00]{2} # Séparateur
.{2} # deux caractères
[\x00]{11} # Séparateur
(\x00|\x01) # Base (0x01) ou non (0x00)
(.*[^\x00]) # tous les caractères, terminés par un caractère non 0x00 : données brutes
#(sans le caractère 0xFF de fin)
[\x00]{2} # fin de l'enregistrement
''', re.VERBOSE)
# extraire les données du fichier
data_list = data_pattern.findall(g1r_file.read())
g1r_file.close()
for record in data_list:
# record = ('DATA TYPE', 'FILE NAME', 'BASE', 'RAW DATA')
data_type = record[0]
data_name = record[1]
if record[2] == '\x01':
use_base = True
else:
use_base = False
raw_data = record[3] + '\x0d\xff' #ajout des caractères de fin pour les données brutes
Le format Fx-Interface (fxi)
Le format fxi est un format binaire, utilisé par le logiciel Fx-Interface. Ce dernier logiciel est celui vendu en France avec les calculatrices graphiques proposant un câble série pour ordinateur, aussi le format fxi est le format le plus courant sur les sites internet francophones. La lecture de ce format se fait en deux temps (du fait de sa complexité, je ne me suis pas intéressé à son écriture).
Il faut tout d'abord convertir chaque octet du fichier binaire par son équivalent dans le format brut. Un tutoriel d'Alexis Soulard, le format FXI
, explique l'algorithme tordu pour construire un tableau d'équivalence (merci milles fois à lui). Le voici en python :
#Build the raw2fxi dic
#Thanks to http://www.casioland.net/tutoriaux.php?idTuto=3&noHeader=1
r2f = {}
dep, a, i, j = 23, 255, 0, 0
v = dep
while a >= 0 :
v = v + 1
r2f[a] = v
a -= 1
i += 1
if i == 8 :
dep -= 8
j += 1
i = 0
v = dep
if j == 4 :
j = 0
dep += 8 * 8
v = dep
#Build the fxi2raw dic
f2r = {}
for a, f in r2f.items():
f2r[f] = a
Ensuite, pour convertir le fichier fxi, il suffit d'utiliser la fonction suivante :
def fxiDecode(fxiData):
""" Convert fxi-like data to raw data """
out = ''
for c in range(len(fxiData)) :
out += chr(f2r[ord(fxiData[c])])
#Fix the 'or' bug (some 'or' strings was replaced by a 0xAA string ##v0.1.2
out = out.replace(chr(0xAA),'or')
return out
Mais comme le format cat, le format fxi peut contenir plusieurs enregistrement de données, ainsi que des informations sur ceux-ci. Et là commence la galère ;-). Voici la structure générale d'un fichier fxi converti à l'aide de l'algorithme précédent (les retours à la ligne n'existent pas, et ne sont qu'une question de présentation, un point d'interrogation représente un caractère non ASCII, une astérisque plusieurs caractères non ASCII ) :
* (L'en tête du fichier : beaucoup de caractères, je ne sait pas trop ce que ça représente)
TXT?PG (probablement l'équivalent des informations du format cat - ici commence l'enregistrement)
????
MyPrgm (le nom du programme)
[16 + 8 - longueur(nom du programme)] * FF (donc entre 24 et 16 caractères 255)
NL (pour un programme normal, BN pour un programme utilisant des calculs sur les bases)
12 * FF
Programme, au format brut
FF (ici se termine l'enregistrement)
* (la séquence dépend ensuite si l'enregistrement est suivi d'un autre ou pas)
La manière la plus simple de récupérer les enregistrements contenus dans un fichier fxi consiste à utiliser une expression rationnelle (ici codé en python avec le module re, utilisant la fonction précédente) :
fxi_file = open(filename, 'r')
# Get the raw data
ctn = fxi_decode(fxi_file.read())
fxi_file.close()
# Make the regular expression
data_pattern = re.compile('''
(TXT) # data format (but fxi txt is not really text :-/)
. # separator
(PG) # type of data
.{4} # 4 characters
([^\xff]{1,8}) # data name
\xff{16,23} # between 16 and 23 (16+8-len(data name)) 0xFF
(NL|BN) # Option1 (Normal or Base)
\xff{12} # 12 0xFF
([^\xff]+\xff) # any non 0xFF characters ended by one 0xFF : raw data
''', re.VERBOSE)
# Extract records from raw data using the regular expression
data_list = data_pattern.findall(ctn)
for record in data_list:
format, data_type, name, optn, data = record
# Vous pouvez utiliser data_type pour déterminer le type de votre enregistrement,
# name pour obtenir son nom, optn == "BN" vous indiquera si ce programme utilise des bases,
# et data contiendra les données brutes du programme.
Le format cafix
Le format cafix est le format des fichiers obtenus avec le logiciel Cafix, un utilitaire en ligne de commande pour transférer des données sous Linux. Le projet semble arrêté depuis quelques années déjà, mais il a le remarquable mérite d'être l'unique outil du genre sous Linux, et de fonctionner (en tout cas avec ma casio 65 et mon câble pour FX-Interface en port COM, ce ne doit pas être le cas avec les nouveaux câbles USB).
Cafix stocke les programmes directement sous leur forme brute, sans stockage de métadonnées ou de possibilité d'enregistrement multiple (ce format ne fait pas de différence entre les programmes normaux et ceux effectuants des calculs sur les bases). Le nom du programme est stocké dans le nom du fichier, de la sorte prog-MyPrgm.cafix. Le fichier peut cependant être renommé sans problème, lors de l'ouverture d'un fichier, Cafix considère que tout le nom du fichier, à l'exclusion de l'extension, est le nom du programme. Aussi MyPrgm
devient prog-MyP
(à cause de la troncature à 8 caractères). Comportement un peu illogique, mais ça fonctionne et c'est simple.
Pour les backups, cafix utilise le préfixe backup-. Ici aussi, les données sont enregistrées directement sous leur forme brute.
Le format Fx-Interface Backup (fxb)
Le logiciel Fx-Interface stocke les sauvegardes (backups) dans des fichiers différents des autres données (format FXI). Ces fichiers portent l'extension .fxb, et sont composés de la façon suivante (même notation que pour la description des fichiers FXI) :
?*278 (l'en tête 1 du fichier, contenant probablement des informations sur la calculatrice)
10*FF (premier séparateur)
GY358 (en-tête 2, toujours le même avec mes backups de casio 65. Est-ce le modèle de calculatrice ?)
2 * FF
?*6
9*FF (second séparateur)
Données brutes
Vous pouvez voir un exemple d'en-tête (tout ce qu'il y a avant les données brutes) vu sous forme héxadécimale.
Le format Fx-Interface Pro Backup (fxb)
Le logiciel Fx-Interface Pro (à ne pas confondre avec Fx-Interface) possède un format de sauvegarde (backup) différent de la version non-pro
. Les données brutes du backup sont stockées dans le fichier sans qu'une quelconque convertion soit nécessaire, mais à l'intérieur d'autres données utilisée par Fx-Interface Pro. Les données brutes sont stockées de l'offset 0000:107A (4218) à l'offset 0001:0879 (67 705), les deux inclus.
Voici un algorithme en python pour extraire les données brutes :
fxm_file = open('backup.fxm','rb')
ctn = fxm_file.read(67706)
fxm_file.close()
bak = ctn[4218:]
raw_file = open('backup.cafix','w')
raw_file.write(bak)
raw_file.close()
Le format Fx-Interface Pro (fxd)
Le logiciel Fx-Interface Pro (à ne pas confondre avec Fx-Interface) possède un format de fichier différent de la version non-pro
. Les données brutes sont stockées dans le fichier sans qu'une quelconque convertion soit nécessaire, (contrairement au format fxi), mais à l'intérieur d'une grande quantité (pouvant aller jusqu'à plus de la moitiée du fichier) d'autres données utilisée par Fx-Interface Pro.
Les données brutes (pour l'instant uniquement les programes) peuvent être extraites à l'aide d'une expression rationnelle, en voici un exemple codé en python :
import re
data_pattern = re.compile('''
(PG) # type of data
.{4} # 4 characters
([^\xff]{1,8}) # data name
\xff{16,23} # between 16 and 23 (16+8-len(data name)) 0xFF
(NL|BN) # Option1 (NL=normal, BN=base)
\xff{13} # 13 0xFF
.{8} # 8 characters
([^\xff]+\xff) # any non 0xFF characters ended by one 0xFF : raw data
''', re.VERBOSE)
fxd_file = open(fxd_filename, 'rb')
out_ctn = data_pattern.findall(fxd_file.read())
# out_ctn contient une liste d'enregistrement de donnée.
# Chaque enregistrement à la structure suivante :
# ("DATA TYPE", "FILE NAME", "OPTION", "RAW DATA")
# DATA TYPE est toujours égal à "PG" (programme) pour l'instant
# FILE NAME est le nom du fichier
# OPTION indique si le programme est normal ou utilise des calculs de base
# RAW DATA est le contenu du programme, sous forme de donnée brute.
# Vous pouvez récupérer ces données à l'aide de ce code :
for record in out_ctn:
data_type, file_name, option, raw_data = record
#vous pouvez maintenant exploiter data_type, file_name option et raw_data
Conclusion : le format newcat
À l'aide des diverses méthodes expliquées ci-desus, il est possible de créer un programme permettant de convertir les différents formats entre eux (en utilisant le format brut comme pivot). Autant cela résoud le problème de l'échange de fichier, autant la question des formats ouverts (aucune des spécifications des formats ci-dessus n'est ouverte) et celle d'un format permettant une édition facile reste en suspend.
C'est pourquoi j'ai décidé de créer un format de fichier répondant à ces deux caractéristiques. Fortement inspiré du format cat, j'ai nommé ce format le newcat
. Les principales différences sont : une spécification claire (voir plus bas), des retours à la ligne en CR (0D - 13) pour une compatibilité avec les éditeurs de textes unix, et de nouveaux équivalents par rapport au format cat, afin de remplacer tous les caractères spéciaux.
De plus, pour combler les lacunes de Cafix, j'ai créé deux logiciels qui s'appuyent sur ce dernier pour la gestion de la calculatrice, mais qui ajoutent en plus le support (complet ou partiel) des formats fxi, cat, newcat et cafix. Le premier de ces deux logiciels est Casetta, il propose un utilitaire en ligne de commande pour réaliser les opérations décrites, ainsi qu'un module python pour réaliser toutes les convertions. Le second est Casetta-gtk, une interface graphique pour Casetta, qui propos un éditeur de programems.
Historique de ce document
- 26 juin 2006 : version initiale
- 1 août 2006 : étude sur les backups pour le format cafix, ajout du format fxb
- 2 août 2006 : ajout du format fxm
- 4 août 2006 : ajout du format fxd
- 6 août 2006 : ajout du format g1r
- 9, 10 septembre 2006 : ajout des données sur les programmes utilisant des calculs de bases
- 16 septembre 2006 : ajout d'informations sur le Calculator Text Format
- 30 septembre 2006 : ajout du support des bases dans l'expression rationnelles du format g1r
Derniers commentaires