PrizmSDK : Différence entre versions

Version du 3 août 2014 à 00:17

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

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-2.24/configure --target=sh4aeb-nofpu-elf --disable-nls --with-sysroot --program-prefix=prizm-

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-2.24 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-4.9.1/configure --target=sh4aeb-nofpu-elf --program-prefix=prizm- --with-sysroot=/usr/local/fxcg --with-native-system-header-dir=/include --without-headers --enable-languages=c,c++ --disable-tls --disable-nls --disable-threads --disable-shared --disable-libssp --disable-libvtv --disable-libada --with-endian=big --with-multilib-list=

Lancez ensuite la compilation avec :

 $ sudo make -j inhibit_libc=true 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 inhibit_libc=true all-gcc   rm -rf build-gcc gcc-4.9.1

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 inhibit_libc=true 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-4.9.1 

Compilation de LibFxCG

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

Ainsi, toujours dans /usr/src, il faut cloner le dépot git de LibFxCG

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

Puis, il faut préparer les dossiers dans lesquels les headers seront installés sur le système :

 $ sudo mkdir -p /usr/local/fxcg/include/sys
 $ sudo mkdir -p /usr/local/fxcg/include/fxcg

Puis installer les headers à partir du dépôt téléchargé :

 $ sudo install -t /usr/local/fxcg/include include/*.h
 $ sudo install -t /usr/local/fxcg/include/fxcg include/fxcg/*.h
 $ sudo install -t /usr/local/fxcg/include/sys include/sys/*.h

L'étape suivante est la compilation de LibFxCG :

 $ make

Puis la création du dossier dans lequel seront installées les librairies compilées précédemment, et l'installation elle même :

 $ sudo mkdir -p /usr/local/fxcg/lib
 $ sudo install -t /usr/local/fxcg/lib lib/libc.a lib/libfxcg.a
 $ sudo install -t /usr/local/fxcg toolchain/prizm.x

//Section à finir

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.

//Section à finir

Notes et références