PrizmSDK : Différence entre versions

Version actuelle datée du 8 décembre 2020 à 18:33

La Prizm n'est pas (et ne sera pas^[1]) accompagnée d'un SDK officiel fournit par Casio. Face à ses faibles performances en Basic, un SDK communautaire a été réalisé, fournissant un environnement de développement en C/C++ basé sur GCC. Il est actuellement en version 0.3 et est utilisable tant sur Windows que sur la plupart des distributions Linux.

Mise en Place du SDK

Sur Windows

Le PrizmSDK v0.3 est actuellement disponible sur le site de la communauté anglophone Cemetech à cette adresse. Téléchargez simplement l'archive au format que vous souhaitez, sachant que le zip est le plus simple à manipuler et le plus commun.

Le SDK est conçu pour être utilisable rapidement sous Windows. En effet, une fois l'archive évoquée plus haut téléchargée, dézippez la quelque part sur votre disque. Il est conseillé de placer ce répertoire à la racine de votre disque dur, ou à tout autre endroit dont le chemin est sans parenthèses ou espaces.

Par exemple :

C:\PrizmSDK-0.3 est valide.
D:\Prizm_dev\Prizm\PrizmSDK-0.3 est également valide.
C:\Program Files(x86)\PrizmSDK-0.3 posera des problèmes.

Vous pouvez vérifier que tout fonctionne une fois votre dossier extrait en allant exécuter le make.bat présent dans le dossier suivant :

PrizmSDK-0.3\projects\example

Si tout se passe bien, vous devriez assister à la compilation du projet "par défaut" du SDK, dont les étapes sont retranscrites dans une invite de commande. Un fichier example.g3a devrait aussi être crée une fois la compilation achevée. Ça y est, vous êtes prêts à développer pour votre calculatrice couleur !

Sur Linux

ATTENTION : La procédure est encore incomplète, cependant les premières étapes décrites ci dessous sont à l'heure actuelle fonctionnelles.

La mise en place sur Linux du SDK n'est pas aussi simple et rapide que sur Windows (mais bon, vous êtes sur Linux, vous vous y attendiez et ça ne vous fait pas peur hein !).

La procédure ci dessous permet d'obtenir l'environnement le plus "récent" à l'heure actuelle, elle est basée sur le travail de Tari.

Ainsi, il faudra compiler une version de GCC permettant de créer des programmes compréhensibles par le processeur de la calculatrice.

Préparation de la compilation

Il faut d'abord s'assurer que les dépendances soient installées sur l'ordinateur : build-essential libmpfr-dev libmpc-dev libgmp-dev libpng-dev ppl-dev curl git cmake Pour vérifier leur présence, et les installer si ils ne sont effectivement pas installés, lancez dans un terminal :

$ sudo apt-get -y install build-essential libmpfr-dev libmpc-dev libgmp-dev libpng-dev ppl-dev curl git cmake

Il va ensuite falloir récupérer les sources des Binutils et de GCC, en prenant en compte la compatibilité entre les deux. A ce jour le couple le plus à jour et testé est Binutils 2.24 et GCC 4.9.1. Néanmoins, si pour diverses raisons il était nécessaire d'utiliser d'autres versions, elles sont trouvables ici pour Binutils et là pour GCC.

Il faut ensuite préparer la compilation. Celle ci s'effectuera dans /usr/src. Afin d'attribuer les privilèges nécessaires au dossier cible et de créer les répertoires temporaires utilisés pendant la compilation, il convient d’exécuter la suite de commandes suivante :

 $ cd /usr
 $ su
 # chmod a+rw src
 # exit
 $ cd src
 $ mkdir binutils gcc build-binutils build-gcc

Il faut ensuite décompresser les deux archives téléchargées précédemment dans leur dossier respectif (le contenu de l'archive binutils-x.y va dans le dossier binutils et le contenu de gcc-x.y.z dans gcc).

Compilation de Binutils

Avant de compiler binutils, il faut procéder à la configuration de ce qui va être compilé. Pour se faire, rendez vous dans le dossier build-binutils

 $ cd build-binutils

Et exécutez la commande suivante :

 $ ../binutils/./configure --target=sh3eb-elf --prefix=/usr/local/prizm --program-prefix=prizm- --disable-nls

Lancez ensuite la compilation en effectuant :

 $ sudo make -j

Puis l'installation grâce à :

 $ sudo make install

Si il n'y a pas eu d'erreur explicite du compilateur, c'est que tout est censé avoir fonctionné, il est alors possible de supprimer les dossiers temporaires :

 $ cd ..
 $ sudo rm -rf binutils build-binutils

Compilation de GCC

De la même manière que pour binutils, il faut d'abord configurer la future compilation de GCC; pour se faire rendez vous dans le dossier build-gcc

 $ cd build-gcc

Puis exécutez la commande suivante :

 $ ../gcc/./configure --target=sh3eb-elf --prefix=/usr/local/prizm --program-prefix=prizm- --disable-nls --enable-languages=c,c++ --without-headers

Lancez ensuite la compilation avec :

 $ sudo make -j all-gcc

Notez que la compilation est relativement longue; si vous disposez d'un processeur multicœur, il est possible de spécifier l'option jn où n représente le nombre de cœurs de votre processeur, réduisant de manière notable le temps de compilation. Pour un processeur quadricœur on aurait donc :

 $ sudo make -j4 all-gcc

L'installation se lance ensuite comme précédemment :

 $ sudo make install

Il faut ensuite lancer la compilation de libgcc, de la manière suivante (là encore il est possible de modifier l'option -j en fonction de votre processeur) :

 $ sudo make -j all-target-libgcc

Puis l'installation de libgcc :

 $ sudo make install-target-libgcc

Si tout s'est déroulé comme prévu (pas d'erreurs à quelque moment que ce soit du processus), il est possible de supprimer les dossiers et fichiers temporaires :

 $ sudo rm -rf build-gcc gcc 

Installation de Mkg3a

Mkg3a est un programme permettant de "wrapper" les binaires obtenus lors d'une compilation avec GCC en fichiers .g3a exécutables par la calculatrice.

Afin de l'installer, il est d'abord de nécessaire de récupérer les sources (on utilisera ici la version [0.2a 0.2a]). Une fois ceci fait, décompressez l'archive obtenue (l'emplacement importe peu), puis placez vous dans le répertoire extrait.

 $ cd 'répertoire contenant l'archive extraite'

Lancez ensuite les commandes suivantes, à l’intérieur du dossier contenant les sources :

 $ cmake .
 $ make
 $ su -c 'make install'

Normalement mkg3a est maintenant installé et utilisable.

Compilation de LibFxCG

Le compilateur étant normalement opérationnel, il va ensuite falloir compiler les librairies et headers permettant de développer à destination de la calculatrice.

Ainsi, il faut tout d'abord faut cloner le dépot git de LibFxCG, l'emplacement encore une fois importe peu.

 $ git clone https://github.com/Jonimoose/libfxcg.git
 $ cd libfxcg

L'étape suivante est la compilation de LibFxCG :

 $ make

Les bibliothèques (libc.a et libfxcg.a) sont maintenant compilées dans le dossier lib, et les headers sont disponibles dans le dossier include de votre copie locale de libfxcg.

Mise en place de l'espace de travail

// En cours d'écriture

Structure du SDK (pour Windows)

include

Contient les en-tête de fonctions utilisés pour programmer les add-ins

project

Contient les différents projets d'add-ins. Chaque dossier-projet suit cette structure:

• src : contient le code source de l'add-in (*.c/*.h)
• unselected.bmp : icone de l'add-in dans le menu lorsque non sélectionné
• selected.bmp : icone de l'add-in lorsque sélectionné
• clean.bat : nettoie le projet
• make.bat : construit le projet et génère le *.g3a à transférer dans la calculatrice
• les autres sont moins importants

Notes et références