https://wiki.planet-casio.com/fr/api.php?action=feedcontributions&feedformat=atom&user=CartixCasio Universal Wiki - Contributions de l’utilisateur [fr]2026-04-28T17:57:05ZContributions de l’utilisateurMediaWiki 1.28.2https://wiki.planet-casio.com/fr/index.php?title=PV-Lib&diff=1043PV-Lib2014-05-21T14:16:30Z<p>Cartix : </p>
<hr />
<div>{{MsgBox|title=Page En construction|text=Cette page est encore en construction. Tout apport d'information est le bienvenu.|theme=orange}}<br />
La libraire PV-Lib est un ensemble de fonction permettant d'utiliser des syscalls du Casio Pocket Viewer.<br />
En effet, le Classpad étant basé sur cet ancien modèle d'agenda électronique, toute les fonctions (ou presque) disponible pour le SDK du PV le sont également pour le CPSDK.<br />
<br />
Ceci implique qu'il est facile de ré-écrire un programme PV pour CP. C'est grâce à cela que Vanhoa a pu porter autant de programme vers le Classpad (IEdit, OWBasic, ...)<br />
<br />
Plus d'informations viendront par la suite</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=PV-Lib&diff=1042PV-Lib2014-05-21T14:15:12Z<p>Cartix : </p>
<hr />
<div>La libraire PV-Lib est un ensemble de fonction permettant d'utiliser des syscalls du Casio Pocket Viewer.<br />
En effet, le Classpad étant basé sur cet ancien modèle d'agenda électronique, toute les fonctions (ou presque) disponible pour le SDK du PV le sont également pour le CPSDK.<br />
<br />
Ceci implique qu'il est facile de ré-écrire un programme PV pour CP. C'est grâce à cela que Vanhoa a pu porter autant de programme vers le Classpad (IEdit, OWBasic, ...)<br />
<br />
Plus d'informations viendront par la suite</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=PV-Lib&diff=1041PV-Lib2014-05-21T14:14:53Z<p>Cartix : Page créée avec « La libraire PV-Lib est un ensemble de fonction permettant d'utiliser des syscalls du Casio Pocket Viewer. En effet, le Classpad étant basé sur cet ancien modèle d'agend... »</p>
<hr />
<div>La libraire PV-Lib est un ensemble de fonction permettant d'utiliser des syscalls du Casio Pocket Viewer.<br />
En effet, le Classpad étant basé sur cet ancien modèle d'agenda électronique, toute les fonctions (ou presque) disponible pour le SDK du PV le sont également pour le CPSDK.<br />
Ceci implique qu'il est facile de ré-écrire un programme PV pour CP. C'est grâce à cela que Vanhoa a pu porter autant de programme vers le Classpad (IEdit, OWBasic, ...)<br />
Plus d'informations viendront par la suite</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Accueil&diff=1027Accueil2014-05-20T14:00:10Z<p>Cartix : </p>
<hr />
<div>{{MsgBox |title=Bienvenue sur Casio Universal Wiki !|text=Retourner vers [http://planet-casio.com/Fr planete-casio.com] ?}}<br />
<br />
<br/>[[Comment écrire un article pour Casio Universal Wiki?]]<br/><br />
<br />
Les inscriptions sont fermés suite à de nombreux messages quotidiens de robots nous ventant les mérites de divers produits. Désolé, si vous souhaitez vous inscrire, veuillez envoyer un message privé à Ziqumu sur [http://www.planet-casio.com/Fr/ Planet-casio] (inscription requise) ou à Helder7 (en anglais) sur [http://casiopeia.net/ Casiopeia.net] (inscription requise)<br />
<br />
<br/><br />
<table id="homePageTable"><!--for edit style of the table, edit http://wiki.casio-scene.com/en/MediaWiki:Common.css--><br />
<tr id="homePageTableTop"><br />
<th width="1%" rowspan="2" style="border-radius: 10px 0 0 0;border-left: 1px solid #a7d7f9 !important;">[[File:Text-Catégories.png|link=:Catégorie:Catégories des calculatrices]]</th><br />
<th width="19%">[[:Catégorie:Calculatrices Basic|Basic]]</th><br />
<th width="20%">[[:Catégorie:Graph 100|Graph 100]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Classpad|Classpad]]</th><br />
<th width="20%">[[:Catégorie:Graph 75/85/95|Graph 75/85/95]]</th><br />
<th width="20%" style="border-radius: 0 10px 0 0;">[[:Catégorie:Calculatrices Prizm|Prizm]]</th><br />
</tr><br />
<tr><br />
<td><center>[[Fichier:Graph 25+ pro-h100.jpg]][[Fichier:GRAPH_35+_USB-h100.jpg|link=Graph 35+ USB]]</center></td><br />
<td><center>[[Fichier:Casio afx series-2.0-en.jpg]]</center></td><br />
<td><center>[[Fichier:Cp.png|link=File:Cp.png]]</center></td><br />
<td><center>[[Fichier:Graph 75-h100.jpg]]</center></td><br />
<td><center>[[Fichier:Fx-CgXX-h100.jpg]]</center></td><br />
</tr><br />
<tr><br />
<th>[[File:text-Modèles.png|link=Catégorie:Calculatrices_Casio|Voir toutes les calculatrices]]</th><br />
<td><br />
<ul><br />
<li>Graph 25+ PRO</li><br />
<li>[[Graph 35|Graph 35+]]</li><br />
<li>[[Graph 35+ USB]]</li><br />
<li>Graph 65</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 100</li><br />
<li>Graph 100+</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Classpad 300</li><br />
<li>Classpad 300+</li><br />
<li>Classpad 330</li><br />
<li>Classpad 330+</li><br />
<li>Classpad 400</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 75</li><br />
<li>Graph 95 SD</li><br />
<li>[[:Category:Graph 75/85/95|Voir plus...]]</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Fx-CG 10</li><br />
<li>[[Fx-CG 20]]</li><br />
</ul><br />
</td> <br />
</tr><br />
<tr><br />
<th></th><br />
<td>''[[Transferts]]''</td><br />
<td>''[[Transfert avec Graph 100]]''</td><br />
<td>''[[Transfert avec Classpad]]''</td><br />
<td><ul><br />
<li>[[Transferts|Transfert avec Graph 75/85/95]]</li><br />
<li>[[Processeurs SH3 et SH4|Compatibilité des add-in]]</li><br />
</ul></td><br />
<td>''[[Transfert avec Prizm]]''</td><br />
</tr><br />
<tr><br />
<th>[[File:text-Basic_Casio.png|link=Basic_Casio]]</th><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>Quelques différences</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td><br />
<ul><br />
<li>[[Basic_Casio|Basic Casio]]</li><br />
<li>[[Basic_Fx-CG|Spécificités du Basic pour Fx-CG 10/20]]</li><br />
</ul><br />
</td><br />
</tr><br />
<tr><br />
<th>[[File:text-C_ASM.png|link=Langage C]]</th><br />
<td>Non</td><br />
<td>Oui</td><br />
<td><br />
<ul><br />
<li>[[CPSDK]]</li><br />
<li>[[GaumerieLib]]</li><br />
<li>[[PV-Lib]]</li><br />
</ul><br />
</td><br />
<td><ul><br />
<li>[[SDK]]</li><br />
<li>[[Syscall]]</li><br />
<li>[[Fxlib.h]]</li><br />
</ul></td><br />
<td><ul><br />
<li>[[miniSDK]] (désuet)</li><br />
<li>[[PrizmSDK]]</li><br />
<li>[[Syscall]]</li><br />
</ul></td><br />
</tr><br />
<tr><br />
<th style="border-radius: 0 0 0 10px;">[[File:Text-Dev. Alternatif.png|link=Développement Alternatif]]</th><br />
<td>Non</td><br />
<td><ul><li>[[Lua Fx|Lua]]</li></ul></td><br />
<td><ul><li>[[CPLua]]</li><li>CPBF</li></ul></td><br />
<td><ul><li>[[Lua Fx|Lua]]</li><li>BF</li><li>Malical</li><li>PRGM2</li><li>C (WSC+FVM)</li></ul></td><br />
<td style="border-radius: 0 0 10px 0;">LuaZM<br />PRGM2 color est en cours</td><br />
</tr><br />
<tr><br />
<th style="border-radius: 0 0 0 10px;">[[File:Text-fichiers-supportés.png]]</th><br />
<td><ul><br />
<li>[[.cat]]</li><br />
<li>[[Fichiers lus par les calculatrices|.fxi]]</li><br />
<li>[[.fxd]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g1r]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g2r]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g1m]]</li><br />
</ul></td><br />
<td><ul><br />
<li>[[.cat]]</li><br />
<li>[[Fichiers lus par les calculatrices|.fxi]]</li><br />
<li>[[.fxd]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g1r]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g2r]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g1m]]</li><br />
<li>[[.cfx]]</li><br />
<li>.exe</li><br />
<li>[[.cdr]]</li><br />
<li>[[.lec]]</li><br />
<li>[[Fichiers lus par les calculatrices|.bmp]]</li></ul></td><br />
<td><ul><br />
<li>.vcp</li><br />
<li>.xcp</li><br />
<li>.fls</li><br />
<li>.mcs</li><br />
<li>.lng</li><br />
<li>[[.cpa]]</li><br />
<li>[[.c1a]]</li><br />
</ul></td><br />
<td><ul><br />
<li>[[Fichiers lus par les calculatrices|.g1e]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g2e]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g1a]]</li><br />
<li>.g1l</li><br />
<li>[[Fichiers lus par les calculatrices|.g1m]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g2m]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g1r]]</li><br />
<li>.g1n</li><br />
<li>[[.g1k]] (seulement dans l'émulateur)</li><br />
<li>[[Fichiers lus par les calculatrices|.bmp]] (par add-in)</li><br />
</ul></td><br />
<td style="border-radius: 0 0 10px 0;"><ul><br />
<li>[[Fichiers lus par les calculatrices|.g1m]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g2m]]</li><br />
<li>.g3m</li><br />
<li>[[Fichiers lus par les calculatrices|.g1e]]</li><br />
<li>[[Fichiers lus par les calculatrices|.g2e]]</li><br />
<li>.g3e</li><br />
<li>.g3l</li><br />
<li>.g3a</li><br />
<li>.g3p</li><br />
<li>.g3b</li><br />
<li>[[.g3k]] (seulement dans l'émulateur)</li><br />
<li>[[Fichiers lus par les calculatrices|.bmp]] (seulement en écriture)</li><br />
</ul></td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
<center>[[Correspondance des numéros de modèle|Correspondance des numéros de modèle Français/International]]<br/>[[Index des calculatrices Casio]]</center><br />
[[en:Main_Page]]<br />
[[Catégorie:Pages en cours d'écriture]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Lua_Fx&diff=1024Lua Fx2014-05-20T09:24:51Z<p>Cartix : </p>
<hr />
<div>{{InfoBox Software<br />
| nom=Lua FX<br />
|logo=Lua.gif<br />
| Auteur=<br />
Luiz Henrique de Figueiredo, Roberto Ierusalimschy et Waldemar Celes<br />
<br />
| développeur=Vebveb, Louloux<br />
| SouventMàJ=non<br />
<br />
| langage=Anglais<br />
| langage de programmation=[[BASIC]], [[C (langage)|C]], [[C++]]<br />
<br />
}}<br />
Le LuaFX est un langage de programmation à mi-chemin entre le Basic et le C et offre de bonnes performances, supérieures au Basic et au MLC ! Les programmes se présentent sous forme d'add-ins à transférer sur la calculatrice Casio.<br />
<br />
<br />
<br />
Le LuaFX est compatible avec les Graph 75/85/95 (SD) et 100(+) grâce à un formidable travail de Vebveb et de la communauté Casio.<br />
<br />
On précompile les .lua sur pc en .lc et on les transfère sur g100 pour les executer.<br />
Sur g85 (et autres calculatrices de la même famille), le basic et le C sont bien plus performants que sur g100, mais le lua reste un langage attractif par ses possibilités, sa simplicité et sa rapidité.<br />
La taille maximale d'un .lc est plus faible que sur g100 pour la g85. En revanche, on peut exécuter des .lua on-calc (mais la taille maximale est plus faible et il peut y avoir des problèmes de compilations: préférez compiler sur pc).<br />
La vitesse du lua sur g85 a été harmonisée partiellement avec celle du lua pour g100 afin que les programmes soient compatibles.<br />
Ce document vise à vous donner les bases de la programmation du lua sur g100.<br />
La partie langage lua en lui même peut être complété par les nombreuses documentations anglaises. (par exemple on peut aussi déclarer une variable 2::=x au lieu de x=2)<br />
Le lua est un des langages interprétés les plus rapides. Il fonctionne en deux étapes: d'abord le programme .lua est lu et est précompilé en .lc, puis il est exécuté via le programme précompilé.<br />
<br />
==Le lua ==<br />
<br />
===Les variables===<br />
<br />
Il y a différents types de variable.<br />
Une variable peut contenir des majuscules, des minuscules ou des chiffres (à condition que le nom ne commence pas par un chiffre)<br />
exemples: B R55 nom Nom Rnom2 sont des variables différentes.<br />
<br />
Les différents type sont nil, nombre, table, string, userdata et fonction<br />
– nil: la variable est vide. Si on ne lui donne aucune valeur, elle reste à nil. Une variable ayant pour valeur nil est supprimée de la mémoire par le 'garbagecollector' du lua.<br />
– Nombre: la variable contient un nombre de définition 'float' (c'est à dire que le nombre correspond aux nombres float en C) : le nombre peut aller de -3.4*e-38 à 3.4*e38<br />
Exemple: nb= 4.7e9 ou nb = 534<br />
– table: la variable est une table (= équivalent liste ou matrice)<br />
exemple: C= {} --on initialise la table<br />
C[40]=5 –on met 5 dans la 40e case.<br />
Une table peut contenir des nombre, des strings, voir des fonctions.<br />
– String: la variable contient un mot ou une phrase. (='chaine de caractères')<br />
Un string prend très peu de place.<br />
un sprite est contenu dans un string pour prendre moins de place.<br />
– Booléen: la variable contient true ou false.<br />
A= (1==2) --A contient false<br />
A= ((y+x)<w) --A contient true ou false<br />
A noter que nil et false ont la même table de vérité, (if nil then ... sera équivalent à if false then ..)<br />
alors que les autres types et true ont même table de vérité (if nombre then .. pareil que if true)<br />
– Userdata: Réservé aux fichiers (voir librairie file)<br />
– Fonction: la variable réfère à une fonction de la librairie ou une fonction lua<br />
exemple: (ce qui suit '--' est un commentaire et ne fait pas partie du code)<br />
<br />
line=nbdraw.line -- la fonction ligne réfère à la fonction nbdraw.line<br />
function rectangle(x1,y1,x2,y2) --rectangle est une fonction lua de 4 paramètres<br />
line(x1,y1,x1,y2) --dessine le rectangle<br />
line(x2,y1,x2,y2)<br />
line(x1,y1,x2,y1)<br />
line(x1,y2,x2,y2)<br />
end -- on signale la fin de la fonction<br />
<br />
rectangle(10,10,20,20) --on l'appelle dans la boucle principale<br />
<br />
Remarque: placer local devant un variable permet d’accélérer son appel et donc la vitesse du programme. Si la variable locale est déclarée dans une fonction, elle lui est spécifique. Une variable non locale est une variable globale. Exemple:<br />
<br />
local resultat -- la variable est équivalente à une globale mais en plus rapide<br />
y=2 -- y est une globale<br />
function calcul(entree) --entree est automatiquement locale à la fonction<br />
local x --x est locale à la fonction<br />
x=(2/entree)<br />
return y+x<br />
end<br />
<br />
resultat=calcul(y)<br />
x=resultat+2 -- x est different de x dans la fonction calcul. Ici x est globale.<br />
<br />
Pour apprendre plus en profondeur le lua, je vous conseille ce site:<br />
http://lua.gts-stolberg.de/fr/index.php<br />
<br />
Les différentes opérations possibles sur les nombres sont:<br />
a = a + b<br />
a= a – b<br />
a= -a -- on prend l'opposé de a<br />
a= a%b (modulo; c'est à dire que a contient le reste de la division euclidienne de a par b)<br />
a = a * b (multiplication)<br />
a = a / b<br />
a = a^b (puissance. Ne marche qu'avec b entier. Si vous utilisez un b à virgule, utilisez pow(a,b) de math.lua)<br />
On peut utiliser les parenthèses.<br />
<br />
Pour connaître le nombres de caractères dans une string ou dans une table ainsi:<br />
<br />
phrase = "coucou," -- le nom de la variable import peu<br />
suite = "je m'appelle veb"<br />
longueur = #phrase -- contient le nombre de lettres. Ici 7.<br />
phase = phrase .. suite -- on ajoute suite à phrase<br />
-- phrase contient "coucou,je m'appelle veb"<br />
longueur = #phrase -- contient la nouvelle longeur de la string<br />
<br />
Si on veut que cela contienne "coucou, je m'appelle veb" (on rajoute un espace après , ),<br />
on fait:<br />
<br />
phrase = phrase .. " " .. suite<br />
<br />
on peut aussi connaitre la longueur d'une table:<br />
<br />
table = {} --on initialise la table<br />
table [1] = {1,2,3} -- on crée une 2 e dimension (matrice) dans cette case<br />
-- #table contient 1 mais #table[1] contient 3<br />
<br />
<br />
Le paragraphe suivant n'est pas obligatoire, mais il peut permettre de mieux comprendre quelques imprécisions, ou légères erreurs.<br />
<br />
===les nombres plus en détail===<br />
<br />
Les float:<br />
Le Lua utilise le système des nombres flottants de précision simple tenant sur 4 octets (float).<br />
La précision est assez élévé et les calculs rapides, mais on est moins précis que pour le système utilisé par casio par exemple.<br />
Tout les entiers de 0 à 16777215 (et leurs négatifes associés) sont précis à 100%<br />
Au delà les nombres seront arrondis à l'entier pair, puis tout les 4, ....<br />
Pour les nombres non entiers, la précision est en fait une sorte d'arrondi:<br />
<br />
Par exemple le codage précis de 3,3 est impossible : si vous rentrez x = 3.3, en réalité x contiendra 3.2999999523162841796875 mais x == 3.3 renverra vrai.<br />
Lors de l'affichage de x, nbdraw.print affichera 3,3 car la précision d'affichage est de 6 par défaut (c'est à dire que l'arrondi se fait pour que le nombre tienne dans 6 chiffres et l'on enlève les 0)<br />
Si vous augmentez la précision d'affichage vous pourrez voir l'imprécision.<br />
<br />
Si vous voulez par exemple mettre 2*pi dans une variable, pour ne pas cumuler les erreurs il vaut donc mieux rentrer manuellement 2pi plutôt que de le calculer.<br />
<br />
<br />
==Les librairies lua sur g100/85 (les fonctions intégrées)==<br />
<br />
===Les fonctions générales===<br />
<br />
====Les fonctions non-graphiques existant dans l’édition standard du lua====<br />
<br />
Il se peut que vous n'utilisiez jamais ces fonctions, Néanmoins sachez qu'elles existent.<br />
<br />
--base.collectgarbage(option [,argument])<br />
Option peut prendre un de ces mots:<br />
-"stop": arrête la collecte des valeurs inutilisées.<br />
-"restart": recommence la collecte.<br />
-"collect": Fait une collecte complète (à utiliser pour libérer de la mémoire)<br />
Cette fonction libère de la place pour l’exécution du programme. Attention, la place libérée n'est que pour de nouvelles valeurs lua (exemple: tableau).<br />
-"count": retourne en octets la place approximative utilisé par lua.<br />
-"step": il faut mettre la taille de la place que vous voulez tenter de libérer dans argument, et le programme va essayer de le libérer.(en kilo-octets)<br />
-"setpause": la valeur de argument se met dans la valeur pause du 'garbagecollector'. Retourne l'ancienne valeur de pause. Si pause=100, alors le garbage collector collecte tout le temps (de même pour des valeurs inférieurs). Par défaut, pause=200, c'est à dire que la garbage collector se lance lorsque l'utilisation de la mémoire double.<br />
-"setstepmul": le step multiplieur prend la valeur de argument. Retourne l'ancienne valeur.<br />
Si c'est 200 (valeur par défaut), le garbage collector a une vitesse normale. 100 signifie un contrôle plus poussé, et, par conséquent, plus lent...<br />
<br />
--base.error(message[,niveau])<br />
arrête le programme en renvoyant un message d'erreur donné par message.<br />
Si niveau=1(défaut) l'erreur est complétée de la fonction dans lequelle l'erreur a été déclaré.<br />
Si niveau=0 il n'y a pas d'informations supplémentaires.<br />
Si niveau=2 on indique où on a appelé la fonction qui a rapporté l'erreur.<br />
Si la fonction rapportant l'erreur a été appelé avec base.pcall, l'erreur est capturé par base.pcall et le programme ne s'arrète pas<br />
<br />
--base.next(table [,index])<br />
Cette fonction renvoi la prochaine case non vide du tableau. Si base.next(table) renvoi nil, la table est vide.<br />
<br />
--base.pcall(fonction, argument1delafonction, argument2,...)<br />
Lance fonction dans un mode protégé. Si une erreur arrive, elle est capturée et le programme ne s'arrète pas. Retourne true et les résultats si il n'y a pas eu d'erreur et false et l'éventuel message d'erreur sinon.<br />
<br />
--base.tonumber( e [,base])<br />
si e n'est pas un nombre ou un string convertible en un nombre, la fonction retourne nil. Sinon elle renvoi le nombre converti dans la base demandé (défaut = base 10)<br />
en base 10 on peut avoir des nombres à exposants ou virgules, ce qui n'est pas le cas des autres bases. La base 10 est celle où sont écrit les nombres courants.<br />
La base est comprise entre 2 et 36. Si la base n'est pas 10, le nombre doit être un entier.<br />
<br />
--base.tostring(e)<br />
Convertit n'importe quel e donné en string.<br />
<br />
--base.type( v)<br />
retourne dans un string le type de l'argument:<br />
peut retourner: "nil", "number", "string", "boolean", "table", "function", "thread", ou "userdata"<br />
<br />
--base.unpack(list [,i [,j]])<br />
retourne tout les éléments d'une table à une dimension entre i(1par défaut) et j(par défaut la longueur de la liste)<br />
C'est pareil que en lua: return list[i], list[i+1], •••, list[j]<br />
<br />
--base.getfenv(fonction)<br />
retourne la tableau contenant l'environnement global de la fonction (le tableau où les variables globales sont lues et enregistrées pour cette fonction. Le tableau par défaut est la variable globale _G . (rq: _G._G=_G )<br />
<br />
--base.setfenv(fonction,tableau)<br />
change l'environnement global de la fonction<br />
<br />
--base.setmetatable(table, metatable)<br />
Attribue metatable comme metatable de la table. On ne peut que changer la métatable d'une table en lua. Si metatable vaut nil, alors enlève la métatable de la table, et si la métatable originale avait un index “__metatable” (métatable protégée) alors provoque une erreur.<br />
La fonction retourne table.<br />
--base.getmetatable(object)<br />
Si object n'a pas de métatable, retourne nil.<br />
Sinon si sa métatable a un index “__metatable”, retourne le contenu de cet index.<br />
Sinon retourne la métatable de l'objet.<br />
<br />
--table.insert(table [,pos],valeur)<br />
insère valeur à la position donnée (si pos n'est pas donné, alors pose à la toute fin)dans la table.<br />
<br />
--table.remove(table [,pos])<br />
retire la valeur à la position donnée et décale le tableau. Retire la dernière valeur si pos n'est pas donné.<br />
<br />
--string.byte (s [, i [, j]])<br />
Retourne le contenu numérique des char s[i], s[i+1], •••, s[j].<br />
La valeur défaut de i est 1 et de j est i.<br />
<br />
--string.char(...)<br />
reçoit des nombres entre 0 et 255 et en fait un string. (en correspondance avec les valeurs ascii)<br />
<br />
--string.sub(s, i [, j])<br />
retourne la sous-string commençant au caractère i et finissant par j ème caractère.<br />
<br />
Les fonctions de gestion des strings peuvent vous être très utile car:<br />
-dans une string chaque caractère ne prend qu'un octet (au lieu de plus de 15 pour la case d'un tableau)<br />
vous pouvez donc créer par exemple un map d'un niveau avec uniquement des nombres entre 0 et 255 et lire la map avec string.byte . Cela peut vous permettre de compresser des données.<br />
ASTUCE: Stockez vos map dans des strings puis écrivez la string dans un fichier (librairie file). Réouvrez le fichier en mode "char". Hop: vous pouvez lire dans le fichier toutes les valeurs de votre niveau (nombres entre 0 et 127).<br />
-dans un sprite 5 couleurs(contenu dans un string), les 2 premières valeurs correspondes aux coordonnées à l'origine (x et y), c'est à dire que si x= 4 et y = 4, le sprite sera affiché ) x+4 et y+4<br />
Cela peut-être pratique pour éviter de recalculer des x et des y pour chaques sprites. Ces fonctions de manipulement des strings peut vous permettre à tout moment de changer les 2 premières valeurs du string du sprite.<br />
<br />
====Les fonctions non-graphiques spécifiques à nos graph====<br />
<br />
--key (numero de touche) '''attention : fonction usuelle'''<br />
retourne false si la touche n'est pas pressée, sinon retourne true si elle est pressée.<br />
Voici le tableau de correspondance des touches.<br />
Si le numero est 0, renvoi si au moins une touche est pressée. ( pas 100% fonctionnel sur g100, car renvoi des fois false même si quelque chose est pressé)<br />
<br />
--misc.numcalc ()<br />
retourne 100 sur g100 et 85 sinon<br />
<br />
--misc.exit ()<br />
le programme quitte brutalement et retourne au menu.<br />
<br />
--misc.tostring2 (nombre)<br />
retourne le nombre en chaine de caractère (uniquement nombres entiers entre -2147483647 et 2147483647). plus rapide que base.tostring . De plus le nombre n'est jamais affiché sous forme exponentielle.<br />
<br />
--misc.contrast(nb)<br />
Le nombre doit être 1 ou -1. diminue(-1) ou augmente le contraste(1) (attention: pas de limite est fixée et la calc peut ne pas supporter tout les contrastes )<br />
<br />
--misc.math ([parametre] ,nombre)<br />
Fait quelque chose de différent en fonction de paramètre:<br />
-"ln" retourne ln(nombre) ln est le logarithme népérien (log(x) = ln(x)/ln(10)<br />
-"exp" retourne exp(nombre)<br />
-"sqrt" ou "racine" retourne la racine carrée du nombre<br />
On peut aussi calculer la racine avec exp((ln(x))*0.5) ), mais sqrt est plus rapide (et plus précis dans certains cas, comme les racines des grands nombres)<br />
<br />
Si le calcul est impossible pour sqrt ou ln (nombre négatif par exemple) la fonction retourne nil<br />
<br />
<br />
--misc.wait(nb de fois 2centisecondes) <br />
met le processeur (et donc le programme) en pause pendant le temps indiqué.<br />
Utilisez cette fonctions pour ralentir les menus,...<br />
Elle permet d'économiser les piles (elle consomme 10 fois moins qu'une instruction normale sur g100 par exemple)<br />
exemples:<br />
local wait=misc.wait<br />
wait(10) -- attends 0,2 secondes<br />
wait(20) -- 0,4secondes<br />
wait(50) -- 1seconde<br />
wait(100) -- 2 secondes<br />
wait(3000) – 1minute<br />
<br />
Par contre à faible nombre, la fonction n'est pas exacte, alors utilisez wait(1) et wait(2) dans un boucle attendant une pression de touche afin de garder un bonne réactivité et diminuant drastiquement la consommation, mais ne l'utilisez pas dans une boucle de jeux, car en fonction de certains paramètres, l'attente est différente. (De plus le résultat est différent sur g100 et g85)<br />
<br />
--misc.random(max)<br />
renvoi un nombre aléatoire entre 0 et max-1. Le nombre renvoyé est un entier.<br />
max doit être inférieur à 32767<br />
Exemple: misc.random(1000) retourne un nombre entre 0 et 999<br />
<br />
--int(nombre) attention : fonction usuelle<br />
renvoi la partie entière d'un nombre.<br />
<br />
--misc.chrono_set([numero_du_chrono])<br />
permet de démarrage d'un chronomètre (deux emplacements : 1 (par défaut) et 2).<br />
Si le chronomètre était déjà démarré, permet de le réinitialiser.<br />
--misc.chrono_read([numero_du_chrono],[mode])<br />
lit le temps chronométré par un chronomètre (le 1 si vous ne spécifiez pas le numéro)<br />
deux formats sont possibles:<br />
.si vous ne rentrez pas de second argument, alors il sera retourné un entier correspondant au temps passé en 1/50 de secondes sur g100 et en 1/64 de secondes sur g85.<br />
.si vous rentrez un second argument, alors il sera retourné dans cet ordre le temps passé : centiseconde, seconde, minute<br />
<br />
Le chronomètre est précis au 1/50e de secondes sur g100 et 1/64e de secondes sur g85.<br />
La premier mode d'affichage permet de gérer des évènements arrivant à fréquence élevée ( déplacement ennemi, ...), alors que le second mode permet plutôt d'avoir une idée du temps qui passe sur un durée plus longue.<br />
<br />
--misc.modlist()<br />
--misc.modload(nom)<br />
Le lua est assez limité en place sur nos graph.<br />
<br />
-> La solution est de charger un .lua principal et de charger ensuite, quand on a besoin, d'autres .lua (qui peuvent contenir des données sur un niveau, des fonctions, une librairie en lua, ...).<br />
Sur g100 il faut que tout soit précompilé en .lc . C'est conseillé sur g85 car la lecture de .lua consomme beaucoup de mémoire.<br />
<br />
Utiliser un module lua consomme un peu plus de mémoire que si on avait tout mis dans un seul fichier, mais cela apporte des avantages:<br />
-On ne peut supprimer des fonctions de la mémoire que si c'est dans un module.<br />
-Si on a beaucoup de données, on peut utiliser plusieurs modules pour les stocker. En chargeant un module à la fois on consomme moins de mémoire que si tout était dans un seul fichier.<br />
-Cela permet aussi de faire des librairies.<br />
<br />
A noter: seules les variables (et fonctions) globales dans le module sont visibles.<br />
<br />
Un fichier .lua chargeable avec modload s'appelle un module.<br />
Le .lua doit contenir une string finissant par "module nom_du_module" (le nom doit avoir une taille inférieure ou égale à 8)<br />
modlist renvoi les noms de tout les modules trouvés.<br />
modload tente de charger le module avec le nom indiqué.<br />
<br />
Exemple 1: Je veux charger une librairie et je ne souhaite pas la décharger.<br />
<br />
f,err = misc.modload ( nom)<br />
if f == nil -- si il y a erreur, f = nil<br />
then<br />
print(err) -- err contient le message d'erreur<br />
end -- affiche l'erreur lors du chargement du fichier<br />
f() -- execute le fichier (et donc défini les fonctions et les variables globales qui deviennent accessibles)<br />
<br />
Remarque: f correspond en fait à une fonction qui contient tout le code du module. L’exécuter revient à lancer le programme contenu dans le module.<br />
<br />
Exemple 2: Je veux charger un module, mais je n'ai pas confiance dans le contenu: j'aimerais qu'il ne puisse pas voir les variables globales que j'ai défini et qu'il ne puisse pas les modifier.<br />
OU : Je veux charger le module et pouvoir le supprimer de la mémoire entièrement ensuite.<br />
<br />
f,err = misc.modload ( nom )<br />
if f == nil -- si il y a erreur, f = nil<br />
then<br />
print(err) -- err contient le message d'erreur<br />
end -- affiche l'erreur lors du chargement du fichier<br />
tab = {base = base ; misc = misc ; nbdraw = nbdraw ; graydraw = graydraw}<br />
base.setfenv(f, tab) – tab est maintenant l'environnement de f (contient toutes les variables globales)<br />
f()<br />
<br />
Toutes les variables globales de f seront définies dans tab. ( on y accède avec ' tab. ' )<br />
Pour supprimer le module de la mémoire:<br />
f = nil<br />
tab = nil – il faut mettre nil aux 2 pour que ça marche<br />
base.collectgarbage("collect") – on supprime tout le module d'un coup.<br />
<br />
====la librairie file:====<br />
cette librairie permet de stocker et de lire facilement dans un fichier stocké dans la ram de votre casio. Le nom du fichier doit commencer par LF et ne pas faire plus de 8 caractères. Il sera protégé d'un mot de passe pour prévenir la modification des données par l'utilisateur.<br />
Le système permet de stocker juste ce que vous avez besoin dans un minimum de place.<br />
Par exemple un nombre normal lua prend 4 octet dans un fichier, alors que sinon il en prend bien plus (environ 20 dans une variable locale sur g100 et plus sur g85)<br />
Les fichiers sont ouverts sous différent mode selon le contenu des données:<br />
"string" est le mode pour stocker des string (1 octet par caractère)<br />
"char" est pour les entiers de -128 à 127 (1 octet)<br />
"int" est pour les entiers de -32 768 à 32 767 (2 octets)<br />
"float" est pour les nombres normaux utilisés par le lua (4 octets)<br />
les données du fichier ouvert sont contenu dans une variable du type userdata.<br />
<br />
Un fichier ne peut pas être ouvert si la taille ne correspond pas à un multiple de le taille du type demandé.<br />
La taille totale du fichier est limitée à 32750.<br />
<br />
A chaque création de fichier/changement de taille/suppression , il faut rechercher de nouveau tout les fichiers pour pouvoir lire/ecrire dedans/les supprimer (sauf celui que l'on vient de manipuler).<br />
<br />
--file.new(nom,nombre_de_cases,[mode])<br />
crée un fichier et renvoi l'userdata associé. Il y a une erreur si le fichier existe.<br />
La taille réelle du fichier est un multiple du nombre de cases.<br />
<br />
--file.search(nom,[mode])<br />
renvoi un userdata contenant les données sur le fichier recherché et nil s'il n'existe pas.<br />
<br />
--file.mode(fichier)<br />
renvoi le mode d'ouverture du fichier<br />
<br />
--file.resize(fichier,nombre_de_cases)<br />
change la taille du fichier<br />
(indisponible sur g85)<br />
<br />
--file.delete(fichier)<br />
supprime le fichier (et l'userdata associé est inutilisable)<br />
<br />
--file.length(fichier)<br />
renvoi le nombre de positions disponibles dans le fichier (pareil que #fichier)<br />
<br />
--file.ramsize()<br />
renvoi la place restante dans la ram.<br />
( non disponible pour g85 )<br />
<br />
--file.read(fichier,position,[fin])<br />
renvoit le nombre contenu à position.<br />
Si on attends une string, il faut indiquer la position finale. (1 caractère = 1case)<br />
La première case est numérotée 1.<br />
<br />
--file.write(fichier,position,nombre)<br />
écrit le nombre (ou la string) à position.<br />
<br />
Dans tout les cas, dès que vous utilisez une fonction à tort (en dehors du fichier, fichier non réactualisé, ...), une erreur est envoyée et le programme s'arrète, sauf si l'erreur est capturée par un pcall.<br />
<br />
Exemple: pour rechercher un fichier et le créer s'il n'existe pas ou n'est pas de la bonne taille:<br />
<br />
local delete = file.delete<br />
local new = file.new<br />
local search = file.search<br />
<br />
-- mode est un argument facultatif<br />
local function search_or_create ( name , taille,mode )<br />
local result = search (name , mode)<br />
if result then<br />
if #result == taille then result<br />
else delete(result) ; return new(name,taille , mode)<br />
end<br />
else<br />
return new(name,taille mode)<br />
end<br />
end<br />
<br />
<br />
====le noir et blanc====<br />
<br />
Le mode noir est blanc a un repère partant du coin en haut à gauche de l'écran (le point 1,1) finissant en bas à droite (64, 128)<br />
On a accès à une ligne et une colonne de plus qu'en basic.<br />
<br />
L'écran est aussi divisé en colonnes et lignes pour savoir où l'on va écrire avec nbdraw.print . Cela correspond à la fonction locate en basic, sauf que l'on a droit à une ligne de plus ( colonne de 1 à 21 et ligne de 1 à 8)<br />
<br />
En lua, on a accès à des pictures virtuelles qui correspondes à des 'pages' d'écran. (En gros si vous voulez vous avez accès à 5 buffers.)<br />
La page 0 est la page principale où tout est affiché. On peut copier la page 0 sur la page 2 ou 3,... et inversement. On peut écrire sur une autre page et copier sur la page 0, ainsi on évite que l'utilisateur voit le dessin se dessiner (et cela évite le clignotement)<br />
la page maximale est 5.<br />
<br />
Si vous ne comprenez pas le système de buffer, contentez vous de savoir que ce qui s'affiche est sur la page 0 qui est l'endroit où les fonctions écrivent par défaut.<br />
<br />
--nbdraw.print(nombre ou/et booléen(true ou false) ou/et string,[autant de paramètres que l'on veut (max 200)])<br />
affiche tout ce que vous demandez en noir et blanc à l'endroit ou se situe le curseur virtuel (invisible) (voir nbdraw.getcursor pour savoir ou est le curseur)<br />
Le curseur se place après le dernier caractère que nbdraw.print a écrit.<br />
Un nbdraw.print ne doit pas afficher plus de 190 caractères (plus grand que l'écran, heureusement)<br />
Les caractères spéciaux sont:<br />
– '%' doit être écrit %% pour être affiché (Ne pas mettre % tout seul!)<br />
– '\n' fait un saut de ligne sans retour à la ligne<br />
– '\r' revient au début de la ligne (donc la passage à la ligne suivante est '\n\r'. bizzarement, '\r\n' provoquera un erreur lors du chargement "bad constant" )<br />
– $ ne doit jamais être écrit<br />
– on peut accèder à des caractères secondaires (voir tableau p34 du manuel du programmeur http://gprog.tk/) . On peut accèder à la seconde collone de tableau en plaçant \246 juste avant un caractère. (pas encore dispo sur g85)<br />
Par exemple je peut afficher la flèche simple vers la droite avec : "\246\157", car \abc converti abc en caractère selon le code ascii (ex: \044 )<br />
– on peut afficher ' et " avec \' et \"<br />
<br />
<br />
---nbdraw.getcursor ()<br />
retourne la collone et la ligne du curseur où va écrire nbdraw.print<br />
<br />
--nbdraw.setcursor (ligne,colonne)<br />
place le curseur où nbdraw.print va écrire<br />
Cela correspond à placer où l'on va écrire comme la fonction locate en basic sauf que l'on écrit rien.<br />
On a droit à la 8e ligne innaccessible avec locate en basic.<br />
<br />
--nbdraw.precision(nb)<br />
Attribue nb à la précision de la conversion par défaut des nombres (base.tostring et nbdraw.print) et chaine de caractère. Par défaut elle est de 6 chiffres significatifs (le reste est arrondi)<br />
Si vous avez des imprecisions dans vos calculs, exemple: vous devez afficher 2.349999, la précision de 6 chiffres affichera 2.35 ou le nombre précédent si elle était de 7.<br />
<br />
<br />
<br />
--clear( page ) attention : fonction usuelle<br />
efface la page que vous avez indiquée (celle affichée : 0)<br />
<br />
--nbdraw.pixeltest (x,y,[page])<br />
renvoi 1 si la pixel est allumé, 0 sinon<br />
<br />
Remarque: le repère est de haut en bas et de droite à gauche.<br />
Le pixel en haut à gauche (innaccessible en basic) a pour coordonnées x=1 et y=1<br />
et celui en bas à droite x=128 et y =64.<br />
C'est à dire que le basic Pixtest(30,20) devient nbdraw.pixeltest(31,21) (le repère est décalé d'une ligne et une collone, puisque une ligne et une collone de plus sont disponibles.)<br />
<br />
--nbdraw.pixel(x,y,[couleur],[page])<br />
affiche un pixel blanc (couleur = 0) ou noir (couleur=1, par défaut) sur la page principale ou celle que vous indiquez. Si vous écrivez en dehors de l'écran, le pixel ne sera pas affiché.<br />
<br />
--nbdraw.line(x1,y1,x2,y2,[page])<br />
affiche une ligne noire du point (x1,y1) au point (x2,y2) sur la page principale ou celle que vous indiquez.<br />
<br />
--nbdraw.copypage(page source, page destinataire)<br />
Vous avez dans doute remarqué que de nombreuses fonctions peuvent prendre une 'page' comme argument.<br />
En effet la page 0 est la page affichée et les pages de 1 à 5 sont des pages disponibles pour des dessins (vous pouvez dessinez qqch pendant que vous affichez autre chose)<br />
Cette fonction permet par exemple de copier la page 5 sur la 0 pour afficher le contenu de la page 5.<br />
<br />
====les 5 couleurs (blanc – gris clair – gris moyen – gris foncé – noir )====<br />
<br />
Le repère utilisé (position des pixel avec x et y) est le même qu'en noir et blanc.<br />
Le mode 5 couleurs s'active avec graydraw.setcolor(true) et s'éteint avec graydraw.setcolor(false)<br />
Il s'éteind automatiquement lorsque l'on quitte.<br />
<br />
Ce que l'on dessine est toujours d'abord dessiné dans un écran invible (buffer), puis une fois que l'on a tout dessiné, on demande à afficher l'écran invisible à l'écran (pendant que l'on redessine sur l'écran invisible, l'écran visible continu d'afficher l'ancienne image)<br />
<br />
L'atout du mode 5 couleurs est que l'on peut utiliser des sprites: c'est à dire que l'on peut afficher un morceau d'image que l'on a prédessiné à n'importe quel x ou y (l'image peut même dépasser de l'écran sans bug)<br />
<br />
Rq: sur g85 le gris foncé est en fait remplacé par: 1pix sur 2 du gris moyen et 1 pix sur 2 du noir.<br />
<br />
Dessiner un sprite:<br />
Pour dessiner un sprite, utilisez le logiciel sprite maker en mode C/C++ gxlib10 sur pc.<br />
Une fois le sprite dessiné, enregistré et généré, copiez collez le contenu entre les guillemets entre les guillements de la table foo du fichier lua sprites.lua<br />
Lancez dans windows sprites.lua (avec le lua pour windows)<br />
un ficher Prog.lua est apparu avec le sprite sous forme de string et prète à être mise dans le .lua de votre projet.<br />
Tout les sprites sont compressés dans des strings!<br />
Remarque: si Prog.lua existe déjà il est écrasé.<br />
Le string contenant un sprite peut apparaitre bizzare, ne vous en inquiétez pas.<br />
<br />
Code du fichier sprites.lua ( à executer avec lua windows et non pas le lua g100/g85 ):<br />
<br />
foo = { /le code du sprite/ }<br />
out = io.open("Prog.lua", "w") – l'ancien fichier Prog.lua sera effacé<br />
foo2=string.char(unpack (foo));<br />
out:write(("sprite = %q"):format(foo2));<br />
--Prog.lua contient la string associé au sprite.<br />
out:close()<br />
<br />
<br />
Pour afficher un sprite:<br />
<br />
--spritexy x,y, sprite_sous_forme_de_string attention : fonction usuelle<br />
afficher le sprite aux coordonnées indiquées.<br />
<br />
Exemple:<br />
<br />
graydraw.setcolor(true) –on active le mode 5 couleurs<br />
<br />
ballon ="bapzefbpazefpqkdù$"éù'*é"'" --pas vraiment un sprite ici, mais ce sera quelque chose du genre<br />
... --code<br />
clear nil –efface l'écran invisible<br />
spritexy 20, 30 , ballon -- dessine le sprite ballon dans l'écran invisible<br />
<br />
refresh --dessine l'écran invisible à l'écran<br />
<br />
--graydraw.setcolor(true ou false)<br />
active(true) ou désactive (false) le mode d'affichage 5couleur (au démarrage du programme, le mode d'affichage est Noir et blanc)<br />
<br />
--graydraw.text(x,y,caractères ou nombre)<br />
affiche aux coordonnées entrées une chaine de caractère ou un nombre.<br />
Si on entre un nombre, il est converti en un entier entre -2147483647 et 2147483647 car l'algorithme utilisé est beaucoup plus rapide que l'algorithme normal (tostring) qui est très lent.(il s'agit de l'algorithme rapide de misc.tostring2<br />
Si vous voulez vraiment afficher un nombre à virgule ou plus grand, utilisez:<br />
graydraw.text(x,y,base.tostring(nombre))<br />
<br />
Tout caractère ne peut pas être affiché: seul peut être affiché ces caractères (les minuscules sont converties en majuscules):<br />
' ( ) * + , - / 0 1 2 3 4 5 6 7 8 9 : ; < > = ? @<br />
ABCDEFGHIJKLMNOPQRSTUVWXYZ<br />
Les caractères sont affichés en noir avec 5 pixels de hauteur, 4 de largeur + 1 pixel d'espace entre chaque caractère.<br />
<br />
--clear nil attention : fonction usuelle<br />
efface l'écran invisible<br />
<br />
--refresh attention : fonction usuelle<br />
dessine l'écran invisible à l'écran.<br />
<br />
--graydraw.pixel(x,y,[couleur])<br />
dessine un pixel d'une couleur de 0(blanc) à 4 (noir) (1:gris clais 2: gris moyen 3: gris foncé) dans l'ecran invisible, et 5 inverse le pixel.<br />
La couleur par défaut est le noir.<br />
<br />
<br />
--graydraw.line(x1,y1,x2,y2,couleur)<br />
Dessine une ligne de la couleur désirée (entre 0: blanc et 4: noir (5: inverser les couleurs)) dans l'écran invisible.<br />
Les points en dehors de l'écran ne sont pas dessinés<br />
<br />
--graydraw.rect(x1,y1,x2,y2,couleur1,couleur2)<br />
Dessine un rectangle de contour couleur1 et de intérieur couleur2 .<br />
<br />
--graydraw.pixeltest(x,y)<br />
renvoie la couleur du pixel dans l'écran invisible<br />
<br />
--graydraw.fill(couleur)<br />
rempli l'écran invisible de la couleur donnée. 5 inverse l'écran.<br />
<br />
<br />
<br />
--state(false ou true) attention : fonction usuelle<br />
C'est la fonction qui permet d'égaler un programme C!<br />
state 'sauve' (false) le décor de manière très rapide pour le ressortir quand on le souhaite (true).<br />
Ainsi vous pouvez dessiner un décor très fournit et le recharger en un rien de temps dans l'écran invisible.<br />
false: sauve l'écran invisible<br />
true: remet l'écran invisible à l'état où il était quand il était sauvegardé.<br />
Remarque: une sauvegarde de l'écran suffit pour le recharger autant qu'on le désire.<br />
<br />
--graydraw.map(image en string)<br />
Ceci affiche une map dessinée avec sprite maker (il s'agit d'un mode spécial en dehors des sprites: "convertir et coder une image 128*64")<br />
<br />
--scrollx ou scrolly (x ,couleur) attention : fonction usuelle<br />
Vous avez affichez une map , et vous voulez la faire défiler sans tout redessiner, alors cette fonction est pour vous!<br />
<br />
Un scroll signifie décaler tout les pixels de l'écran d'un coup. Les pixels qui disparaissent d'un coté réapparaissent de l'autre (vous pouvez les effacer et completer la map)<br />
<br />
x est entre -8 et 8 (0 ne fait rien)<br />
<br />
scrollx décale les pixels au niveau des x: si x est négatif, les pixels se décalent vers la gauche (leurs x diminue) si x = -1, ils se déplacent d'un pixel, si x = -3, de 3 pixels ,...<br />
Si x est positif, les pixels se déplacent de la même manière vers la droite.<br />
<br />
scrolly fait la même chose que la fonction précedente, mais sur l'axe des y.<br />
Si x est négatif, les pixels vont vers le haut et inversement.<br />
<br />
scrollx a la même vitesse peu importe la valeur de x. scrolly 1 100 est 8 fois plus rapide que scrollx maisla vitesse de scrolly y 100 dépend de y.<br />
<br />
Si couleur est entre 0 et 5, alors ce sera remplacé par une ligne de la couleur indiquée.(0:blanc 4:noir 5: inverser) (sur g85, la couleur 3 ne donne pas un très bon rendu)<br />
sinon (exemple: couleur = 100) ce qui sort d'un coté de l'écran réapparait de l'autre<br />
<br />
L'interet de décaler tout les 2 ou 3 pixels au lieu de 1 est dans le cas où le programme fait un nombre important de calcul, et que le programme serait plus fluide si le scrolling est de plus de 1 pixel.<br />
Un scrolling de seulement 1 pixel peut aussi dans certains cas faire apparaitre aux yeux l'image floue (l'oeuil distingue mieux un décalage rapide de 2 pixels).<br />
<br />
<br />
<br />
<br />
===les fonctions usuelles===<br />
<br />
Vous avez sans doute remarqué les 'attention : fonction usuelle'.<br />
Certaines fontions sont appelées de nombreuses fois dans des programmes avec un affichage graphique dévellopé, et ce genre de programme néccessite le plus de fluidité possible, donc j'ai regroupé certains fonctions en les codant d'une certaines manière que leur appel est plus rapide.<br />
<br />
Ce que l'on ne peut plus faire avec les fonctions usuelles:<br />
<br />
local math=misc.math -- fonctionne<br />
local touche= key -- ne fonctionne pas<br />
<br />
En effet, pour utiliser ces fonctions, il faut être plus stricte, et vous ne pourrez pas précompiler si vous ne respectez pas la syntaxe requise.<br />
Mais vous pouvez faire par exemple:<br />
clear 0<br />
clear (0)<br />
clear x -- avec x= 0<br />
clear (x)<br />
clear nil<br />
local touche= key(5) -- contient true si exe était pressé, sinon false<br />
if key(5) then ... end -- execute si exe était pressé.<br />
scrolly 1,4 -- ne pas faire (1,4)<br />
scrollx x,(-y)<br />
spritexy x, y, sprite<br />
spritexy (60), y, sprite<br />
state true<br />
state (false)<br />
refresh<br />
....<br />
remarque:<br />
--clear (num)<br />
en Noir et Blanc, num doit contenir le numero de la page à effacer (page principale= ce que l'on voit à l'écran = page 0)<br />
en 5 couleurs, num n'est pas important, mais vous devez le mettre. Conseil: mettez nil qui prend moins de place.<br />
<br />
<br />
En fait une fonction usuelle est codée comme une opération de base du lua (+, ...) ce qui fait que son appel est quasi instantané et que contrairement à tout les appels de fonctions (lua ou C) il n'y a pas de gestion de la mémoire ( aucune allocation 'au cas où' et pas de perte de temps)<br />
<br />
== Optimisations==<br />
<br />
<br />
A quoi sert t'il d'avoir le code le plus rapide possible?<br />
<br />
-> c'est plus agréable pour l'utilisateur<br />
-> dans le cadre d'un programme graphique; il faut savoir que plus l'affichage se 'raffraichis' (c'est à dire que l'image à afficher se met à jour) rapidement, plus on a l'impression que le mouvement est fluide (le jeux est agréable à regarder)<br />
pas contre si le mouvement est trop rapide, on a l'impression de flou, d'où par exemple dans le jeux "ballon", les ballons ne montent pas d'un pixel par pixel, mais de 45% d'un pixel ou plus en fonction du niveau. (lorsqu'ils sont affichés avec une coordonnée à virgule, en réalité la fonction de sprite ne voit que la partie entière des coordonnées (comme toutes les fonctions graphiques qui le font intantanément) )<br />
<br />
Quelques optimisations à effets importants:<br />
-Evitez au maximum d'appeler des fonctions (lua ou C) dans la boucle principale de votre programme. (sauf dans le cas des fonctions usuelles dont l'appel est instantané)<br />
-Diminuez au maximum les calculs<br />
-Utilisez les particularités du lua:<br />
par exemple:<br />
if key(5) == true then x=1 else x=y end<br />
-> 1ère optimisation :<br />
if key(5) then x=1 else x=y end<br />
-> 2e optimisation :<br />
x = (key(5) and 1) or y<br />
en effet or renvoi le premier résultat vrai et and le dernier (sauf si c'est faux)<br />
et un nombre est toujours considéré vrai<br />
par exemple si exe (key(5) ) est pressé:<br />
vrai and 1 renvoie 1<br />
<br />
-Utilisez la fonction state pour charger un décor permet de faire un bonne interface graphique tout en accélérant le code .<br />
-Passez en local toutes les fonctions que vous pouvez<br />
-while not condition do ... end est plus lent que son équivalent repeat ... until condition.<br />
<br />
<br />
Remarque:<br />
<br />
Un mouvement est saccadé à partir tu moment où la fréquence de rafraichissement est inférieur à celle de l'écran.<br />
Sur g100 l'écran se raffraichit toutes les 0,1 secondes.<br />
Si on raffraichit l'image toutes les 0,2 secondes, l'image sera un peu saccadée.<br />
Si l'image se raffraichi toute les 0,04 secondes environ, le mouvement est fluide.<br />
<br />
<br />
<br />
<br />
<br />
==Remarques==<br />
-seclua (sur g100) est un programme basic qui est là pour empècher qu'un bug insoluble du lua qui à son lancement écrit quelque part au début de seclua, d'où le fait qu'il doit être en première position.<br />
Seculua est aussi utilisé pour stocker les données de state (donc au rédémarrage d'un programme, les données de state contenues de la fois précédente peuvent avoir été très légèrement modifiés)<br />
Il contient aussi (dans l'endroit plus sécurisé) les sprites de caractères.<br />
<br />
-sur g85 , il reste quelques bugs. Si vous avez un plantage juste après avoir lancé le gris, mettez une petite attente avant d'activer le gris.<br />
<br />
-un local est plus rapide et plus petite qu'une variable globale. Une fonction peut être local est donc son appel est plus rapide<br />
-les goto n'existent pas en lua, il est donc difficile de retranscrire en lua un programme avec des goto. Cependant on peut couper un programme avec des goto en fonctions, à condition que l'on s'arrange pour quitter chaque fonction avant dans lancer une autre (voir programme bourse pour comprendre)<br />
<br />
-chaque appel d'une fonction (lua ou C) alloue de la mémoire pour un éventuel retour de la fonction. Cet espace n'est libérable pas le garbagecollector qui si l'on a quitté la fonction (donc si A appelle B, la mémoire de A n'est pas libérable). Il est donc préférable dans une boucle d'éviter au maximum d'appeller une fonction chaque tour (pour la fluidité et le fait que l'on devrait souvent liberer la mémoire)<br />
Si des fonctions s'entre-appellent à l'infini (A appelle B qui appelle A,...) vous aurez à un moment une pénurie de mémoire.<br />
<br />
-le ramasseur d'ordure ne se déclenche que lorsque l'utilisation de la mémoire augmente beaucoup. On peut l'arrèter ou le déclencher avec la fonction base.collectgarbage.<br />
Si il n'y a plus assez de mémoire il se déclenche de force pour en liberer, mais il peut échouer. Pour aider à gérer la mémoire, mettez à nil les objets que vous n'utilisez plus (c'est fait par défaut pour les variables locales d'une fonction que l'on quitte ). De plus si vous mettez beaucoup de variables à nil d'un coup, forcez une collection.<br />
<br />
Voici différents exemples de code qui peuvent vous aider:<br />
<br />
-si vous avez une erreur du genre "invalid comparison, x is nil":<br />
x=map[i] --par exemple<br />
..... --code<br />
if (x>100) --l'erreur est signalée ici<br />
<br />
Dans ce code on remarque que cela vient probablement de la case i de map qui doit être nil. Pour connaitre i et comprendre l'erreur on peut faire:<br />
..... --code<br />
if (x) then base.error("\n\rerreur x est nil.\n\r la valeur de i était:\n\r i="...tostring(i))<br />
if(x>100)<br />
<br />
Ainsi quand x sera égal à nil, au lieu d'avoir le message d'erreur précédent, vous aurez le message d'erreur:<br />
x est nil.<br />
La valeur de i était:<br />
i=433<br />
(le valeur de i est donnée en exemple.)<br />
Une fois l'erreur trouvée, vous pouvez supprimer la ligne avec le test pour ne pas ralentir votre code.<br />
-Vous pouvez vous aussi capturer l'erreur d'une fonction sans arrèter le programme.<br />
function mafonction (i)<br />
.... --code<br />
end<br />
<br />
....<br />
arg= 5 --par exemple<br />
a,b=base.pcall(mafonction,arg)<br />
if (not a) -- il y a eu une erreur (equivalent à if (a == false) )<br />
then affichererreur(b) end --b est un string contenant le message d'erreur<br />
.... --dans tout les cas le programme continu. (sauf erreur memoire)<br />
<br />
-Vous pouvez vous même creer votre propre message d'erreur<br />
function mafonction (i)<br />
type=base.type(i)<br />
if(type ~= "number") then -- ~= signifie différent de<br />
base.error("erreur d'argument, il faut rentrer un nombre, non pas un"...type,0)<br />
end<br />
.... --code<br />
end<br />
- Si vous voulez défiler les cases d'un tableau, deux cas se présentent à vous:<br />
. Si le tableau ne contient que des cases numérotées par des entiers positifs supérieurs à 1, le plus rapide est d'utiliser une boucle for et d'accéder directement aux cases du tableau.<br />
. Si le tableau contient aussi des cases que l'on n'accède pas avec un entier positif supérieur à 1 ( par exemple la case 0, la case "feuille", ...), alors le plus rapide est d'utiliser le code suivant:<br />
<br />
local next = base.next<br />
for k,v in next, mytable do<br />
.... -- k contient l'indice tel que mytable[k] = v<br />
-- la boucle défile toutes les valeurs de k possibles<br />
end<br />
<br />
- Pour stocker des données (comme des maps), vous pouvez utiliser les string ou les fichiers. Le lecture d'une case d'un fichier (file.read) et la lecture de l'entier codé par une lettre de la string (string.byte) se fait quasiment à la même vitesse. Vous pouvez donc utiliser les deux systèmes.<br />
Il faut cependant admettre que l'accès d'un tableau est plus rapide (deux fois plus rapide), mais les tableaux prennent énormément plus de mémoire qu'une string<br />
<br />
<br />
Remerciements:<br />
<br />
De grands remerciements à tout ceux qui m'ont aidé dans ce projet. La liste est longue (Orwell, PierrotLL, Eiyeron, Louloux, Purobaz, light_spirit, kristaba,... et j'en oublie)<br />
[[Catégorie:Lua]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPLua&diff=1023CPLua2014-05-20T09:24:10Z<p>Cartix : </p>
<hr />
<div>{{InfoBox Software<br />
| nom = CPLua <br />
| logo = cpluaicon.png<br />
| logoCaption = icon <br />
| auteur = Orwell<br />
| langage de programmation = Lua<br />
| genre = IDE<br />
| plateforme = Classpad<br />
}}<br />
Le langage Lua est un juste milieu entre le CPBasic et le C/C+/Asm. Ce langage de programmation est simple, flexible et rapide. Il permet aux développeurs de créer des programmes complexes impossibles à écrire en CPBasic.<br />
<br />
CPLua est un add-in pour ClassPad qui inclut un interpréteur Lua et propose beaucoup de nouvelles fonctions, en plus de la programmation on-calc. <br /><br />
CPLua est un projet donc quelques bugs peuvent apparaître. La version la plus stable est actuellement la version 0.8. La dernière version est la version 0.10A.<br />
<br />
==Histoire== <br />
CPLua a été commencé en 2005 par Julien, un programmeur français, parce qu'il y avait trop de personnes qui se plaignaient de la lenteur du CPBasic mais ne voulaient pas apprendre le C++.<br />
* 01/09/2005 : la première version a été publiée [http://casiocalto.free.fr/Forum/viewtopic.php?t=611 ici].<br />
* 07/09/2005 : version 0.4 : ajout de la possibilité sauver/ouvrir des script Lua<br />
* 08-09/2005 : version 0.51 : correction de certains bugs et ajout d'un nouveau clavier<br />
* 27/09/2005 : version 0.72 : ajout de la totalité du paquet de CAS<br />
* 19/04/2006 : version 0.8 : version la plus rapide (en dessin) de CPLua. Téléchargez-la [http://www.casio-scene.com/downloads.php?do=file&id=532 ici]<br />
* 07-27-2007 : version 0.9E : la dernière version faite par Orwell (ajout de la bibliothèque UI)<br />
L'année dernière, deux programmeur, [http://www.casio-scene.com/member.php?10077-Cartix Cartix] (moi) et [http://www.planet-casio.com/Fr/compte/voir_profil.php?membre=binary_man Binary_Man], de Planete Casio, ont commencé à retravailler sur le projet, dans le but d'ajouter de nouvelles fonctions. Notre première version (CPLua 0.10A) est sortie le 28/01/2012, et est disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici]<br />
<br />
==Mise en route==<br />
* Premièrement, télécharger la version de l'add-in que vous souhaitez :[http://www.casio-scene.com/downloads.php?do=file&id=532 CPLua 0.8] ou [http://www.casio-scene.com/downloads.php?do=file&id=533 CPLua 0.10A]<br />
* Envoyez ensuite le .cpa à votre classpad avec FA-CP1 ou Classpad Add-In Installer (des tutos seront bientôt disponible)<br />
* Allez au menu principal sur votre Classpad et ouvrez l'application CPLua<br />
* Créez un nouveau fichier et commencez à programmer<br />
<br />
==Librairie== <br />
* UI : Interface utilisateurs : Cette librairie vous permet d'utiliser l'interface utilisateur du Classpad (menu, barre d'outils,…) dans vos programmes<br />
* CAS : Système d'Aglèbre informatique : Cette librairie vous permets d'employer toutes les fonctions mathématiques de l'application "Main" (diff, intg, solve, …)<br />
* Draw : Cette librairie vous permet de dessiner sur l'écran (point, ligne, cercle,…) et pour employer des sprites/images<br />
* IO : Entrée-sortie : Cette librairie vous permet de manipuler les fichiers de votre Classpad (ouvrir, enregistrer, lire,…)<br />
* String : Cette librairie vous permet de manipuler les chaines de caractères<br />
* Debug : Cette librairie vous permet de corriger votre programme<br />
* Table : Cette librairie vous permet de manipuler des listes<br />
* Math : Cette librairie vous permet d'effectuer des opérations sur des nombres (sin, log,…)<br />
Pour connaître toutes les fonctions d'une librairie, "table.foreach (<name du library>, de la copie)"<br />
<br />
==Structures de Controle==<br />
===BOUCLES===<br />
* Vous pouvez casser une boucle avec "break"<br />
====While====<br />
<pre><br />
while <condition 1> do<br />
<code à exécuter tant que la condition 1 est respectée><br />
end<br />
</pre><br />
<br />
====Repeat====<br />
<pre><br />
repeat<br />
<code à exécuter tant que la condition 1 est respectée><br />
until <condition 1><br />
</pre><br />
<br />
====For====<br />
<pre><br />
for <var>=<min>,<max>[,incrément] do<br />
<code à exécuter tant que var est différent de max ><br />
end<br />
</pre><br />
* Si l'incrément n'est pas spécifié, il vaudra automatiquement 1<br />
<br />
===IF===<br />
<pre><br />
if <condition 1> then<br />
<code à exécuter si la condition 1 est respectée><br />
elseif <condition 2> then<br />
<code à exécuter si la condition 1 est respectée et la condition 1 est respectée><br />
else<br />
<code à exécuter si aucune des conditions n'est respéctée><br />
end<br />
</pre><br />
<br />
===Déclaration d'une fonction===<br />
<pre><br />
function <nom de la fonction>(<liste des paramètres>)<br />
<code à exécuter si la fonction est appelée><br />
return <valeur à retourner><br />
end<br />
</pre><br />
* Si la valeur à retourner n'est pas spécifiée, la fonction ne renverra rien<br />
* Si aucun paramètre n'est spécifié, la fonction fonctionnera sans paramètre<br />
* On peut déclarer des variables locales dans les fonctions, utilisable uniquement par la fonction dans laquelle elles ont étés déclarées<br />
<br />
===Comentaires===<br />
<pre><br />
--<commentaire> pour un commentaire d'une ligne<br />
--[[<commentaire>]]-- pour un commentaire de plusieurs lignes<br />
</pre><br />
<br />
==Fonctions spécifiques à CPLua==<br />
CPLua a deux écran différents : la console (pour les entrées/sorties) et l'écran graphique (pour dessiner). Par défaut, un programme affiche la console. On peut passer de l'un à l'autre à l'aide de<br />
* showconsole() pour afficher la console<br />
* showgraph() pour afficher l'écran graphique<br />
Il y a de nombreuse autres fonctions spécifiques telles que :<br />
* keypad(0/1) : 0 pour masque le clavier et 1 pour l'afficher<br />
* fullscreen(0/1) : 0 pour afficher la barre de menu 1 pour la masquer<br />
Pour connaitre toutes les fonctions spécifiques et leur syntaxes, regarder [http://orwell01.free.fr/Release/CPLua/functions.txt ici]<br />
<br />
==Lien utiles==<br />
* [http://www.lua.org/ Site officiel du Lua]<br />
* [http://calc-casio.e-monsite.com/pages/librairie/cplua/ Librairies supplémentaires]<br />
* [http://orwell01.free.fr/Release/CPLua/functions.txt Liste des fonctions spécifiques]<br />
<br />
[[en:CPLua]]<br />
[[Catégorie:Lua]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPLua&diff=1022CPLua2014-05-20T09:23:32Z<p>Cartix : </p>
<hr />
<div>{{InfoBox Software<br />
| nom = CPLua <br />
| logo = cpluaicon.png<br />
| logoCaption = icon <br />
| auteur = Orwell<br />
| langage de programmation = Lua<br />
| genre = IDE<br />
| plateforme = Classpad<br />
}}<br />
Le langage Lua est un juste milieu entre le CPBasic et le C/C+/Asm. Ce langage de programmation est simple, flexible et rapide. Il permet aux développeurs de créer des programmes complexes impossibles à écrire en CPBasic.<br />
<br />
CPLua est un add-in pour ClassPad qui inclut un interpréteur Lua et propose beaucoup de nouvelles fonctions, en plus de la programmation on-calc. <br /><br />
CPLua est un projet donc quelques bugs peuvent apparaître. La version la plus stable est actuellement la version 0.8. La dernière version est la version 0.10A.<br />
<br />
==Histoire== <br />
CPLua a été commencé en 2005 par Julien, un programmeur français, parce qu'il y avait trop de personnes qui se plaignaient de la lenteur du CPBasic mais ne voulaient pas apprendre le C++.<br />
* 01/09/2005 : la première version a été publiée [http://casiocalto.free.fr/Forum/viewtopic.php?t=611 ici].<br />
* 07/09/2005 : version 0.4 : ajout de la possibilité sauver/ouvrir des script Lua<br />
* 08-09/2005 : version 0.51 : correction de certains bugs et ajout d'un nouveau clavier<br />
* 27/09/2005 : version 0.72 : ajout de la totalité du paquet de CAS<br />
* 19/04/2006 : version 0.8 : version la plus rapide (en dessin) de CPLua. Téléchargez-la [http://www.casio-scene.com/downloads.php?do=file&id=532 ici]<br />
* 07-27-2007 : version 0.9E : la dernière version faite par Orwell (ajout de la bibliothèque UI)<br />
L'année dernière, deux programmeur, [http://www.casio-scene.com/member.php?10077-Cartix Cartix] (moi) et [http://www.planet-casio.com/Fr/compte/voir_profil.php?membre=binary_man Binary_Man], de Planete Casio, ont commencé à retravailler sur le projet, dans le but d'ajouter de nouvelles fonctions. Notre première version (CPLua 0.10A) est sortie le 28/01/2012, et est disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici]<br />
<br />
==Mise en route==<br />
* Premièrement, télécharger la version de l'add-in que vous souhaitez :[http://www.casio-scene.com/downloads.php?do=file&id=532 CPLua 0.8] ou [http://www.casio-scene.com/downloads.php?do=file&id=533 CPLua 0.10A]<br />
* Envoyez ensuite le .cpa à votre classpad avec FA-CP1 ou Classpad Add-In Installer (des tutos seront bientôt disponible)<br />
* Allez au menu principal sur votre Classpad et ouvrez l'application CPLua<br />
* Créez un nouveau fichier et commencez à programmer<br />
<br />
==Librairie== <br />
* UI : Interface utilisateurs : Cette librairie vous permet d'utiliser l'interface utilisateur du Classpad (menu, barre d'outils,…) dans vos programmes<br />
* CAS : Système d'Aglèbre informatique : Cette librairie vous permets d'employer toutes les fonctions mathématiques de l'application "Main" (diff, intg, solve, …)<br />
* Draw : Cette librairie vous permet de dessiner sur l'écran (point, ligne, cercle,…) et pour employer des sprites/images<br />
* IO : Entrée-sortie : Cette librairie vous permet de manipuler les fichiers de votre Classpad (ouvrir, enregistrer, lire,…)<br />
* String : Cette librairie vous permet de manipuler les chaines de caractères<br />
* Debug : Cette librairie vous permet de corriger votre programme<br />
* Table : Cette librairie vous permet de manipuler des listes<br />
* Math : Cette librairie vous permet d'effectuer des opérations sur des nombres (sin, log,…)<br />
Pour connaître toutes les fonctions d'une librairie, "table.foreach (<name du library>, de la copie)"<br />
<br />
==Structures de Controle==<br />
===BOUCLES===<br />
* Vous pouvez casser une boucle avec "break"<br />
====While====<br />
<pre><br />
while <condition 1> do<br />
<code à exécuter tant que la condition 1 est respectée><br />
end<br />
</pre><br />
<br />
====Repeat====<br />
<pre><br />
repeat<br />
<code à exécuter tant que la condition 1 est respectée><br />
until <condition 1><br />
</pre><br />
<br />
====For====<br />
<pre><br />
for <var>=<min>,<max>[,incrément] do<br />
<code à exécuter tant que var est différent de max ><br />
end<br />
</pre><br />
* Si l'incrément n'est pas spécifié, il vaudra automatiquement 1<br />
<br />
===IF===<br />
<pre><br />
if <condition 1> then<br />
<code à exécuter si la condition 1 est respectée><br />
elseif <condition 2> then<br />
<code à exécuter si la condition 1 est respectée et la condition 1 est respectée><br />
else<br />
<code à exécuter si aucune des conditions n'est respéctée><br />
end<br />
</pre><br />
<br />
===Déclaration d'une fonction===<br />
<pre><br />
function <nom de la fonction>(<liste des paramètres>)<br />
<code à exécuter si la fonction est appelée><br />
return <valeur à retourner><br />
end<br />
</pre><br />
* Si la valeur à retourner n'est pas spécifiée, la fonction ne renverra rien<br />
* Si aucun paramètre n'est spécifié, la fonction fonctionnera sans paramètre<br />
* On peut déclarer des variables locales dans les fonctions, utilisable uniquement par la fonction dans laquelle elles ont étés déclarées<br />
<br />
===Comentaires===<br />
<pre><br />
--<commentaire> pour un commentaire d'une ligne<br />
--[[<commentaire>]]-- pour un commentaire de plusieurs lignes<br />
</pre><br />
<br />
==Fonctions spécifiques à CPLua==<br />
CPLua a deux écran différents : la console (pour les entrées/sorties) et l'écran graphique (pour dessiner). Par défaut, un programme affiche la console. On peut passer de l'un à l'autre à l'aide de<br />
* showconsole() pour afficher la console<br />
* showgraph() pour afficher l'écran graphique<br />
Il y a de nombreuse autres fonctions spécifiques telles que :<br />
* keypad(0/1) : 0 pour masque le clavier et 1 pour l'afficher<br />
* fullscreen(0/1) : 0 pour afficher la barre de menu 1 pour la masquer<br />
Pour connaitre toutes les fonctions spécifiques et leur syntaxes, regarder [http://orwell01.free.fr/Release/CPLua/functions.txt ici]<br />
<br />
==Lien utiles==<br />
* [http://www.lua.org/ Site officiel du Lua]<br />
* [http://calc-casio.e-monsite.com/pages/librairie/cplua/ Librairies supplémentaires]<br />
* [http://orwell01.free.fr/Release/CPLua/functions.txt Liste des fonctions spécifiques]<br />
<br />
[[en:CPLua]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Fichier:Cpluaicon.png&diff=1021Fichier:Cpluaicon.png2014-05-20T09:21:08Z<p>Cartix : </p>
<hr />
<div></div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPSDK&diff=1020CPSDK2014-05-20T09:07:37Z<p>Cartix : /* L'Assembleur (Asm) */</p>
<hr />
<div>{{MsgBox|title=Important|text=Le ClassPad SDK n'est officiellement pas supporté par Casio qui ne répondra donc pas aux questions posées à ce sujet.|theme=rouge}}<br />
<br /><br />
{{InfoBox Software<br />
| nom=CPSDK<br />
| logo=devcpp.png<br />
| Auteur=Saltire<br />
| language=Anglais<br />
| langage de programmation=[[C (langage)|C]], [[C++]]<br />
}}<br />
Ce logiciel (Software Development Kit) est un module de Dev-C++ vous permettant de programmer des add-ins pour votre Classpad. <br />
Saltire, qui a développé le cœur mathématique de la Graph100, a aussi développé le système d'exploitation de la Classpad 300 basé sur une API graphique propriétaire.<br />
<br />
Ils ont donc fourni avec l'accord de Casio un Environnement de Développement Intégré basé sur Dev-C++, le compilateur SH et des outils propriétaires.<br />
<br />
Ainsi, il est possible de développer des applications utilisant l'API de la calculatrice pour faire des jeux, dessiner, utiliser le cœur mathématique, gérer les fichiers...<br />
<br />
Actuellement, le SDK n'est fonctionnel que pour les CP300(+) et CP330. En effet, le format d'add-in des CP330+ étant différent, les add-ins actuels sont incompatibles. De plus, il semblerait que Casio n'est pas décidé à combler ce manque.<br />
<br />
<br />
== Interface de développement ==<br />
<br />
Le CPSDK se présente comme un plug-in à ajouter à Dev-C++. Ceci permet d'utiliser l'interface de ce logiciel pour programmer.<br />
<br />
== Langages de programmation disponibles ==<br />
<br />
Les Add-Ins (ou Applications Ajoutées) sont des programmes qui apparaissent dans le menu principal. Ces programmes sont bien plus rapides que ceux écrits en Basic. Ils sont programmables en deux langages :<br />
<br />
=== Le C++ ===<br />
<br />
Il permet de mettre en place des fenêtres, une interface, des menus, exactement comme dans les applications intégrées.<br />
Le C++ est plus complexe que le CPBasic, et donc plus difficile à apprendre. Cependant, étant un langage de haut-niveau, il reste compréhensible par un programmeur habitué<br />
<br />
Le C++ étant un langage compilé, l'add-in doit être programmé à partir d'un ordinateur, compilé, puis envoyé vers la ClassPad.<br />
<br />
Vous trouverez plus bas divers liens utiles pour vous entraîner. Vous pouvez également consulter les nombreuses sources disponibles sur CasioFan.<br />
<br />
=== L'Assembleur (Asm) ===<br />
<br />
Le langage Assembleur utilisé par le ClassPad est l'assembleur SH-3, de par le type de processeur dont elle est équipée. L'assembleur est le langage le plus proche du "langage machine" ; c'est son principal avantage (il est alors plus rapide que le C++) mais c'est aussi son principal inconvénient car cela le rend (très) peu lisible et peu maniable : réaliser un programme complet avec demande énormément d'efforts et d'expérience. On utilise plus souvent l'assembleur pour faire des fonctions qu'on exporte ensuite dans un programme C++, notamment lorsque certains traitements nécessitent une grande vitesse d'exécution (opération de rafraichissement d'écran, etc).<br />
<br />
Programmer en Assembleur est réservé aux développeurs chevronnés. Ce langage ne permet de faire que ce que le processeur sait faire : lire/écrire dans la mémoire, et effectuer des opérations très simples sur ses registres. Ainsi, si on souhaite simplement afficher un pixel à l'écran, il faut connaître l'adresse de l'écran et sa structure dans la mémoire, puis "écrire" à cette adresse au bon endroit (sans altérer l'état des pixels voisins). C'est pourquoi ce langage peut s'avérer dangereux : on a la possibilité de faire tout et n'importe quoi avec la mémoire, une mauvaise manipulation peut avoir de graves conséquences comme "bloquer" la machine et ce de manière irréversible. Au cas où vous voudriez tenter votre chance, consultez la documentation Hitachi, et effectuez vos tests sur le ClassPad Manager.<br />
<br />
== Alternative à Dev-C++ ==<br />
<br />
* Il semblerait qu'il existe un plug-in Casio pour MS Visual Studio. Malheureusement, celui-ci reste, à l'heure actuelle, introuvable. Il a probablement disparu avec la chute de cpsdk.com<br />
* Le 01/04/2013, MicroPro, un programmeur de l'UCF, a annoncé avoir commencé à développer un IDE Visuel, dans le style de Visual Studio. Malheureusement, nous n'avons plus de nouvelles de ce projet depuis longtemps. La date de l'annonce laisse également supposer qu'il s'agissait d'une blague. Pour plus d'informations, voir [[http://community.casiocalc.org/topic/7122-program-in-a-visual-basic-ide-for-classpad/ ici]]<br />
<br />
== Liens utiles ==<br />
<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-guide.pdf CPSDK Programming Guide]<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-tutorial.pdf CPSDK Programming Tutorial]<br />
* [http://casiocalto.free.fr/Forum/viewtopic.php?t=474 Tuto sur CasioCalto]<br />
* [http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html Tuto C++ sur le Site Du Zéro]<br />
* [http://documentation.renesas.com/eng/products/mpumcu/rej09b0317_sh_3sm.pdf Documentation SH3]<br />
<br />
[[Catégorie:C/C++/Asm]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPSDK&diff=1019CPSDK2014-05-20T09:07:17Z<p>Cartix : /* Le C++ */</p>
<hr />
<div>{{MsgBox|title=Important|text=Le ClassPad SDK n'est officiellement pas supporté par Casio qui ne répondra donc pas aux questions posées à ce sujet.|theme=rouge}}<br />
<br /><br />
{{InfoBox Software<br />
| nom=CPSDK<br />
| logo=devcpp.png<br />
| Auteur=Saltire<br />
| language=Anglais<br />
| langage de programmation=[[C (langage)|C]], [[C++]]<br />
}}<br />
Ce logiciel (Software Development Kit) est un module de Dev-C++ vous permettant de programmer des add-ins pour votre Classpad. <br />
Saltire, qui a développé le cœur mathématique de la Graph100, a aussi développé le système d'exploitation de la Classpad 300 basé sur une API graphique propriétaire.<br />
<br />
Ils ont donc fourni avec l'accord de Casio un Environnement de Développement Intégré basé sur Dev-C++, le compilateur SH et des outils propriétaires.<br />
<br />
Ainsi, il est possible de développer des applications utilisant l'API de la calculatrice pour faire des jeux, dessiner, utiliser le cœur mathématique, gérer les fichiers...<br />
<br />
Actuellement, le SDK n'est fonctionnel que pour les CP300(+) et CP330. En effet, le format d'add-in des CP330+ étant différent, les add-ins actuels sont incompatibles. De plus, il semblerait que Casio n'est pas décidé à combler ce manque.<br />
<br />
<br />
== Interface de développement ==<br />
<br />
Le CPSDK se présente comme un plug-in à ajouter à Dev-C++. Ceci permet d'utiliser l'interface de ce logiciel pour programmer.<br />
<br />
== Langages de programmation disponibles ==<br />
<br />
Les Add-Ins (ou Applications Ajoutées) sont des programmes qui apparaissent dans le menu principal. Ces programmes sont bien plus rapides que ceux écrits en Basic. Ils sont programmables en deux langages :<br />
<br />
=== Le C++ ===<br />
<br />
Il permet de mettre en place des fenêtres, une interface, des menus, exactement comme dans les applications intégrées.<br />
Le C++ est plus complexe que le CPBasic, et donc plus difficile à apprendre. Cependant, étant un langage de haut-niveau, il reste compréhensible par un programmeur habitué<br />
<br />
Le C++ étant un langage compilé, l'add-in doit être programmé à partir d'un ordinateur, compilé, puis envoyé vers la ClassPad.<br />
<br />
Vous trouverez plus bas divers liens utiles pour vous entraîner. Vous pouvez également consulter les nombreuses sources disponibles sur CasioFan.<br />
<br />
=== L'Assembleur (Asm) ===<br />
<br />
Le langage Assembleur utilisé par le ClassPad est l'assembleur SH-3, de par le type de processeur dont elle est équipée. L'assembleur est le langage le plus proche du "langage machine" ; c'est son principal avantage (il est alors plus rapide que le C++) mais c'est aussi son principal inconvénient car cela le rend (très) peu lisible et peu maniable : réaliser un programme complet avec demande énormément d'efforts et d'expérience. On utilise plus souvent l'assembleur pour faire des fonctions qu'on exporte ensuite dans un programme C++, notamment lorsque certains traitements nécessitent une grande vitesse d'exécution (opération de rafraichissement d'écran, etc).<br />
Programmer en Assembleur est réservé aux développeurs chevronnés. Ce langage ne permet de faire que ce que le processeur sait faire : lire/écrire dans la mémoire, et effectuer des opérations très simples sur ses registres. Ainsi, si on souhaite simplement afficher un pixel à l'écran, il faut connaître l'adresse de l'écran et sa structure dans la mémoire, puis "écrire" à cette adresse au bon endroit (sans altérer l'état des pixels voisins). C'est pourquoi ce langage peut s'avérer dangereux : on a la possibilité de faire tout et n'importe quoi avec la mémoire, une mauvaise manipulation peut avoir de graves conséquences comme "bloquer" la machine et ce de manière irréversible. Au cas où vous voudriez tenter votre chance, consultez la documentation Hitachi, et effectuez vos tests sur le ClassPad Manager.<br />
<br />
== Alternative à Dev-C++ ==<br />
<br />
* Il semblerait qu'il existe un plug-in Casio pour MS Visual Studio. Malheureusement, celui-ci reste, à l'heure actuelle, introuvable. Il a probablement disparu avec la chute de cpsdk.com<br />
* Le 01/04/2013, MicroPro, un programmeur de l'UCF, a annoncé avoir commencé à développer un IDE Visuel, dans le style de Visual Studio. Malheureusement, nous n'avons plus de nouvelles de ce projet depuis longtemps. La date de l'annonce laisse également supposer qu'il s'agissait d'une blague. Pour plus d'informations, voir [[http://community.casiocalc.org/topic/7122-program-in-a-visual-basic-ide-for-classpad/ ici]]<br />
<br />
== Liens utiles ==<br />
<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-guide.pdf CPSDK Programming Guide]<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-tutorial.pdf CPSDK Programming Tutorial]<br />
* [http://casiocalto.free.fr/Forum/viewtopic.php?t=474 Tuto sur CasioCalto]<br />
* [http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html Tuto C++ sur le Site Du Zéro]<br />
* [http://documentation.renesas.com/eng/products/mpumcu/rej09b0317_sh_3sm.pdf Documentation SH3]<br />
<br />
[[Catégorie:C/C++/Asm]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPSDK&diff=1018CPSDK2014-05-20T09:07:07Z<p>Cartix : /* Le C++ */</p>
<hr />
<div>{{MsgBox|title=Important|text=Le ClassPad SDK n'est officiellement pas supporté par Casio qui ne répondra donc pas aux questions posées à ce sujet.|theme=rouge}}<br />
<br /><br />
{{InfoBox Software<br />
| nom=CPSDK<br />
| logo=devcpp.png<br />
| Auteur=Saltire<br />
| language=Anglais<br />
| langage de programmation=[[C (langage)|C]], [[C++]]<br />
}}<br />
Ce logiciel (Software Development Kit) est un module de Dev-C++ vous permettant de programmer des add-ins pour votre Classpad. <br />
Saltire, qui a développé le cœur mathématique de la Graph100, a aussi développé le système d'exploitation de la Classpad 300 basé sur une API graphique propriétaire.<br />
<br />
Ils ont donc fourni avec l'accord de Casio un Environnement de Développement Intégré basé sur Dev-C++, le compilateur SH et des outils propriétaires.<br />
<br />
Ainsi, il est possible de développer des applications utilisant l'API de la calculatrice pour faire des jeux, dessiner, utiliser le cœur mathématique, gérer les fichiers...<br />
<br />
Actuellement, le SDK n'est fonctionnel que pour les CP300(+) et CP330. En effet, le format d'add-in des CP330+ étant différent, les add-ins actuels sont incompatibles. De plus, il semblerait que Casio n'est pas décidé à combler ce manque.<br />
<br />
<br />
== Interface de développement ==<br />
<br />
Le CPSDK se présente comme un plug-in à ajouter à Dev-C++. Ceci permet d'utiliser l'interface de ce logiciel pour programmer.<br />
<br />
== Langages de programmation disponibles ==<br />
<br />
Les Add-Ins (ou Applications Ajoutées) sont des programmes qui apparaissent dans le menu principal. Ces programmes sont bien plus rapides que ceux écrits en Basic. Ils sont programmables en deux langages :<br />
<br />
=== Le C++ ===<br />
<br />
Il permet de mettre en place des fenêtres, une interface, des menus, exactement comme dans les applications intégrées.<br />
Le C++ est plus complexe que le CPBasic, et donc plus difficile à apprendre. Cependant, étant un langage de haut-niveau, il reste compréhensible par un programmeur habitué<br />
<br />
Le C++ étant un langage compilé, l'add-in doit être programmé à partir d'un ordinateur, compilé, puis envoyé vers la ClassPad.<br />
<br />
<br />
Vous trouverez plus bas divers liens utiles pour vous entraîner. Vous pouvez également consulter les nombreuses sources disponibles sur CasioFan.<br />
<br />
=== L'Assembleur (Asm) ===<br />
<br />
Le langage Assembleur utilisé par le ClassPad est l'assembleur SH-3, de par le type de processeur dont elle est équipée. L'assembleur est le langage le plus proche du "langage machine" ; c'est son principal avantage (il est alors plus rapide que le C++) mais c'est aussi son principal inconvénient car cela le rend (très) peu lisible et peu maniable : réaliser un programme complet avec demande énormément d'efforts et d'expérience. On utilise plus souvent l'assembleur pour faire des fonctions qu'on exporte ensuite dans un programme C++, notamment lorsque certains traitements nécessitent une grande vitesse d'exécution (opération de rafraichissement d'écran, etc).<br />
Programmer en Assembleur est réservé aux développeurs chevronnés. Ce langage ne permet de faire que ce que le processeur sait faire : lire/écrire dans la mémoire, et effectuer des opérations très simples sur ses registres. Ainsi, si on souhaite simplement afficher un pixel à l'écran, il faut connaître l'adresse de l'écran et sa structure dans la mémoire, puis "écrire" à cette adresse au bon endroit (sans altérer l'état des pixels voisins). C'est pourquoi ce langage peut s'avérer dangereux : on a la possibilité de faire tout et n'importe quoi avec la mémoire, une mauvaise manipulation peut avoir de graves conséquences comme "bloquer" la machine et ce de manière irréversible. Au cas où vous voudriez tenter votre chance, consultez la documentation Hitachi, et effectuez vos tests sur le ClassPad Manager.<br />
<br />
== Alternative à Dev-C++ ==<br />
<br />
* Il semblerait qu'il existe un plug-in Casio pour MS Visual Studio. Malheureusement, celui-ci reste, à l'heure actuelle, introuvable. Il a probablement disparu avec la chute de cpsdk.com<br />
* Le 01/04/2013, MicroPro, un programmeur de l'UCF, a annoncé avoir commencé à développer un IDE Visuel, dans le style de Visual Studio. Malheureusement, nous n'avons plus de nouvelles de ce projet depuis longtemps. La date de l'annonce laisse également supposer qu'il s'agissait d'une blague. Pour plus d'informations, voir [[http://community.casiocalc.org/topic/7122-program-in-a-visual-basic-ide-for-classpad/ ici]]<br />
<br />
== Liens utiles ==<br />
<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-guide.pdf CPSDK Programming Guide]<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-tutorial.pdf CPSDK Programming Tutorial]<br />
* [http://casiocalto.free.fr/Forum/viewtopic.php?t=474 Tuto sur CasioCalto]<br />
* [http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html Tuto C++ sur le Site Du Zéro]<br />
* [http://documentation.renesas.com/eng/products/mpumcu/rej09b0317_sh_3sm.pdf Documentation SH3]<br />
<br />
[[Catégorie:C/C++/Asm]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPSDK&diff=1017CPSDK2014-05-20T09:04:03Z<p>Cartix : </p>
<hr />
<div>{{MsgBox|title=Important|text=Le ClassPad SDK n'est officiellement pas supporté par Casio qui ne répondra donc pas aux questions posées à ce sujet.|theme=rouge}}<br />
<br /><br />
{{InfoBox Software<br />
| nom=CPSDK<br />
| logo=devcpp.png<br />
| Auteur=Saltire<br />
| language=Anglais<br />
| langage de programmation=[[C (langage)|C]], [[C++]]<br />
}}<br />
Ce logiciel (Software Development Kit) est un module de Dev-C++ vous permettant de programmer des add-ins pour votre Classpad. <br />
Saltire, qui a développé le cœur mathématique de la Graph100, a aussi développé le système d'exploitation de la Classpad 300 basé sur une API graphique propriétaire.<br />
<br />
Ils ont donc fourni avec l'accord de Casio un Environnement de Développement Intégré basé sur Dev-C++, le compilateur SH et des outils propriétaires.<br />
<br />
Ainsi, il est possible de développer des applications utilisant l'API de la calculatrice pour faire des jeux, dessiner, utiliser le cœur mathématique, gérer les fichiers...<br />
<br />
Actuellement, le SDK n'est fonctionnel que pour les CP300(+) et CP330. En effet, le format d'add-in des CP330+ étant différent, les add-ins actuels sont incompatibles. De plus, il semblerait que Casio n'est pas décidé à combler ce manque.<br />
<br />
<br />
== Interface de développement ==<br />
<br />
Le CPSDK se présente comme un plug-in à ajouter à Dev-C++. Ceci permet d'utiliser l'interface de ce logiciel pour programmer.<br />
<br />
== Langages de programmation disponibles ==<br />
<br />
Les Add-Ins (ou Applications Ajoutées) sont des programmes qui apparaissent dans le menu principal. Ces programmes sont bien plus rapides que ceux écrits en Basic. Ils sont programmables en deux langages :<br />
<br />
=== Le C++ ===<br />
<br />
Il permet de mettre en place des fenêtres, une interface, des menus, exactement comme dans les applications intégrées.<br />
Le C++ est plus complexe que le CPBasic, et donc plus difficile à apprendre. Cependant, étant un langage de haut-niveau, il reste compréhensible par un programmeur habitué<br />
<br />
Le C++ étant un langage compilé, l'add-in doit être programmé à partir d'un ordinateur, compilé, puis envoyé vers la ClassPad. Le logiciel utilisé pour écrire de tels programmes est le ClassPad SDK téléchargeable sur le site officiel.<br />
Vous trouverez plus bas divers liens utiles pour vous entraîner. Vous pouvez également consulter les nombreuses sources disponibles sur CasioFan.<br />
<br />
=== L'Assembleur (Asm) ===<br />
<br />
Le langage Assembleur utilisé par le ClassPad est l'assembleur SH-3, de par le type de processeur dont elle est équipée. L'assembleur est le langage le plus proche du "langage machine" ; c'est son principal avantage (il est alors plus rapide que le C++) mais c'est aussi son principal inconvénient car cela le rend (très) peu lisible et peu maniable : réaliser un programme complet avec demande énormément d'efforts et d'expérience. On utilise plus souvent l'assembleur pour faire des fonctions qu'on exporte ensuite dans un programme C++, notamment lorsque certains traitements nécessitent une grande vitesse d'exécution (opération de rafraichissement d'écran, etc).<br />
Programmer en Assembleur est réservé aux développeurs chevronnés. Ce langage ne permet de faire que ce que le processeur sait faire : lire/écrire dans la mémoire, et effectuer des opérations très simples sur ses registres. Ainsi, si on souhaite simplement afficher un pixel à l'écran, il faut connaître l'adresse de l'écran et sa structure dans la mémoire, puis "écrire" à cette adresse au bon endroit (sans altérer l'état des pixels voisins). C'est pourquoi ce langage peut s'avérer dangereux : on a la possibilité de faire tout et n'importe quoi avec la mémoire, une mauvaise manipulation peut avoir de graves conséquences comme "bloquer" la machine et ce de manière irréversible. Au cas où vous voudriez tenter votre chance, consultez la documentation Hitachi, et effectuez vos tests sur le ClassPad Manager.<br />
<br />
== Alternative à Dev-C++ ==<br />
<br />
* Il semblerait qu'il existe un plug-in Casio pour MS Visual Studio. Malheureusement, celui-ci reste, à l'heure actuelle, introuvable. Il a probablement disparu avec la chute de cpsdk.com<br />
* Le 01/04/2013, MicroPro, un programmeur de l'UCF, a annoncé avoir commencé à développer un IDE Visuel, dans le style de Visual Studio. Malheureusement, nous n'avons plus de nouvelles de ce projet depuis longtemps. La date de l'annonce laisse également supposer qu'il s'agissait d'une blague. Pour plus d'informations, voir [[http://community.casiocalc.org/topic/7122-program-in-a-visual-basic-ide-for-classpad/ ici]]<br />
<br />
== Liens utiles ==<br />
<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-guide.pdf CPSDK Programming Guide]<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-tutorial.pdf CPSDK Programming Tutorial]<br />
* [http://casiocalto.free.fr/Forum/viewtopic.php?t=474 Tuto sur CasioCalto]<br />
* [http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html Tuto C++ sur le Site Du Zéro]<br />
* [http://documentation.renesas.com/eng/products/mpumcu/rej09b0317_sh_3sm.pdf Documentation SH3]<br />
<br />
[[Catégorie:C/C++/Asm]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=SDK&diff=1016SDK2014-05-20T09:03:20Z<p>Cartix : </p>
<hr />
<div>=== Le fx-9860G SDK ===<br />
<br />
Vous savez sûrement que Casio nous a gentiment offert un kit de développement permettant de programmer en C ou C++ sur les Graph 75/85/95 (SD). Or la documentation est en anglais, est très incomplète, et contient même des erreurs dans les fonctions de lecture et écriture des fichiers. Une partie de ce wiki est donc consacrée aux premiers pas sur le kit de développement et aux fonctions offertes par la librairie "fxlib" de la calculatrice.<br />
<br />
Vous aurez besoin de connaître les bases du C ou du C++. Pour cela, vous pouvez aller découvrir différents tutoriels. Vous êtes un débutant complet et vous voulez des explications ludiques pour avaler les heures d'apprentissage plus facilement ? Le [http://www.siteduzero.com/tutoriel-3-14189-apprenez-a-programmer-en-c.html tutoriel d'Open Classrooms] est pour vous. Vous voulez des explications plus professionnelles provenant d'une source sûre ? Allez plutôt voir [http://melem.developpez.com/tutoriels/langage-c/initiation-langage-c ce cours] pour vous initier au langage C.<br /><br />
Pour la présentation générale et les premiers pas : [[Fx-9860G SDK|fx-9860G SDK]]<br />
<br />
Puisque la calculatrice ne fonctionne pas exactement comme un ordinateur, de nombreuses fonctions du C standard ne sont pas supportées par le SDK. En revanche, Casio nous a concocté une bibliothèque adaptée au développement sur calculatrices qu'elle a nommé ''fxlib'' (pour FX library). Cette bibliothèque contient toutes les fonctions propres à la calculatrice qui vous seront necéssaires pour le développement de vos programmes. Entre autres, tout ce qui touche à l'affichage à l'écran, réception d'évènements ou manipulation des fichiers du système.<br />
<br />
Pour une présentation des fonctions de la bibliothèque fournie par Casio : [[Fxlib.h|fxlib]]<br />
<br />
<br />
=== Le Prizm SDK ===<br />
<br />
Casio n'a pas fourni de SDK pour aller avec la [[Fx-CG_20|Prizm]]. Un logiciel communautaire a donc été réalisé pour permettre le développement C sur cette calculatrice. Il est compatible avec Windows et Linux, contrairement au précédent.<br />
<br />
Pour plus d'informations : [[PrizmSDK|Prizm SDK]]<br />
<br />
=== Le CPSDK ===<br />
Casio a partagé un plug-in de Dev-C++, développé par Saltire, permettant de créer des add-in pour Classpad. Ceux-ci ne sont malheureusement compatibles qu'avec les anciens modèles (CP300(+) et CP330), et il semblerait que Casio n'ait pas l'intention de combler ce manque.<br />
<br />
Pour plus d'information : [[CPSDK]]<br />
[[en:SDK]]<br />
[[Catégorie:C/C++/Asm]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPSDK&diff=1012CPSDK2014-05-19T16:13:57Z<p>Cartix : </p>
<hr />
<div><pre style="color: red">Important : Le ClassPad SDK n'est officiellement pas supporté par Casio. Casio ne répondra pas aux questions posées à ce sujet</pre><br />
{{InfoBox Software<br />
| nom=CPSDK<br />
| logo=devcpp.png<br />
| Auteur=Saltire<br />
| language=Anglais<br />
| langage de programmation=[[C (langage)|C]], [[C++]]<br />
}}<br />
Ce logiciel (Source Develeppoment Kit) est un add-in de Dev-C++ vous permettant de programmer des add-in pour votre Classpad. <br />
Saltire, qui a développé le cœur mathématique de la Graph100, a aussi développé le système d'exploitation de la Classpad 300 basé sur une API graphique propriétaire.<br />
<br />
Ils ont donc fourni avec l'accord de Casio un Environnement de Développement à base de DevC++, le compilateur SH et des outils propriétaires.<br />
<br />
Ainsi, il est possible de développer des applications utilisant l'API de la calculatrice pour faire des jeux, dessiner, utiliser le cœur mathématique, gérer les fichiers...<br />
<br />
Actuellement, le SDK n'est fonctionnel que pour les CP300(+) et CP330. En effet, le format d'add-in des CP330+ étant différent, les add-ins actuels sont incompatibles. De plus, il semblerait que Casio n'est pas décidé à combler ce manque.<br />
<br />
==Interface de dévelloppement==<br />
Le CPSDK se présente comme un plug-in à ajouter à Dev-C++. Ceci permet d'utiliser l'interface de ce logiciel pour programmer.<br />
<br />
==Langages de programmation disponibles==<br />
Les Add-Ins (ou Applications Ajoutées) sont des programmes qui apparaissent dans le menu principal. Ces programmes sont bien plus rapides que ceux écrits en Basic. Ils sont programmables en deux langages :<br />
===Le C++===<br />
Il permet de mettre en place des fenêtres, une interface, des menus, exactement comme dans les applications intégrées.<br />
Le C++ est plus complexe que le CPBasic, et donc plus difficile à apprendre. Cependant, étant un langage de haut-niveau, il reste compréhensible par un programmeur habitué<br />
<br />
Le C++ étant un langage compilé, l'Add-In doit être programmé à partir d'un ordinateur, converti, puis envoyé vers le ClassPad. Le logiciel utilisé pour écrire de tels programmes est le ClassPad SDK téléchargeable sur le site officiel.<br />
Vous trouverez plus bas divers liens utiles pour vous entraîner. Vous pouvez également consulter les nombreuses sources disponibles sur CasioFan<br />
<br />
===L'Assembleur (ASM)===<br />
Le langage assembleur utilisé par le ClassPad est l'assembleur SH-3, de par le type de processeur dont elle est équipée. L'assembleur est le langage le plus proche du "langage machine"; c'est son principal avantage (il est alors plus rapide que le C++) mais c'est aussi son principal inconvénient car cela le rend (très) peu lisible et peu maniable : réaliser un programme complet avec demande énormément d'efforts et d'expérience. On utilise plus souvent l'assembleur pour faire des fonctions qu'on exporte ensuite dans un programme C++, notamment lorsque certains traitements nécessitent une grande vitesse d'exécution (opération de rafraichissement d'écran etc).<br />
Programmer en assembleur est réservé aux développeurs chevronnés. Ce langage ne permet de faire que ce que le processeur sait faire : lire/écrire dans la mémoire, et effectuer des opérations très simples sur ses registres. Ainsi, si on souhaite simplement afficher un pixel à l'écran, il faut connaître l'adresse de l'écran et sa structure dans la mémoire, puis "écrire" à cette adresse au bon endroit (sans altérer l'état des pixels voisins). C'est pourquoi ce langage peut s'avérer dangereux : on a la possibilité de faire tout et n'importe quoi avec la mémoire, une mauvaise manipulation peut avoir de graves conséquences comme "bloquer" la machine et ce de manière irréversible. Au cas où vous voudriez tenter votre chance, consultez la documentation Hitachi, et effectuez vos tests sur le ClassPad Manager.<br />
<br />
==Alternative à Dev-C++==<br />
* Il semblerait qu'il existe un plug-in Casio pour MS Visual Studio. Malheureusement, celui-ci reste, à l'heure actuelle, introuvable. Il a probablement disparu avec la chute de cpsdk.com<br />
* Le 01/04/2013, MicroPro, un programmeur de l'UCF, a annoncé avoir commencé à develloper un IDE Visuel, dans le style de Visual Studio. Malheureusement, nous n'avons plus de nouvelles de ce projet depuis longtemps. La date de l'annonce laisse également supposer qu'il s'aggissant d'une blague. Pour plus d'information, voir [[http://community.casiocalc.org/topic/7122-program-in-a-visual-basic-ide-for-classpad/ ici]]<br />
<br />
==Liens utiles==<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-guide.pdf CPSDK Programming Guide]<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-tutorial.pdf CPSDK Programming Tutorial]<br />
* [http://casiocalto.free.fr/Forum/viewtopic.php?t=474 Tuto sur CasioCalto]<br />
* [http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html Tuto C++ sur le Site Du Zéro]<br />
* [http://documentation.renesas.com/eng/products/mpumcu/rej09b0317_sh_3sm.pdf Documentation SH3]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPSDK&diff=1011CPSDK2014-05-19T16:12:07Z<p>Cartix : </p>
<hr />
<div><pre style="color: red">Important : Le ClassPad SDK n'est officiellement pas supporté par Casio. Casio ne répondra pas aux questions posées à ce sujet</pre><br />
{{InfoBox Software<br />
| nom=CPSDK<br />
| logo=devcpp.png<br />
| Auteur=Saltire<br />
| language=Anglais<br />
| langage de programmation=[[C (langage)|C]], [[C++]]<br />
}}<br />
Ce logiciel (Source Develeppoment Kit) est un add-in de Dev-C++ vous permettant de programmer des add-in pour votre Classpad. <br />
Saltire, qui a développé le cœur mathématique de la Graph100, a aussi développé le système d'exploitation de la Classpad 300 basé sur une API graphique propriétaire.<br />
<br />
Ils ont donc fourni avec l'accord de Casio un Environnement de Développement à base de DevC++, le compilateur SH et des outils propriétaires.<br />
<br />
Ainsi, il est possible de développer des applications utilisant l'API de la calculatrice pour faire des jeux, dessiner, utiliser le cœur mathématique, gérer les fichiers...<br />
<br />
Actuellement, le SDK n'est fonctionnel que pour les CP300(+) et CP330. En effet, le format d'add-in des CP330+ étant différent, les add-ins actuels sont incompatibles. De plus, il semblerait que Casio n'est pas décidé à combler ce manque.<br />
<br />
==Interface de dévelloppement==<br />
Le CPSDK se présente comme un plug-in à ajouter à Dev-C++. Ceci permet d'utiliser l'interface de ce logiciel pour programmer.<br />
<br />
==Langages de programmation disponibles==<br />
Les Add-Ins (ou Applications Ajoutées) sont des programmes qui apparaissent dans le menu principal. Ces programmes sont bien plus rapides que ceux écrits en Basic. Ils sont programmables en deux langages :<br />
===Le C++===<br />
Il permet de mettre en place des fenêtres, une interface, des menus, exactement comme dans les applications intégrées.<br />
Le C++ est plus complexe que le CPBasic, et donc plus difficile à apprendre. Cependant, étant un langage de haut-niveau, il reste compréhensible par un programmeur habitué<br />
<br />
Le C++ étant un langage compilé, l'Add-In doit être programmé à partir d'un ordinateur, converti, puis envoyé vers le ClassPad. Le logiciel utilisé pour écrire de tels programmes est le ClassPad SDK téléchargeable sur le site officiel.<br />
Vous trouverez plus bas divers liens utiles pour vous entraîner. Vous pouvez également consulter les nombreuses sources disponibles sur CasioFan<br />
<br />
===L'Assembleur (ASM)===<br />
Le langage assembleur utilisé par le ClassPad est l'assembleur SH-3, de par le type de processeur dont elle est équipée. L'assembleur est le langage le plus proche du "langage machine"; c'est son principal avantage (il est alors plus rapide que le C++) mais c'est aussi son principal inconvénient car cela le rend (très) peu lisible et peu maniable : réaliser un programme complet avec demande énormément d'efforts et d'expérience. On utilise plus souvent l'assembleur pour faire des fonctions qu'on exporte ensuite dans un programme C++, notamment lorsque certains traitements nécessitent une grande vitesse d'exécution (opération de rafraichissement d'écran etc).<br />
Programmer en assembleur est réservé aux développeurs chevronnés. Ce langage ne permet de faire que ce que le processeur sait faire : lire/écrire dans la mémoire, et effectuer des opérations très simples sur ses registres. Ainsi, si on souhaite simplement afficher un pixel à l'écran, il faut connaître l'adresse de l'écran et sa structure dans la mémoire, puis "écrire" à cette adresse au bon endroit (sans altérer l'état des pixels voisins). C'est pourquoi ce langage peut s'avérer dangereux : on a la possibilité de faire tout et n'importe quoi avec la mémoire, une mauvaise manipulation peut avoir de graves conséquences comme "bloquer" la machine et ce de manière irréversible. Au cas où vous voudriez tenter votre chance, consultez la documentation Hitachi, et effectuez vos tests sur le ClassPad Manager.<br />
<br />
==Alternative à Dev-C++==<br />
* Il semblerait qu'il existe un plug-in Casio pour MS Visual Studio. Malheureusement, celui-ci reste, à l'heure actuelle, introuvable. Il a probablement disparu avec la chute de cpsdk.com<br />
* Le 01/04/2013, MicroPro, un programmeur de l'UCF, a annoncé avoir commencé à develloper un IDE Visuel, dans le style de Visual Studio. Malheureusement, nous n'avons plus de nouvelles de ce projet depuis longtemps. La date de l'annonce laisse également supposer qu'il s'aggissant d'une blague. Pour plus d'information, voir [[http://community.casiocalc.org/topic/7122-program-in-a-visual-basic-ide-for-classpad/ ici]]<br />
<br />
==Liens utiles==<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-guide.pdf CPSDK Programming Guide]<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-tutorial.pdf CPSDK Programming Tutorial]<br />
* [http://casiocalto.free.fr/Forum/viewtopic.php?t=474 Tuto sur CasioCalto]<br />
* [http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html Tuto C++ sur le Site Du Zéro]<br />
* [http://www.renesas.com/fmwk.jsp?cnt=Documentation.jsp&fp=/products/mpumcu/superh_family/sh7700_series/&title=Documentation&lid=6 Documentation SH3]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Casio_Classpad_300/300%2B/330/330%2B&diff=1010Casio Classpad 300/300+/330/330+2014-05-19T16:01:02Z<p>Cartix : </p>
<hr />
<div>Elle est une des rares calculatrices du marché, avec la Sharp EL-9600, à disposer d'un écran tactile.<br />
<br />
==Présentation==<br />
<br />
La calculatrice '''Classpad 300/300+/330/330+''' est la concurrente pour sa capacité de calcul de la TI Voyage 200, ainsi que de la TI-89 Titanium et dernièrement de la TI-Nspire CAS. L'atout majeur de cette calculatrice est qu'elle possède un écran tactile très utile dans toutes les manipulations graphiques. Son écran LCD est monochrome comme sur la quasi-totalité des autres calculatrices.<br />
<br />
==Fonctionnalités==<br />
<br />
On accède aux différentes fonctionnalités par un menu à icônes.<br />
<br />
Les différents modes sont : Principal (calcul), eActivity (permet la création de questionnaires ou supports de cours), statistiques, tableur (OS 3.0), graphique (dont 3D), tableaux de valeurs, géométrie, équation différentielles (OS 3.0), finances (OS 3.0), résolveur d'équations, création de présentations et programmation. À noter que l'on peut aussi accéder aux applications en ouvrant une fenêtre de l'application souhaitée directement dans le mode Principal.<br />
<br />
La '''Classpad 300''' permet, comme plusieurs autres modèles de calculatrices Casio, la saisie des expressions en ''mode 2D'', c'est-à-dire que les expressions ne sont pas entrées par une suite de caractères disposés linéairement, mais en utilisant des symboles appelés « ''symboles math 2D'' » qui ont la même représentation que les expressions mathématiques en écriture manuscrite.<br />
<br />
Cette calculatrice permet le calcul de dérivées et d'intégrales, le calcul formel et matriciel.<br />
<br />
==Historique==<br />
<br />
Pendant l'année 1996, CASIO a travaillé au projet « CAS » (Computer Algebra System). Le CAS a été utilisé pour la première fois dans la Casio CFX-9970G et ensuite dans la Casio Algebra FX 2.0. Il forma plus tard le cœur du système mathématique de la ClassPad.<br />
<br />
En 1999, avec l'aide de nombreux enseignants et amis, l'idée d'« eActivity » émergea. Qu'est-ce que l'eActivity ? Initialement, c'était une idée qui autoriserait toutes les applications d'interagir depuis une application, et d'afficher l'information sous la forme d'un manuel. Mais concrétiser cette idée n'était pas facile, CASIO avait besoin de plus d'ingénieurs.<br />
<br />
En 2000, CASIO ouvrit un nouveau bureau, le « CASIO Education Technology M.R.D. Center » à Portland, dans l'Oregon aux États-Unis. Ils recrutèrent des ingénieurs compétents en programmation sur PC et des spécialistes issus de l'enseignement. Des idées venant du monde entier étaient alors implémentées dans la ClassPad par l'équipe de R&D de Tokyo et l'équipe MRD de Portland.<br />
<br />
En 2002 CASIO termina un prototype de la ClassPad. Avant que le prototype ne soit terminé, un émulateur était utilisé pour le test. L'émulateur était si réussi que CASIO décida d'inclure l'émulateur dans le logiciel qui était développé pour le transfert de données depuis un PC. Le logiciel de transfert et l'émulateur fusionnèrent en un seul produit appelé le « ClassPad Manager » (le gestionnaire de ClassPad).<br />
<br />
En 2003, CASIO sortit finalement la ClassPad 300.<br />
<br />
En 2005, CASIO sortit la ClassPad 300 Plus. La 300 Plus est identique à la ClassPad 300, mais elle est dotée d'un nouvel écran offrant un contraste supérieur. Le nouvel écran est extrêmement lisible, même dans des conditions d'éclairement faibles. Elle dispose aussi d'une plus grande mémoire flash : 5,4 Mo au lieu de 4,5 Mo.<br />
<br />
En 2006, CASIO sortit l'OS 3.0 pour la ClassPad. L'OS 3.0 comporte en plus les transformées de Laplace, les transformées de Fourier, une application gérant les équations différentielles, des fonctions financières. Casio a également sorti l'OS 3.0pour le ClassPad Manager, la version native PC de la ClassPad.<br />
<br />
En 2006, CASIO sortit l'OS 3.01 pour la ClassPad. Disponible seulement pour les possesseurs de l'OS 3.0, l'OS 3.01 est gratuit et disponible sur https://edu.casio.com. Des logiciels supplémentaires (« Add-in ») pour les versions 3.x seront disponibles pendant la deuxième moitié de 2007.<br />
<br />
En 2007, CASIO sortit l'OS 3.02 (la version exacte est 3.02.3000) pour la ClassPad. Cette version est disponible seulement pour les possesseurs de l'OS 3.00 ou du 3.01. Il est possible de le télécharger à l'endroit signalé plus haut, mais vous devez avoir enregistré votre Classpad sur ce même site pour avoir l'autorisation de télécharger la mise à jour. Les logiciels additionnels pour l'OS 3.xx ont été retardés.<br />
<br />
En 2007, CASIO sortit la Classpad 330. La ClassPad 330 a exactement le même matériel que la ClassPad 300 Plus mis à part qu'elle possède l'OS 3.00 pré-installé. Certaines ClassPad 300 Plus sont maintenant vendues avec un CD-ROM contenant l'OS 3.00, pour effectuer soi-même une mise à jour de la version pré-installée 2.20 à 3.00 et produire soi-même une 330.<br />
<br />
En 2008, CASIO sortit l'OS 3.03 (la version exacte est 3.03.3000) pour la ClassPad. de même que pour les autres versions 3.** cet OS peut être téléchargé sur le site signalé plus haut (toujours avec la nécessité d'être enregistré).<br />
<br />
En 2009, CASIO sortit l'OS 3.04 pour la ClassPad. L'OS 3.04 (initialement 3.04.3000) comportait une mise à jour du tableur, des améliorations dans les fonctions de statistiques et dans l'interface utilisateur. Plus tard, Casio sortit l'OS 3.04.4000 qui corrigeait des anomalies découvertes dans l'OS 3.04.3000.<br />
<br />
En 2010, CASIO sortit l'OS 3.05 pour la ClassPad. Cet OS ajoute de nouvelles fonctions financières ansi que des options pour le calcul des quartiles.<br />
<br />
En 2011, CASIO a proposé l'OS 3.06 pour la ClassPad. OS 3.06 propose de nouvelles fonctions sur les imaginaires et un solveur numérique amélioré. Jusqu'ici la dernière version est OS 3.06.1000.<br />
<br />
==Environnement de Développement==<br />
<br />
* Article détaillé : [[CPSDK]]<br />
<br />
==Spécifications==<br />
===Caractéristiques Physiques===<br />
* Épaisseur : 21 mm<br />
* Largeur : 84 mm<br />
* Hauteur : 185,5 mm<br />
* Poids (avec piles) : 280 g<br />
* Alimentation : 4 piles AAA (ou LR03)<br />
<br />
===Capacité de calcul===<br />
* Plage de calcul : de ± 1 × 10<sup>-999</sup> à ± 9,999999999 × 10<sup>999</sup><br />
<br />
==Liens externes==<br />
<br />
* [http://www.casio-scene.com/downloads.php?do=cat&id=41 Site de téléchargement de programmes pour la ClassPad]<br><br />
* [http://www.casiocalc.org/to/fsdisplay.php?cat2disp=FS.Classpad.addins.utilities Site alternatif]<br><br />
* Fiches pédagogiques sur la ClassPad300 à télécharger, par le [http://math.univ-lyon1.fr/irem/spip.php?rubrique6 groupe 36x36 de l'Institut de recherche sur l'enseignement des mathématiques de Lyon]<br />
<br />
{{Méta palette calculatrice}}<br />
[[Catégorie:Calculatrices Casio]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPSDK&diff=1009CPSDK2014-05-19T15:50:21Z<p>Cartix : Page créée avec « <pre style="color: red">Important : Le ClassPad SDK n'est officiellement pas supporté par Casio. Casio ne répondra pas aux questions posées à ce sujet</pre> {{InfoBox ... »</p>
<hr />
<div><pre style="color: red">Important : Le ClassPad SDK n'est officiellement pas supporté par Casio. Casio ne répondra pas aux questions posées à ce sujet</pre><br />
{{InfoBox Software<br />
| nom=CPSDK<br />
| logo=devcpp.png<br />
| Auteur=Saltire<br />
| language=Anglais<br />
| langage de programmation=[[C (langage)|C]], [[C++]]<br />
}}<br />
Ce logiciel (Source Develeppoment Kit) est un add-in de Dev-C++ vous permettant de programmer des add-in pour votre classpad. Celui-ci a, pour le première fois, été développé par Saltire, un groupe indépendant de Casio.<br />
Actuellement, le SDK n'est fonctionnel que pour les CP300(+) et CP330. En effet, le format d'add-in des CP330+ étant différent, les add-ins actuels sont incompatibles. De plus, il semblerait que Casio n'est pas décidé à combler ce manque.<br />
<br />
==Interface de dévelloppement==<br />
Le CPSDK se présente comme un plug-in à ajouter à Dev-C++. Ceci permet d'utiliser l'interface de ce logiciel pour programmer.<br />
<br />
==Langages de programmation disponibles==<br />
Les Add-Ins (ou Applications Ajoutées) sont des programmes qui apparaissent dans le menu principal. Ces programmes sont bien plus rapides que ceux écrits en Basic. Ils sont programmables en deux langages :<br />
===Le C++===<br />
Il permet de mettre en place des fenêtres, une interface, des menus, exactement comme dans les applications intégrées.<br />
Le C++ est plus complexe que le CPBasic, et donc plus difficile à apprendre. Cependant, étant un langage de haut-niveau, il reste compréhensible par un programmeur habitué<br />
<br />
Le C++ étant un langage compilé, l'Add-In doit être programmé à partir d'un ordinateur, converti, puis envoyé vers le ClassPad. Le logiciel utilisé pour écrire de tels programmes est le ClassPad SDK téléchargeable sur le site officiel.<br />
Vous trouverez plus bas divers liens utiles pour vous entraîner. Vous pouvez également consulter les nombreuses sources disponibles sur CasioFan<br />
<br />
===L'Assembleur (ASM)===<br />
Le langage assembleur utilisé par le ClassPad est l'assembleur SH-3, de par le type de processeur dont elle est équipée. L'assembleur est le langage le plus proche du "langage machine"; c'est son principal avantage (il est alors plus rapide que le C++) mais c'est aussi son principal inconvénient car cela le rend (très) peu lisible et peu maniable : réaliser un programme complet avec demande énormément d'efforts et d'expérience. On utilise plus souvent l'assembleur pour faire des fonctions qu'on exporte ensuite dans un programme C++, notamment lorsque certains traitements nécessitent une grande vitesse d'exécution (opération de rafraichissement d'écran etc).<br />
Programmer en assembleur est réservé aux développeurs chevronnés. Ce langage ne permet de faire que ce que le processeur sait faire : lire/écrire dans la mémoire, et effectuer des opérations très simples sur ses registres. Ainsi, si on souhaite simplement afficher un pixel à l'écran, il faut connaître l'adresse de l'écran et sa structure dans la mémoire, puis "écrire" à cette adresse au bon endroit (sans altérer l'état des pixels voisins). C'est pourquoi ce langage peut s'avérer dangereux : on a la possibilité de faire tout et n'importe quoi avec la mémoire, une mauvaise manipulation peut avoir de graves conséquences comme "bloquer" la machine et ce de manière irréversible. Au cas où vous voudriez tenter votre chance, consultez la documentation Hitachi, et effectuez vos tests sur le ClassPad Manager.<br />
<br />
==Alternative à Dev-C++==<br />
* Il semblerait qu'il existe un plug-in Casio pour MS Visual Studio. Malheureusement, celui-ci reste, à l'heure actuelle, introuvable. Il a probablement disparu avec la chute de cpsdk.com<br />
* Le 01/04/2013, MicroPro, un programmeur de l'UCF, a annoncé avoir commencé à develloper un IDE Visuel, dans le style de Visual Studio. Malheureusement, nous n'avons plus de nouvelles de ce projet depuis longtemps. La date de l'annonce laisse également supposer qu'il s'aggissant d'une blague. Pour plus d'information, voir [[http://community.casiocalc.org/topic/7122-program-in-a-visual-basic-ide-for-classpad/ ici]]<br />
<br />
==Liens utiles==<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-guide.pdf CPSDK Programming Guide]<br />
* [http://calc-casio.e-monsite.com/medias/files/programming-tutorial.pdf CPSDK Programming Tutorial]<br />
* [http://casiocalto.free.fr/Forum/viewtopic.php?t=474 Tuto sur CasioCalto]<br />
* [http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html Tuto C++ sur le Site Du Zéro]<br />
* [http://www.renesas.com/fmwk.jsp?cnt=Documentation.jsp&fp=/products/mpumcu/superh_family/sh7700_series/&title=Documentation&lid=6 Documentation SH3]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Fichier:Devcpp.png&diff=1007Fichier:Devcpp.png2014-05-19T13:28:07Z<p>Cartix : </p>
<hr />
<div></div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Correspondance_des_num%C3%A9ros_de_mod%C3%A8le&diff=397Correspondance des numéros de modèle2012-06-20T16:16:47Z<p>Cartix : /* Note */</p>
<hr />
<div> {| class="wikitable centre"<br />
|style="background-color:#ECBEBE" | International ||style="background-color:#ECBEBE" | Français "Graph" ||style="background-color:#ECBEBE" | Français<br />
|-<br />
|colspan="3" style="background-color:#BED3EC;text-align:center"|Première génération de modèles<br />
|-<br />
| fx-6300G || - || fx-6800G<br />
|-<br />
| fx-7300G || - || fx-6900G<br />
|-<br />
|colspan="3" style="background-color:#CCFFCC;padding-left:15%"|Graphiques<br />
|-<br />
| fx-7700G || - || fx-7800G <br />
|-<br />
| fx-7700GB|| - || fx-7800GC<br />
|-<br />
| fx-8700G || - || fx-8800G <br />
|-<br />
| fx-8700GB|| - || fx-8800GC <br />
|-<br />
|colspan="3" style="background-color:#CCFFCC;padding-left:15%" |Graphiques, menu à icône<br />
|-<br />
| fx-7700GE, GH || - || fx-7900GC<br />
|-<br />
| fx-9700GE, GH || - || fx-9900GC <br />
|-<br />
| CFX-9800G || - || CFX-9900GC <br />
|-<br />
|colspan="3" style="background-color:#BED3EC;text-align:center"|Deuxième génération de modèles<br />
|-<br />
|fx-7400G, 7450G || Graph 20, 25 || fx-6910G <br />
|-<br />
|fx-7400GII || Graph 25+ Pro || - <br />
|-<br />
|fx-9750G || Graph 30 || fx-8930GT <br />
|-<br />
|fx-9750G PLUS '''(*)''' || Graph 35, Graph 35+ (green) || -<br />
|-<br />
|fx-9750GA PLUS || Graph 35+ (white) || -<br />
|-<br />
|fx-9750GII || Graph 35+ USB, (white) || -<br />
|-<br />
|CFX-9850G, 9950 || Graph 60, 65|| CFX-9930GT, 9940, 9960 <br />
|-<br />
|CFX-9850GC PLUS || Graph 65 USB || -<br />
|-<br />
|CFX- 9970G || Graph 80 || CFX-9990GT <br />
|-<br />
|fx-9860G, 9860G SD || Graph 85, Graph 85 SD || -<br />
|-<br />
|fx-9860GII || Graph 75 || - <br />
|-<br />
|fx-9860GII SD || Graph 95 SD|| - <br />
|-<br />
|Algebra FX 2.0 || Graph 100 || -<br />
|-<br />
|Algebra FX 2.0 PLUS|| Graph 100+ USB || -<br />
|-<br />
|}<br />
<br />
=== Note ===<br />
<br />
* '''(*)''' Le modèle "9750G Plus" n'est pas identique face aux versions française : il a 26k de mémoire contre 64k pour la Graph 35/35+<br />
<br />
* 9750G = 8930GT = Graph 30 avec 32k<br />
<br />
* 9940GT+ = Graph 60 avec le libraire et le 32k.<br />
<br />
* Graph 65 avec libraire et 64k<br />
<br />
* donc:<br />
** 9850G = 9930GT<br />
** 9950G = 9960GT<br />
** 9850G Plus = 9940GT<br />
** 9850GB Plus = 9940GT+ = Graph 60<br />
** 9950GB Plus = Graph 65<br />
** 9850GC Plus = 65 moins de libraire<br />
** 9850G Plus(64k version)=9 850GC Plus<br />
<br />
* Les librairies de programmes sont différentes selon les modèles français et internationales.<br />
** 7400G = 6910G = Graph 20<br />
** ???? = 6910aG<br />
** 7450G = Graph 25<br />
** 7400G Plus = anglais et Allemand seulement (7400G Plus adds statgraph types pie,stack,bar,line to the 7450G)<br />
** 7400G Plus GY = Graph 25+<br />
<br />
== Notes et références ==<br />
Tableau réalisé par ''Roy F.A. Maclean'' : http://www.spiderpixel.co.uk/caspro/subhtml/modelsef.html<br />
<br />
[[en:Model Numbers Equivalence Table]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Accueil&diff=305Accueil2012-06-18T09:15:47Z<p>Cartix : </p>
<hr />
<div>{{MsgBox |title=Bienvenue sur Casio Universal Wiki !|text=Retourner vers [http://casio-scene.com casio-scene.com] ?}}<br />
<br />
<br/>[[Comment écrire un article pour Casio Universal Wiki?]]<br />
<br />
<table id="homePageTable"><!--for edit style of the table, edit http://wiki.casio-scene.com/en/MediaWiki:Common.css--><br />
<tr id="homePageTableTop"><br />
<th width="1%" rowspan="2" style="border-radius: 10px 0 0 0;border-left: 1px solid #a7d7f9 !important;">[[File:Text-Catégories.png|link=:Catégorie:Catégories des calculatrices]]</th><br />
<th width="19%">[[:Catégorie:Calculatrices Basic|Basic]]</th><br />
<th width="20%">[[:Catégorie:Graph 100|Graph 100]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Classpad|Classpad]]</th><br />
<th width="20%">[[:Catégorie:Graph 75/85/95|Graph 75/85/95]]</th><br />
<th width="20%" style="border-radius: 0 10px 0 0;">[[:Catégorie:Calculatrices Prizm|Prizm]]</th><br />
</tr><br />
<tr><br />
<td><center>[[Fichier:Graph 25+ pro-h100.jpg]][[Fichier:GRAPH_35+_USB-h100.jpg|link=Graph 35+ USB]]</center></td><br />
<td><center>[[Fichier:Casio afx series-2.0-en.jpg]]</center></td><br />
<td><center>[[Fichier:Cp.png|link=File:Cp.png]]</center></td><br />
<td><center>[[Fichier:Graph 75-h100.jpg]]</center></td><br />
<td><center>[[Fichier:Fx-CgXX-h100.jpg]]</center></td><br />
</tr><br />
<tr><br />
<th>[[File:text-Modèles.png|link=Catégorie:Calculatrices_Casio|Voir toutes les calculatrices]]</th><br />
<td><br />
<ul><br />
<li>Graph 25+ PRO</li><br />
<li>[[Graph 35+ USB]]</li><br />
<li>Graph 65</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 100</li><br />
<li>Graph 100+</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Classpad 300</li><br />
<li>Classpad 300+</li><br />
<li>Classpad 330</li><br />
<li>Classpad 330+</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 75</li><br />
<li>Graph 85</li><br />
<li>Graph 95</li><br />
<li>[[:Category:Graph 75/85/95|Voir plus...]]</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Fx-Cg10</li><br />
<li>Fx-Cg20</li><br />
</ul><br />
</td> <br />
</tr><br />
<tr><br />
<th></th><br />
<td>[[Transferts]]</td><br />
<td>[[Transfert avec Graph 100]]</td><br />
<td>[[Transfert avec Classpad]]</td><br />
<td>[[Transfert avec Graph 75/85/95]]</td><br />
<td>[[Transfert avec Prizm]]</td><br />
</tr><br />
<tr><br />
<th>[[File:text-Basic_Casio.png|link=Basic_Casio]]</th><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>Quelques différences</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
</tr><br />
<tr><br />
<th>[[File:text-C_ASM.png|link=Langage C]]</th><br />
<td>Non</td><br />
<td>Oui</td><br />
<td><ul><li>[[CPSDK]]</li><li>[[GaumerieLib]]</li></ul></td><br />
<td><ul><br />
<li>[[SDK]]</li><br />
<li>[[Syscalls]]</li><br />
</ul></td><br />
<td><ul><br />
<li>[[miniSDK]]</li><br />
<li>[[Syscalls]]</li><br />
</ul></td><br />
</tr><br />
<tr><br />
<th style="border-radius: 0 0 0 10px;">[[File:Text-Dev. Alternatif.png|link=Développement Alternatif]]</th><br />
<td>Non</td><br />
<td><ul><li>Lua</li></ul></td><br />
<td><ul><li>[[CPLua]]</li><li>CPBF</li></ul></td><br />
<td><ul><li>Lua</li></ul></td><br />
<td style="border-radius: 0 0 10px 0;">Aucun pour l'instant<br />Mais PRGM2 color est en cours</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
<center>[[Correspondance des numéros de modèle|Correspondance des numéros de modèle Français/International]]</center><br />
Page en cours de construction...<br />
<br/><br />
[[en:Main_Page]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Accueil&diff=275Accueil2012-06-17T11:02:31Z<p>Cartix : </p>
<hr />
<div>{{MsgBox |title=Bienvenue sur Casio Universal Wiki !|text=Retourner vers [http://casio-scene.com casio-scene.com] ?}}<br />
<br />
<br/>[[Comment écrire un article pour Casio Universal Wiki?]]<br />
<br />
<table id="homePageTable"><!--for edit style of the table, edit http://wiki.casio-scene.com/en/MediaWiki:Common.css--><br />
<tr id="homePageTableTop"><br />
<th width="1%" rowspan="2" style="border-radius: 10px 0 0 0;border-left: 1px solid #a7d7f9 !important;">[[File:Text-Catégories.png|link=:Catégorie:Catégories des calculatrices]]</th><br />
<th width="19%">[[:Catégorie:Calculatrices Basic|Basic]]</th><br />
<th width="20%">[[:Catégorie:Graph 100|Graph 100]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Classpad|Classpad]]</th><br />
<th width="20%">[[:Catégorie:Graph 75/85/95|Graph 75/85/95]]</th><br />
<th width="20%" style="border-radius: 0 10px 0 0;">[[:Catégorie:Calculatrices Prizm|Prizm]]</th><br />
</tr><br />
<tr><br />
<td><center>[[Fichier:Graph 25+ pro-h100.jpg]]</center></td><br />
<td><center>[[Fichier:Casio afx series-2.0-en.jpg]]</center></td><br />
<td><center>[[Fichier:Cp.png|link=File:Cp.png]]</center></td><br />
<td><center>[[Fichier:GRAPH_35+_USB-h100.jpg|link=Graph 35+ USB]]</center></td><br />
<td><center>[[Fichier:Fx-CgXX-h100.jpg]]</center></td><br />
</tr><br />
<tr><br />
<th>[[File:text-Modèles.png|link=Catégorie:Calculatrices_Casio|Voir toutes les calculatrices]]</th><br />
<td><br />
<ul><br />
<li>Graph 25+ PRO</li><br />
<li>[[Graph 35+ USB]]</li><br />
<li>Graph 65</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 100</li><br />
<li>Graph 100+</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Classpad 300</li><br />
<li>Classpad 300+</li><br />
<li>Classpad 330</li><br />
<li>Classpad 330+</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 75</li><br />
<li>Graph 85</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Fx-Cg10</li><br />
<li>Fx-Cg20</li><br />
</ul><br />
</td> <br />
</tr><br />
<tr><br />
<th></th><br />
<td>[[Transfert]]</td><br />
<td>[[Transfert avec Graph 100]]</td><br />
<td>[[Transfert avec Classpad]]</td><br />
<td>[[Transfert avec Graph 75/85/95]]</td><br />
<td>[[Transfert avec Prizm]]</td><br />
</tr><br />
<tr><br />
<th>[[File:text-Basic_Casio.png|link=Basic_Casio]]</th><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>Quelques différences</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
</tr><br />
<tr><br />
<th>[[File:text-C_ASM.png|link=Langage C]]</th><br />
<td>Non</td><br />
<td>Oui</td><br />
<td>[[GaumerieLib]]</td><br />
<td>Oui</td><br />
<td>Oui</td><br />
</tr><br />
<tr><br />
<th style="border-radius: 0 0 0 10px;">[[File:Text-Dev. Alternatif.png|link=Développement Alternatif]]</th><br />
<td>Non</td><br />
<td><ul><li>Lua</li></ul></td><br />
<td><ul><li>[[CPLua]]</li><li>CPBF</li></ul></td><br />
<td><ul><li>Lua</li></ul></td><br />
<td style="border-radius: 0 0 10px 0;">Aucun pour l'instant<br />Mais PRGM2 color est en cours</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
<center>[[Correspondance des numéros de modèle|Correspondance des numéros de modèle Français/International]]</center><br />
Page en cours de construction...<br />
<br/><br />
[[en:Main_Page]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Accueil&diff=274Accueil2012-06-17T11:00:05Z<p>Cartix : </p>
<hr />
<div>{{MsgBox |title=Bienvenue sur Casio Universal Wiki !|text=Retourner vers [http://casio-scene.com casio-scene.com] ?}}<br />
<br />
<br/>[[Comment écrire un article pour Casio Universal Wiki?]]<br />
<br />
<table id="homePageTable"><!--for edit style of the table, edit http://wiki.casio-scene.com/en/MediaWiki:Common.css--><br />
<tr id="homePageTableTop"><br />
<th width="1%" rowspan="2" style="border-radius: 10px 0 0 0;border-left: 1px solid #a7d7f9 !important;">[[File:Text-Catégories.png|link=:Catégorie:Catégories des calculatrices]]</th><br />
<th width="19%">[[:Catégorie:Calculatrices Basic|Basic]]</th><br />
<th width="20%">[[:Catégorie:Graph 100|Graph 100]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Classpad|Classpad]]</th><br />
<th width="20%">[[:Catégorie:Graph 75/85/95|Graph 75/85/95]]</th><br />
<th width="20%" style="border-radius: 0 10px 0 0;">[[:Catégorie:Calculatrices Prizm|Prizm]]</th><br />
</tr><br />
<tr><br />
<td><center>[[Fichier:Graph 25+ pro-h100.jpg]]</center></td><br />
<td><center>[[Fichier:Casio afx series-2.0-en.jpg]]</center></td><br />
<td><center>[[Fichier:Cp.png|link=File:Cp.png]]</center></td><br />
<td><center>[[Fichier:GRAPH_35+_USB-h100.jpg|link=Graph 35+ USB]]</center></td><br />
<td><center>[[Fichier:Fx-CgXX-h100.jpg]]</center></td><br />
</tr><br />
<tr><br />
<th>[[File:text-Modèles.png|link=Catégorie:Calculatrices_Casio|Voir toutes les calculatrices]]</th><br />
<td><br />
<ul><br />
<li>Graph 25+ PRO</li><br />
<li>[[Graph 35+ USB]]</li><br />
<li>Graph 65</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 100</li><br />
<li>Graph 100+</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Classpad 300</li><br />
<li>Classpad 300+</li><br />
<li>Classpad 330</li><br />
<li>Classpad 330+</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 75</li><br />
<li>Graph 85</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Fx-Cg10</li><br />
<li>Fx-Cg20</li><br />
</ul><br />
</td> <br />
</tr><br />
<tr><br />
<th></th><br />
<td>[[Transfert]]</td><br />
<td>[[Transfert avec Graph 100]]</td><br />
<td>[[Transfert avec Classpad]]</td><br />
<td>[[Transfert avec Graph 75/85/95]]</td><br />
<td>[[Transfert avec Prizm]]</td><br />
</tr><br />
<tr><br />
<th>[[File:text-Basic_Casio.png|link=Basic_Casio]]</th><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>Quelques différences</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
<td>[[Basic_Casio|Basic Casio]]</td><br />
</tr><br />
<tr><br />
<th>[[File:text-C_ASM.png|link=Langage C]]</th><br />
<td>Non</td><br />
<td>Oui</td><br />
<td>[http://classpad.fr/publication/GaumerieLib.pdf GaumerieLib]</td><br />
<td>Oui</td><br />
<td>Oui</td><br />
</tr><br />
<tr><br />
<th style="border-radius: 0 0 0 10px;">[[File:Text-Dev. Alternatif.png|link=Développement Alternatif]]</th><br />
<td>Non</td><br />
<td><ul><li>Lua</li></ul></td><br />
<td><ul><li>[[CPLua]]</li><li>CPBF</li></ul></td><br />
<td><ul><li>Lua</li></ul></td><br />
<td style="border-radius: 0 0 10px 0;">Aucun pour l'instant<br />Mais PRGM2 color est en cours</td><br />
</tr><br />
</table><br />
<br />
<br />
<br />
<center>[[Correspondance des numéros de modèle|Correspondance des numéros de modèle Français/International]]</center><br />
Page en cours de construction...<br />
<br/><br />
[[en:Main_Page]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Accueil&diff=238Accueil2012-06-16T10:20:00Z<p>Cartix : </p>
<hr />
<div>{{MsgBox |title=Bienvenue sur Casio Universal Wiki !|text=Retourner vers [http://casio-scene.com casio-scene.com] ?}}<br />
<br />
<br/>[[Comment écrire un article pour Casio Universal Wiki?]]<br />
<br />
<table id="homePageTable"><!--for edit style of the table, edit http://wiki.casio-scene.com/en/MediaWiki:Common.css--><br />
<tr id="homePageTableTop"><br />
<th width="1%" rowspan="2" style="border-radius: 10px 0 0 0;border-left: 1px solid #a7d7f9 !important;">[[File:Text-Catégories.png|link=:Catégorie:Catégories des calculatrices]]</th><br />
<th width="19%">[[:Catégorie:Calculatrices Basic|Basic]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Basic et C/ASM|Basic et C/ASM]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Classpad|Classpad]]</th><br />
<th width="20%" style="border-radius: 0 10px 0 0;">[[:Catégorie:Calculatrices Prizm|Prizm]]</th><br />
</tr><br />
<tr><br />
<td><center>[[File:GRAPH_35+_USB-h100.jpg|link=Graph 35+ USB]]</center></td><br />
<td>&nbsp;</td><br />
<td><center>[[File:Cp.png|link=File:Cp.png]]</center></td><br />
<td>&nbsp;</td><br />
</tr><br />
<tr><br />
<th>[[File:text-Modèles.png|link=Catégorie:Calculatrices_Casio|Voir toutes les calculatrices]]</th><br />
<td><br />
<ul><br />
<li>Graph 25+ PRO</li><br />
<li>[[Graph 35+ USB]]</li><br />
<li>Graph 65</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 75</li><br />
<li>Graph 85</li><br />
<li>Graph 100+</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Classpad 300</li><br />
<li>Classpad 300+</li><br />
<li>Classpad 330</li><br />
<li>Classpad 330+</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Fx-Cg10</li><br />
<li>Fx-Cg20</li><br />
</ul><br />
</td> <br />
</tr><br />
<br />
<tr><br />
<th>[[File:text-Basic_Casio.png|link=Basic_Casio]]</th><br />
<td></td><br />
<td></td><br />
<td></td><br />
<td></td><br />
</tr><br />
<tr><br />
<th>[[File:text-C_ASM.png|link=Langage C]]</th><br />
<td></td><br />
<td></td><br />
<td></td><br />
<td></td><br />
</tr><br />
<tr><br />
<th style="border-radius: 0 0 0 10px;">[[File:Text-Dev. Alternatif.png|link=Développement Alternatif]]</th><br />
<td></td><br />
<td></td><br />
<td><ul><li>[[CPLua]]</li><li>CPBF</li></ul></td><br />
<td style="border-radius: 0 0 10px 0;"></td><br />
</tr><br />
</table><br />
<br />
Page en cours de construction...<br />
<br/><br />
[[en:Main_Page]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Accueil&diff=237Accueil2012-06-16T10:18:52Z<p>Cartix : </p>
<hr />
<div>{{MsgBox |title=Bienvenue sur Casio Universal Wiki !|text=Retourner vers [http://casio-scene.com casio-scene.com] ?}}<br />
<br />
<br/>[[Comment écrire un article pour Casio Universal Wiki?]]<br />
<br />
<table id="homePageTable"><!--for edit style of the table, edit http://wiki.casio-scene.com/en/MediaWiki:Common.css--><br />
<tr id="homePageTableTop"><br />
<th width="1%" rowspan="2" style="border-radius: 10px 0 0 0;border-left: 1px solid #a7d7f9 !important;">[[File:Text-Catégories.png|link=:Catégorie:Catégories des calculatrices]]</th><br />
<th width="19%">[[:Catégorie:Calculatrices Basic|Basic]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Basic et C/ASM|Basic et C/ASM]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Classpad|Classpad]]</th><br />
<th width="20%" style="border-radius: 0 10px 0 0;">[[:Catégorie:Calculatrices Prizm|Prizm]]</th><br />
</tr><br />
<tr><br />
<td><center>[[File:GRAPH_35+_USB-h100.jpg|link=Graph 35+ USB]]</center></td><br />
<td>&nbsp;</td><br />
<td>&nbsp;</td><br />
<td>&nbsp;</td><br />
</tr><br />
<tr><br />
<th>[[File:text-Modèles.png|link=Catégorie:Calculatrices_Casio|Voir toutes les calculatrices]]</th><br />
<td><br />
<ul><br />
<li>Graph 25+ PRO</li><br />
<li>[[Graph 35+ USB]]</li><br />
<li>Graph 65</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 75</li><br />
<li>Graph 85</li><br />
<li>Graph 100+</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Classpad 300</li><br />
<li>Classpad 300+</li><br />
<li>Classpad 330</li><br />
<li>Classpad 330+</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Fx-Cg10</li><br />
<li>Fx-Cg20</li><br />
</ul><br />
</td> <br />
</tr><br />
<br />
<tr><br />
<th>[[File:text-Basic_Casio.png|link=Basic_Casio]]</th><br />
<td></td><br />
<td></td><br />
<td></td><br />
<td></td><br />
</tr><br />
<tr><br />
<th>[[File:text-C_ASM.png|link=Langage C]]</th><br />
<td></td><br />
<td></td><br />
<td></td><br />
<td></td><br />
</tr><br />
<tr><br />
<th style="border-radius: 0 0 0 10px;">[[File:Text-Dev. Alternatif.png|link=Développement Alternatif]]</th><br />
<td></td><br />
<td></td><br />
<td><ul><li>[[CPLua]]</li><li>CPBF</li></ul></td><br />
<td style="border-radius: 0 0 10px 0;"></td><br />
</tr><br />
</table><br />
<br />
Page en cours de construction...<br />
<br/><br />
[[en:Main_Page]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPLua&diff=236CPLua2012-06-16T10:16:40Z<p>Cartix : </p>
<hr />
<div>[[en:CPLua]]<br />
<br />
La langue de Lua est un juste milieu entre le CPBasic et le C++. Ce langage de programmation est simple, flexible et rapide. Il permettent aux développeurs de créer des programmes complexes impossibles à écrire en CPBasic. CPLua est un add-in pour ClassPad qui incluent un interprèter Lua et à beaucoup de nouvelles fonctions et vous permet de programmer en Lua on-calc. <br />
<br />
CPLua est un projet donc quelques bogues peuvent apparaître. La version la plus stable est actuellement la version 0.8 version. La dernière version est la version 0.10A disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici].<br />
<br />
__TOC__<br />
<br />
==Histoire== <br />
CPLua a été commencé en 2005 par Julien, un programmeur français, parce qu'il y avait trop de personnes qui se plaignaient de la lenteur du CPBasic mais ne voulaient pas apprendre le C++.<br />
* 01/09/2005 : la première version a été publiée [http://casiocalto.free.fr/Forum/viewtopic.php?t=611 ici].<br />
* 07/09/2005 : version 0.4 : ajout de la possibilité sauver/ouvrir des script Lua<br />
* 08-09/2005 : version 0.51 : correction de certains bugs et ajout d'un nouveau clavier<br />
* 27/09/2005 : version 0.72 : ajout de la totalité du paquet de CAS<br />
* 19/04/2006 : version 0.8 : version la plus rapide (en dessin) de CPLua. Téléchargez-la [http://www.casio-scene.com/downloads.php?do=file&id=532 ici]<br />
* 07-27-2007 : version 0.9E : la dernière version faite par Orwell (ajout de la bibliothèque UI)<br />
L'année dernière, deux programmeur, [http://www.casio-scene.com/member.php?10077-Cartix Cartix] (moi) et [http://www.planet-casio.com/Fr/compte/voir_profil.php?membre=binary_man Binary_Man], de Planete Casio, ont commencé à retravailler sur le projet, dans le but d'ajouter de nouvelles fonctions. Notre première version (CPLua 0.10A) est sortie le 28/01/2012, et est disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici]<br />
<br />
==Mise en route==<br />
* Premièrement, télécharger la version de l'add-in que vous souhaitez :[http://www.casio-scene.com/downloads.php?do=file&id=532 CPLua 0.8] ou [http://www.casio-scene.com/downloads.php?do=file&id=533 CPLua 0.10A]<br />
* Envoyez ensuite le .cpa à votre classpad avec FA-CP1 ou Classpad Add-In Installer (des tutos seront bientôt disponible)<br />
* Allez au menu principal sur votre Classpad et ouvrez l'application CPLua<br />
* Créez un nouveau fichier et commencez à programmer<br />
<br />
==Librairie== <br />
* UI : Interface utilisateurs : Cette librairie vous permet d'utiliser l'interface utilisateur du Classpad (menu, barre d'outils,…) dans vos programmes<br />
* CAS : Système d'Aglèbre informatique : Cette librairie vous permets d'employer toutes les fonctions mathématiques de l'application "Main" (diff, intg, solve, …)<br />
* Draw : Cette librairie vous permet de dessiner sur l'écran (point, ligne, cercle,…) et pour employer des sprites/images<br />
* IO : Entrée-sortie : Cette librairie vous permet de manipuler les fichiers de votre Classpad (ouvrir, enregistrer, lire,…)<br />
* String : Cette librairie vous permet de manipuler les chaines de caractères<br />
* Debug : Cette librairie vous permet de corriger votre programme<br />
* Table : Cette librairie vous permet de manipuler des listes<br />
* Math : Cette librairie vous permet d'effectuer des opérations sur des nombres (sin, log,…)<br />
Pour connaître toutes les fonctions d'une librairie, "table.foreach (<name du library>, de la copie)"<br />
<br />
==Structures de Controle==<br />
===BOUCLES===<br />
* Vous pouvez casser une boucle avec "break"<br />
====While====<br />
<pre><br />
while <condition 1> do<br />
<code à exécuter tant que la condition 1 est respectée><br />
end<br />
</pre><br />
<br />
====Repeat====<br />
<pre><br />
repeat<br />
<code à exécuter tant que la condition 1 est respectée><br />
until <condition 1><br />
</pre><br />
<br />
====For====<br />
<pre><br />
for <var>=<min>,<max>[,incrément] do<br />
<code à exécuter tant que var est différent de max ><br />
end<br />
</pre><br />
* Si l'incrément n'est pas spécifié, il vaudra automatiquement 1<br />
<br />
===IF===<br />
<pre><br />
if <condition 1> then<br />
<code à exécuter si la condition 1 est respectée><br />
elseif <condition 2> then<br />
<code à exécuter si la condition 1 est respectée et la condition 1 est respectée><br />
else<br />
<code à exécuter si aucune des conditions n'est respéctée><br />
end<br />
</pre><br />
<br />
===Déclaration d'une fonction===<br />
<pre><br />
function <nom de la fonction>(<liste des paramètres>)<br />
<code à exécuter si la fonction est appelée><br />
return <valeur à retourner><br />
end<br />
</pre><br />
* Si la valeur à retourner n'est pas spécifiée, la fonction ne renverra rien<br />
* Si aucun paramètre n'est spécifié, la fonction fonctionnera sans paramètre<br />
* On peut déclarer des variables locales dans les fonctions, utilisable uniquement par la fonction dans laquelle elles ont étés déclarées<br />
<br />
===Comentaires===<br />
<pre><br />
--<commentaire> pour un commentaire d'une ligne<br />
--[[<commentaire>]]-- pour un commentaire de plusieurs lignes<br />
</pre><br />
<br />
==Fonctions spécifiques à CPLua==<br />
CPLua a deux écran différents : la console (pour les entrées/sorties) et l'écran graphique (pour dessiner). Par défaut, un programme affiche la console. On peut passer de l'un à l'autre à l'aide de<br />
* showconsole() pour afficher la console<br />
* showgraph() pour afficher l'écran graphique<br />
Il y a de nombreuse autres fonctions spécifiques telles que :<br />
* keypad(0/1) : 0 pour masque le clavier et 1 pour l'afficher<br />
* fullscreen(0/1) : 0 pour afficher la barre de menu 1 pour la masquer<br />
Pour connaitre toutes les fonctions spécifiques et leur syntaxes, regarder [http://orwell01.free.fr/Release/CPLua/functions.txt ici]<br />
<br />
==Lien utiles==<br />
* [http://www.lua.org/ Site officiel du Lua]<br />
* [http://calc-casio.e-monsite.com/pages/librairie/cplua/ Librairies supplémentaires]<br />
* [http://orwell01.free.fr/Release/CPLua/functions.txt Liste des fonctions spécifiques]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPLua&diff=235CPLua2012-06-16T10:16:24Z<p>Cartix : </p>
<hr />
<div>[[en:page]]<br />
<br />
La langue de Lua est un juste milieu entre le CPBasic et le C++. Ce langage de programmation est simple, flexible et rapide. Il permettent aux développeurs de créer des programmes complexes impossibles à écrire en CPBasic. CPLua est un add-in pour ClassPad qui incluent un interprèter Lua et à beaucoup de nouvelles fonctions et vous permet de programmer en Lua on-calc. <br />
<br />
CPLua est un projet donc quelques bogues peuvent apparaître. La version la plus stable est actuellement la version 0.8 version. La dernière version est la version 0.10A disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici].<br />
<br />
__TOC__<br />
<br />
==Histoire== <br />
CPLua a été commencé en 2005 par Julien, un programmeur français, parce qu'il y avait trop de personnes qui se plaignaient de la lenteur du CPBasic mais ne voulaient pas apprendre le C++.<br />
* 01/09/2005 : la première version a été publiée [http://casiocalto.free.fr/Forum/viewtopic.php?t=611 ici].<br />
* 07/09/2005 : version 0.4 : ajout de la possibilité sauver/ouvrir des script Lua<br />
* 08-09/2005 : version 0.51 : correction de certains bugs et ajout d'un nouveau clavier<br />
* 27/09/2005 : version 0.72 : ajout de la totalité du paquet de CAS<br />
* 19/04/2006 : version 0.8 : version la plus rapide (en dessin) de CPLua. Téléchargez-la [http://www.casio-scene.com/downloads.php?do=file&id=532 ici]<br />
* 07-27-2007 : version 0.9E : la dernière version faite par Orwell (ajout de la bibliothèque UI)<br />
L'année dernière, deux programmeur, [http://www.casio-scene.com/member.php?10077-Cartix Cartix] (moi) et [http://www.planet-casio.com/Fr/compte/voir_profil.php?membre=binary_man Binary_Man], de Planete Casio, ont commencé à retravailler sur le projet, dans le but d'ajouter de nouvelles fonctions. Notre première version (CPLua 0.10A) est sortie le 28/01/2012, et est disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici]<br />
<br />
==Mise en route==<br />
* Premièrement, télécharger la version de l'add-in que vous souhaitez :[http://www.casio-scene.com/downloads.php?do=file&id=532 CPLua 0.8] ou [http://www.casio-scene.com/downloads.php?do=file&id=533 CPLua 0.10A]<br />
* Envoyez ensuite le .cpa à votre classpad avec FA-CP1 ou Classpad Add-In Installer (des tutos seront bientôt disponible)<br />
* Allez au menu principal sur votre Classpad et ouvrez l'application CPLua<br />
* Créez un nouveau fichier et commencez à programmer<br />
<br />
==Librairie== <br />
* UI : Interface utilisateurs : Cette librairie vous permet d'utiliser l'interface utilisateur du Classpad (menu, barre d'outils,…) dans vos programmes<br />
* CAS : Système d'Aglèbre informatique : Cette librairie vous permets d'employer toutes les fonctions mathématiques de l'application "Main" (diff, intg, solve, …)<br />
* Draw : Cette librairie vous permet de dessiner sur l'écran (point, ligne, cercle,…) et pour employer des sprites/images<br />
* IO : Entrée-sortie : Cette librairie vous permet de manipuler les fichiers de votre Classpad (ouvrir, enregistrer, lire,…)<br />
* String : Cette librairie vous permet de manipuler les chaines de caractères<br />
* Debug : Cette librairie vous permet de corriger votre programme<br />
* Table : Cette librairie vous permet de manipuler des listes<br />
* Math : Cette librairie vous permet d'effectuer des opérations sur des nombres (sin, log,…)<br />
Pour connaître toutes les fonctions d'une librairie, "table.foreach (<name du library>, de la copie)"<br />
<br />
==Structures de Controle==<br />
===BOUCLES===<br />
* Vous pouvez casser une boucle avec "break"<br />
====While====<br />
<pre><br />
while <condition 1> do<br />
<code à exécuter tant que la condition 1 est respectée><br />
end<br />
</pre><br />
<br />
====Repeat====<br />
<pre><br />
repeat<br />
<code à exécuter tant que la condition 1 est respectée><br />
until <condition 1><br />
</pre><br />
<br />
====For====<br />
<pre><br />
for <var>=<min>,<max>[,incrément] do<br />
<code à exécuter tant que var est différent de max ><br />
end<br />
</pre><br />
* Si l'incrément n'est pas spécifié, il vaudra automatiquement 1<br />
<br />
===IF===<br />
<pre><br />
if <condition 1> then<br />
<code à exécuter si la condition 1 est respectée><br />
elseif <condition 2> then<br />
<code à exécuter si la condition 1 est respectée et la condition 1 est respectée><br />
else<br />
<code à exécuter si aucune des conditions n'est respéctée><br />
end<br />
</pre><br />
<br />
===Déclaration d'une fonction===<br />
<pre><br />
function <nom de la fonction>(<liste des paramètres>)<br />
<code à exécuter si la fonction est appelée><br />
return <valeur à retourner><br />
end<br />
</pre><br />
* Si la valeur à retourner n'est pas spécifiée, la fonction ne renverra rien<br />
* Si aucun paramètre n'est spécifié, la fonction fonctionnera sans paramètre<br />
* On peut déclarer des variables locales dans les fonctions, utilisable uniquement par la fonction dans laquelle elles ont étés déclarées<br />
<br />
===Comentaires===<br />
<pre><br />
--<commentaire> pour un commentaire d'une ligne<br />
--[[<commentaire>]]-- pour un commentaire de plusieurs lignes<br />
</pre><br />
<br />
==Fonctions spécifiques à CPLua==<br />
CPLua a deux écran différents : la console (pour les entrées/sorties) et l'écran graphique (pour dessiner). Par défaut, un programme affiche la console. On peut passer de l'un à l'autre à l'aide de<br />
* showconsole() pour afficher la console<br />
* showgraph() pour afficher l'écran graphique<br />
Il y a de nombreuse autres fonctions spécifiques telles que :<br />
* keypad(0/1) : 0 pour masque le clavier et 1 pour l'afficher<br />
* fullscreen(0/1) : 0 pour afficher la barre de menu 1 pour la masquer<br />
Pour connaitre toutes les fonctions spécifiques et leur syntaxes, regarder [http://orwell01.free.fr/Release/CPLua/functions.txt ici]<br />
<br />
==Lien utiles==<br />
* [http://www.lua.org/ Site officiel du Lua]<br />
* [http://calc-casio.e-monsite.com/pages/librairie/cplua/ Librairies supplémentaires]<br />
* [http://orwell01.free.fr/Release/CPLua/functions.txt Liste des fonctions spécifiques]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPLua&diff=234CPLua2012-06-16T10:16:08Z<p>Cartix : </p>
<hr />
<div>[[fr:page]]<br />
<br />
La langue de Lua est un juste milieu entre le CPBasic et le C++. Ce langage de programmation est simple, flexible et rapide. Il permettent aux développeurs de créer des programmes complexes impossibles à écrire en CPBasic. CPLua est un add-in pour ClassPad qui incluent un interprèter Lua et à beaucoup de nouvelles fonctions et vous permet de programmer en Lua on-calc. <br />
<br />
CPLua est un projet donc quelques bogues peuvent apparaître. La version la plus stable est actuellement la version 0.8 version. La dernière version est la version 0.10A disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici].<br />
<br />
__TOC__<br />
<br />
==Histoire== <br />
CPLua a été commencé en 2005 par Julien, un programmeur français, parce qu'il y avait trop de personnes qui se plaignaient de la lenteur du CPBasic mais ne voulaient pas apprendre le C++.<br />
* 01/09/2005 : la première version a été publiée [http://casiocalto.free.fr/Forum/viewtopic.php?t=611 ici].<br />
* 07/09/2005 : version 0.4 : ajout de la possibilité sauver/ouvrir des script Lua<br />
* 08-09/2005 : version 0.51 : correction de certains bugs et ajout d'un nouveau clavier<br />
* 27/09/2005 : version 0.72 : ajout de la totalité du paquet de CAS<br />
* 19/04/2006 : version 0.8 : version la plus rapide (en dessin) de CPLua. Téléchargez-la [http://www.casio-scene.com/downloads.php?do=file&id=532 ici]<br />
* 07-27-2007 : version 0.9E : la dernière version faite par Orwell (ajout de la bibliothèque UI)<br />
L'année dernière, deux programmeur, [http://www.casio-scene.com/member.php?10077-Cartix Cartix] (moi) et [http://www.planet-casio.com/Fr/compte/voir_profil.php?membre=binary_man Binary_Man], de Planete Casio, ont commencé à retravailler sur le projet, dans le but d'ajouter de nouvelles fonctions. Notre première version (CPLua 0.10A) est sortie le 28/01/2012, et est disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici]<br />
<br />
==Mise en route==<br />
* Premièrement, télécharger la version de l'add-in que vous souhaitez :[http://www.casio-scene.com/downloads.php?do=file&id=532 CPLua 0.8] ou [http://www.casio-scene.com/downloads.php?do=file&id=533 CPLua 0.10A]<br />
* Envoyez ensuite le .cpa à votre classpad avec FA-CP1 ou Classpad Add-In Installer (des tutos seront bientôt disponible)<br />
* Allez au menu principal sur votre Classpad et ouvrez l'application CPLua<br />
* Créez un nouveau fichier et commencez à programmer<br />
<br />
==Librairie== <br />
* UI : Interface utilisateurs : Cette librairie vous permet d'utiliser l'interface utilisateur du Classpad (menu, barre d'outils,…) dans vos programmes<br />
* CAS : Système d'Aglèbre informatique : Cette librairie vous permets d'employer toutes les fonctions mathématiques de l'application "Main" (diff, intg, solve, …)<br />
* Draw : Cette librairie vous permet de dessiner sur l'écran (point, ligne, cercle,…) et pour employer des sprites/images<br />
* IO : Entrée-sortie : Cette librairie vous permet de manipuler les fichiers de votre Classpad (ouvrir, enregistrer, lire,…)<br />
* String : Cette librairie vous permet de manipuler les chaines de caractères<br />
* Debug : Cette librairie vous permet de corriger votre programme<br />
* Table : Cette librairie vous permet de manipuler des listes<br />
* Math : Cette librairie vous permet d'effectuer des opérations sur des nombres (sin, log,…)<br />
Pour connaître toutes les fonctions d'une librairie, "table.foreach (<name du library>, de la copie)"<br />
<br />
==Structures de Controle==<br />
===BOUCLES===<br />
* Vous pouvez casser une boucle avec "break"<br />
====While====<br />
<pre><br />
while <condition 1> do<br />
<code à exécuter tant que la condition 1 est respectée><br />
end<br />
</pre><br />
<br />
====Repeat====<br />
<pre><br />
repeat<br />
<code à exécuter tant que la condition 1 est respectée><br />
until <condition 1><br />
</pre><br />
<br />
====For====<br />
<pre><br />
for <var>=<min>,<max>[,incrément] do<br />
<code à exécuter tant que var est différent de max ><br />
end<br />
</pre><br />
* Si l'incrément n'est pas spécifié, il vaudra automatiquement 1<br />
<br />
===IF===<br />
<pre><br />
if <condition 1> then<br />
<code à exécuter si la condition 1 est respectée><br />
elseif <condition 2> then<br />
<code à exécuter si la condition 1 est respectée et la condition 1 est respectée><br />
else<br />
<code à exécuter si aucune des conditions n'est respéctée><br />
end<br />
</pre><br />
<br />
===Déclaration d'une fonction===<br />
<pre><br />
function <nom de la fonction>(<liste des paramètres>)<br />
<code à exécuter si la fonction est appelée><br />
return <valeur à retourner><br />
end<br />
</pre><br />
* Si la valeur à retourner n'est pas spécifiée, la fonction ne renverra rien<br />
* Si aucun paramètre n'est spécifié, la fonction fonctionnera sans paramètre<br />
* On peut déclarer des variables locales dans les fonctions, utilisable uniquement par la fonction dans laquelle elles ont étés déclarées<br />
<br />
===Comentaires===<br />
<pre><br />
--<commentaire> pour un commentaire d'une ligne<br />
--[[<commentaire>]]-- pour un commentaire de plusieurs lignes<br />
</pre><br />
<br />
==Fonctions spécifiques à CPLua==<br />
CPLua a deux écran différents : la console (pour les entrées/sorties) et l'écran graphique (pour dessiner). Par défaut, un programme affiche la console. On peut passer de l'un à l'autre à l'aide de<br />
* showconsole() pour afficher la console<br />
* showgraph() pour afficher l'écran graphique<br />
Il y a de nombreuse autres fonctions spécifiques telles que :<br />
* keypad(0/1) : 0 pour masque le clavier et 1 pour l'afficher<br />
* fullscreen(0/1) : 0 pour afficher la barre de menu 1 pour la masquer<br />
Pour connaitre toutes les fonctions spécifiques et leur syntaxes, regarder [http://orwell01.free.fr/Release/CPLua/functions.txt ici]<br />
<br />
==Lien utiles==<br />
* [http://www.lua.org/ Site officiel du Lua]<br />
* [http://calc-casio.e-monsite.com/pages/librairie/cplua/ Librairies supplémentaires]<br />
* [http://orwell01.free.fr/Release/CPLua/functions.txt Liste des fonctions spécifiques]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPLua&diff=233CPLua2012-06-16T10:15:52Z<p>Cartix : </p>
<hr />
<div>[[fr:http://wiki.casio-scene.com/en/CPLua]]<br />
<br />
La langue de Lua est un juste milieu entre le CPBasic et le C++. Ce langage de programmation est simple, flexible et rapide. Il permettent aux développeurs de créer des programmes complexes impossibles à écrire en CPBasic. CPLua est un add-in pour ClassPad qui incluent un interprèter Lua et à beaucoup de nouvelles fonctions et vous permet de programmer en Lua on-calc. <br />
<br />
CPLua est un projet donc quelques bogues peuvent apparaître. La version la plus stable est actuellement la version 0.8 version. La dernière version est la version 0.10A disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici].<br />
<br />
__TOC__<br />
<br />
==Histoire== <br />
CPLua a été commencé en 2005 par Julien, un programmeur français, parce qu'il y avait trop de personnes qui se plaignaient de la lenteur du CPBasic mais ne voulaient pas apprendre le C++.<br />
* 01/09/2005 : la première version a été publiée [http://casiocalto.free.fr/Forum/viewtopic.php?t=611 ici].<br />
* 07/09/2005 : version 0.4 : ajout de la possibilité sauver/ouvrir des script Lua<br />
* 08-09/2005 : version 0.51 : correction de certains bugs et ajout d'un nouveau clavier<br />
* 27/09/2005 : version 0.72 : ajout de la totalité du paquet de CAS<br />
* 19/04/2006 : version 0.8 : version la plus rapide (en dessin) de CPLua. Téléchargez-la [http://www.casio-scene.com/downloads.php?do=file&id=532 ici]<br />
* 07-27-2007 : version 0.9E : la dernière version faite par Orwell (ajout de la bibliothèque UI)<br />
L'année dernière, deux programmeur, [http://www.casio-scene.com/member.php?10077-Cartix Cartix] (moi) et [http://www.planet-casio.com/Fr/compte/voir_profil.php?membre=binary_man Binary_Man], de Planete Casio, ont commencé à retravailler sur le projet, dans le but d'ajouter de nouvelles fonctions. Notre première version (CPLua 0.10A) est sortie le 28/01/2012, et est disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici]<br />
<br />
==Mise en route==<br />
* Premièrement, télécharger la version de l'add-in que vous souhaitez :[http://www.casio-scene.com/downloads.php?do=file&id=532 CPLua 0.8] ou [http://www.casio-scene.com/downloads.php?do=file&id=533 CPLua 0.10A]<br />
* Envoyez ensuite le .cpa à votre classpad avec FA-CP1 ou Classpad Add-In Installer (des tutos seront bientôt disponible)<br />
* Allez au menu principal sur votre Classpad et ouvrez l'application CPLua<br />
* Créez un nouveau fichier et commencez à programmer<br />
<br />
==Librairie== <br />
* UI : Interface utilisateurs : Cette librairie vous permet d'utiliser l'interface utilisateur du Classpad (menu, barre d'outils,…) dans vos programmes<br />
* CAS : Système d'Aglèbre informatique : Cette librairie vous permets d'employer toutes les fonctions mathématiques de l'application "Main" (diff, intg, solve, …)<br />
* Draw : Cette librairie vous permet de dessiner sur l'écran (point, ligne, cercle,…) et pour employer des sprites/images<br />
* IO : Entrée-sortie : Cette librairie vous permet de manipuler les fichiers de votre Classpad (ouvrir, enregistrer, lire,…)<br />
* String : Cette librairie vous permet de manipuler les chaines de caractères<br />
* Debug : Cette librairie vous permet de corriger votre programme<br />
* Table : Cette librairie vous permet de manipuler des listes<br />
* Math : Cette librairie vous permet d'effectuer des opérations sur des nombres (sin, log,…)<br />
Pour connaître toutes les fonctions d'une librairie, "table.foreach (<name du library>, de la copie)"<br />
<br />
==Structures de Controle==<br />
===BOUCLES===<br />
* Vous pouvez casser une boucle avec "break"<br />
====While====<br />
<pre><br />
while <condition 1> do<br />
<code à exécuter tant que la condition 1 est respectée><br />
end<br />
</pre><br />
<br />
====Repeat====<br />
<pre><br />
repeat<br />
<code à exécuter tant que la condition 1 est respectée><br />
until <condition 1><br />
</pre><br />
<br />
====For====<br />
<pre><br />
for <var>=<min>,<max>[,incrément] do<br />
<code à exécuter tant que var est différent de max ><br />
end<br />
</pre><br />
* Si l'incrément n'est pas spécifié, il vaudra automatiquement 1<br />
<br />
===IF===<br />
<pre><br />
if <condition 1> then<br />
<code à exécuter si la condition 1 est respectée><br />
elseif <condition 2> then<br />
<code à exécuter si la condition 1 est respectée et la condition 1 est respectée><br />
else<br />
<code à exécuter si aucune des conditions n'est respéctée><br />
end<br />
</pre><br />
<br />
===Déclaration d'une fonction===<br />
<pre><br />
function <nom de la fonction>(<liste des paramètres>)<br />
<code à exécuter si la fonction est appelée><br />
return <valeur à retourner><br />
end<br />
</pre><br />
* Si la valeur à retourner n'est pas spécifiée, la fonction ne renverra rien<br />
* Si aucun paramètre n'est spécifié, la fonction fonctionnera sans paramètre<br />
* On peut déclarer des variables locales dans les fonctions, utilisable uniquement par la fonction dans laquelle elles ont étés déclarées<br />
<br />
===Comentaires===<br />
<pre><br />
--<commentaire> pour un commentaire d'une ligne<br />
--[[<commentaire>]]-- pour un commentaire de plusieurs lignes<br />
</pre><br />
<br />
==Fonctions spécifiques à CPLua==<br />
CPLua a deux écran différents : la console (pour les entrées/sorties) et l'écran graphique (pour dessiner). Par défaut, un programme affiche la console. On peut passer de l'un à l'autre à l'aide de<br />
* showconsole() pour afficher la console<br />
* showgraph() pour afficher l'écran graphique<br />
Il y a de nombreuse autres fonctions spécifiques telles que :<br />
* keypad(0/1) : 0 pour masque le clavier et 1 pour l'afficher<br />
* fullscreen(0/1) : 0 pour afficher la barre de menu 1 pour la masquer<br />
Pour connaitre toutes les fonctions spécifiques et leur syntaxes, regarder [http://orwell01.free.fr/Release/CPLua/functions.txt ici]<br />
<br />
==Lien utiles==<br />
* [http://www.lua.org/ Site officiel du Lua]<br />
* [http://calc-casio.e-monsite.com/pages/librairie/cplua/ Librairies supplémentaires]<br />
* [http://orwell01.free.fr/Release/CPLua/functions.txt Liste des fonctions spécifiques]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPLua&diff=232CPLua2012-06-16T10:14:17Z<p>Cartix : </p>
<hr />
<div>La langue de Lua est un juste milieu entre le CPBasic et le C++. Ce langage de programmation est simple, flexible et rapide. Il permettent aux développeurs de créer des programmes complexes impossibles à écrire en CPBasic. CPLua est un add-in pour ClassPad qui incluent un interprèter Lua et à beaucoup de nouvelles fonctions et vous permet de programmer en Lua on-calc. <br />
<br />
CPLua est un projet donc quelques bogues peuvent apparaître. La version la plus stable est actuellement la version 0.8 version. La dernière version est la version 0.10A disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici].<br />
<br />
__TOC__<br />
<br />
==Histoire== <br />
CPLua a été commencé en 2005 par Julien, un programmeur français, parce qu'il y avait trop de personnes qui se plaignaient de la lenteur du CPBasic mais ne voulaient pas apprendre le C++.<br />
* 01/09/2005 : la première version a été publiée [http://casiocalto.free.fr/Forum/viewtopic.php?t=611 ici].<br />
* 07/09/2005 : version 0.4 : ajout de la possibilité sauver/ouvrir des script Lua<br />
* 08-09/2005 : version 0.51 : correction de certains bugs et ajout d'un nouveau clavier<br />
* 27/09/2005 : version 0.72 : ajout de la totalité du paquet de CAS<br />
* 19/04/2006 : version 0.8 : version la plus rapide (en dessin) de CPLua. Téléchargez-la [http://www.casio-scene.com/downloads.php?do=file&id=532 ici]<br />
* 07-27-2007 : version 0.9E : la dernière version faite par Orwell (ajout de la bibliothèque UI)<br />
L'année dernière, deux programmeur, [http://www.casio-scene.com/member.php?10077-Cartix Cartix] (moi) et [http://www.planet-casio.com/Fr/compte/voir_profil.php?membre=binary_man Binary_Man], de Planete Casio, ont commencé à retravailler sur le projet, dans le but d'ajouter de nouvelles fonctions. Notre première version (CPLua 0.10A) est sortie le 28/01/2012, et est disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici]<br />
<br />
==Mise en route==<br />
* Premièrement, télécharger la version de l'add-in que vous souhaitez :[http://www.casio-scene.com/downloads.php?do=file&id=532 CPLua 0.8] ou [http://www.casio-scene.com/downloads.php?do=file&id=533 CPLua 0.10A]<br />
* Envoyez ensuite le .cpa à votre classpad avec FA-CP1 ou Classpad Add-In Installer (des tutos seront bientôt disponible)<br />
* Allez au menu principal sur votre Classpad et ouvrez l'application CPLua<br />
* Créez un nouveau fichier et commencez à programmer<br />
<br />
==Librairie== <br />
* UI : Interface utilisateurs : Cette librairie vous permet d'utiliser l'interface utilisateur du Classpad (menu, barre d'outils,…) dans vos programmes<br />
* CAS : Système d'Aglèbre informatique : Cette librairie vous permets d'employer toutes les fonctions mathématiques de l'application "Main" (diff, intg, solve, …)<br />
* Draw : Cette librairie vous permet de dessiner sur l'écran (point, ligne, cercle,…) et pour employer des sprites/images<br />
* IO : Entrée-sortie : Cette librairie vous permet de manipuler les fichiers de votre Classpad (ouvrir, enregistrer, lire,…)<br />
* String : Cette librairie vous permet de manipuler les chaines de caractères<br />
* Debug : Cette librairie vous permet de corriger votre programme<br />
* Table : Cette librairie vous permet de manipuler des listes<br />
* Math : Cette librairie vous permet d'effectuer des opérations sur des nombres (sin, log,…)<br />
Pour connaître toutes les fonctions d'une librairie, "table.foreach (<name du library>, de la copie)"<br />
<br />
==Structures de Controle==<br />
===BOUCLES===<br />
* Vous pouvez casser une boucle avec "break"<br />
====While====<br />
<pre><br />
while <condition 1> do<br />
<code à exécuter tant que la condition 1 est respectée><br />
end<br />
</pre><br />
<br />
====Repeat====<br />
<pre><br />
repeat<br />
<code à exécuter tant que la condition 1 est respectée><br />
until <condition 1><br />
</pre><br />
<br />
====For====<br />
<pre><br />
for <var>=<min>,<max>[,incrément] do<br />
<code à exécuter tant que var est différent de max ><br />
end<br />
</pre><br />
* Si l'incrément n'est pas spécifié, il vaudra automatiquement 1<br />
<br />
===IF===<br />
<pre><br />
if <condition 1> then<br />
<code à exécuter si la condition 1 est respectée><br />
elseif <condition 2> then<br />
<code à exécuter si la condition 1 est respectée et la condition 1 est respectée><br />
else<br />
<code à exécuter si aucune des conditions n'est respéctée><br />
end<br />
</pre><br />
<br />
===Déclaration d'une fonction===<br />
<pre><br />
function <nom de la fonction>(<liste des paramètres>)<br />
<code à exécuter si la fonction est appelée><br />
return <valeur à retourner><br />
end<br />
</pre><br />
* Si la valeur à retourner n'est pas spécifiée, la fonction ne renverra rien<br />
* Si aucun paramètre n'est spécifié, la fonction fonctionnera sans paramètre<br />
* On peut déclarer des variables locales dans les fonctions, utilisable uniquement par la fonction dans laquelle elles ont étés déclarées<br />
<br />
===Comentaires===<br />
<pre><br />
--<commentaire> pour un commentaire d'une ligne<br />
--[[<commentaire>]]-- pour un commentaire de plusieurs lignes<br />
</pre><br />
<br />
==Fonctions spécifiques à CPLua==<br />
CPLua a deux écran différents : la console (pour les entrées/sorties) et l'écran graphique (pour dessiner). Par défaut, un programme affiche la console. On peut passer de l'un à l'autre à l'aide de<br />
* showconsole() pour afficher la console<br />
* showgraph() pour afficher l'écran graphique<br />
Il y a de nombreuse autres fonctions spécifiques telles que :<br />
* keypad(0/1) : 0 pour masque le clavier et 1 pour l'afficher<br />
* fullscreen(0/1) : 0 pour afficher la barre de menu 1 pour la masquer<br />
Pour connaitre toutes les fonctions spécifiques et leur syntaxes, regarder [http://orwell01.free.fr/Release/CPLua/functions.txt ici]<br />
<br />
==Lien utiles==<br />
* [http://www.lua.org/ Site officiel du Lua]<br />
* [http://calc-casio.e-monsite.com/pages/librairie/cplua/ Librairies supplémentaires]<br />
* [http://orwell01.free.fr/Release/CPLua/functions.txt Liste des fonctions spécifiques]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=CPLua&diff=231CPLua2012-06-16T10:09:25Z<p>Cartix : Page créée avec « La langue de Lua est un juste milieu entre le CPBasic et le C++. Ce langage de programmation est simple, flexible et rapide. Il permettent aux développeurs de créer des ... »</p>
<hr />
<div>La langue de Lua est un juste milieu entre le CPBasic et le C++. Ce langage de programmation est simple, flexible et rapide. Il permettent aux développeurs de créer des programmes complexes impossibles à écrire en CPBasic. CPLua est un add-in pour ClassPad qui incluent un interprèter Lua et à beaucoup de nouvelles fonctions et vous permet de programmer en Lua on-calc. <br />
<br />
CPLua est un projet donc quelques bogues peuvent apparaître. La version la plus stable est actuellement la version 0.8 version. La dernière version est la version 0.10A disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici].<br />
<br />
__TOC__<br />
<br />
==Histoire== <br />
CPLua a été commencé en 2005 par Julien, un programmeur français, parce qu'il y avait trop de personnes qui se plaignaient de la lenteur du CPBasic mais ne voulaient pas apprendre le C++.<br />
* 01/09/2005 : la première version a été publiée [http://casiocalto.free.fr/Forum/viewtopic.php?t=611 ici].<br />
* 07/09/2005 : version 0.4 : ajout de la possibilité sauver/ouvrir des script Lua<br />
* 08-09/2005 : version 0.51 : correction de certains bugs et ajout d'un nouveau clavier<br />
* 27/09/2005 : version 0.72 : ajout de la totalité du paquet de CAS<br />
* 19/04/2006 : version 0.8 : version la plus rapide (en dessin) de CPLua. Téléchargez-la [http://www.casio-scene.com/downloads.php?do=file&id=532 ici]<br />
* 07-27-2007 : version 0.9E : la dernière version faite par Orwell (ajout de la bibliothèque UI)<br />
L'année dernière, deux programmeur, [http://www.casio-scene.com/member.php?10077-Cartix Cartix] (moi) et [http://www.planet-casio.com/Fr/compte/voir_profil.php?membre=binary_man Binary_Man], de Planete Casio, ont commencé à retravailler sur le projet, dans le but d'ajouter de nouvelles fonctions. Notre première version (CPLua 0.10A) est sortie le 28/01/2012, et est disponible [http://www.casio-scene.com/downloads.php?do=file&id=533 ici]<br />
<br />
==Mise en route==<br />
* Premièrement, télécharger la version de l'add-in que vous souhaitez :[http://www.casio-scene.com/downloads.php?do=file&id=532 CPLua 0.8] ou [http://www.casio-scene.com/downloads.php?do=file&id=533 CPLua 0.10A]<br />
* Envoyez ensuite le .cpa à votre classpad avec FA-CP1 ou Classpad Add-In Installer (des tutos seront bientôt disponible)<br />
* Allez au menu principal sur votre Classpad et ouvrez l'application CPLua<br />
* Créez un nouveau fichier et commencez à programmer<br />
<br />
==Librairie== <br />
* UI : Interface utilisateurs : Cette librairie vous permet d'utiliser l'interface utilisateur du Classpad (menu, barre d'outils,…) dans vos programmes<br />
* CAS : Système d'Aglèbre informatique : Cette librairie vous permets d'employer toutes les fonctions mathématiques de l'application "Main" (diff, intg, solve, …)<br />
* Draw : Cette librairie vous permet de dessiner sur l'écran (point, ligne, cercle,…) et pour employer des sprites/images<br />
* IO : Entrée-sortie : Cette librairie vous permet de manipuler les fichiers de votre Classpad (ouvrir, enregistrer, lire,…)<br />
* String : Cette librairie vous permet de manipuler les chaines de caractères<br />
* Debug : Cette librairie vous permet de corriger votre programme<br />
* Table : Cette librairie vous permet de manipuler des listes<br />
* Math : Cette librairie vous permet d'effectuer des opérations sur des nombres (sin, log,…)<br />
Pour connaître toutes les fonctions d'une librairie, "table.foreach (<name du library>, de la copie)"<br />
<br />
==Structures de Controle==<br />
===BOUCLES===<br />
* Vous pouvez casser une boucle avec "break"<br />
====While====<br />
<pre><br />
while <condition 1> do<br />
<code à exécuter tant que la condition 1 est respectée><br />
end<br />
</pre><br />
<br />
====Repeat====<br />
<pre><br />
repeat<br />
<code à exécuter tant que la condition 1 est respectée><br />
until <condition 1><br />
</pre><br />
<br />
====For====<br />
<pre><br />
for <var>=<min>,<max>[,incrément] do<br />
<code à exécuter tant que var est différent de max ><br />
end<br />
</pre><br />
* Si l'incrément n'est pas spécifié, il vaudra automatiquement 1<br />
<br />
===IF Statement===<br />
<pre><br />
if <condition 1> then<br />
<code à exécuter si la condition 1 est respectée><br />
elseif <condition 2> then<br />
<code à exécuter si la condition 1 est respectée et la condition 1 est respectée><br />
else<br />
<code à exécuter si aucune des conditions n'est respéctée><br />
end<br />
</pre><br />
<br />
===FUNCTION Statement===<br />
<pre><br />
function <nom de la fonction>(<liste des paramètres>)<br />
<code à exécuter si la fonction est appelée><br />
return <valeur à retourner><br />
end<br />
</pre><br />
* Si la valeur à retourner n'est pas spécifiée, la fonction ne renverra rien<br />
* Si aucun paramètre n'est spécifié, la fonction fonctionnera sans paramètre<br />
* On peut déclarer des variables locales dans les fonctions, utilisable uniquement par la fonction dans laquelle elles ont étés déclarées<br />
<br />
===COMMENT Statement===<br />
<pre><br />
--<commentaire> pour un commentaire d'une ligne<br />
--[[<commentaire>]]-- pour un commentaire de plusieurs lignes<br />
</pre></div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Accueil&diff=230Accueil2012-06-16T09:18:05Z<p>Cartix : </p>
<hr />
<div>{{MsgBox |title=Bienvenue sur Casio Universal Wiki !|text=Retourner vers [http://casio-scene.com casio-scene.com] ?}}<br />
<br />
<br/>[[Comment écrire un article pour Casio Universal Wiki?]]<br />
<br />
<table id="homePageTable"><!--for edit style of the table, edit http://wiki.casio-scene.com/en/MediaWiki:Common.css--><br />
<tr id="homePageTableTop"><br />
<th width="1%" rowspan="2" style="border-radius: 10px 0 0 0;border-left: 1px solid #a7d7f9 !important;">[[File:Text-Catégories.png|link=:Catégorie:Catégories des calculatrices]]</th><br />
<th width="19%">[[:Catégorie:Calculatrices Basic|Basic]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Basic et C/ASM|Basic et C/ASM]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Classpad|Classpad]]</th><br />
<th width="20%" style="border-radius: 0 10px 0 0;">[[:Catégorie:Calculatrices Prizm|Prizm]]</th><br />
</tr><br />
<tr><br />
<td><center>[[File:GRAPH_35+_USB-h100.jpg|link=Graph 35+ USB]]</center></td><br />
<td>&nbsp;</td><br />
<td>&nbsp;</td><br />
<td>&nbsp;</td><br />
</tr><br />
<tr><br />
<th>[[File:text-Modèles.png|link=Catégorie:Calculatrices_Casio|Voir toutes les calculatrices]]</th><br />
<td><br />
<ul><br />
<li>Graph 25+ PRO</li><br />
<li>[[Graph 35+ USB]]</li><br />
<li>Graph 65</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 75</li><br />
<li>Graph 85</li><br />
<li>Graph 100+</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Classpad 300</li><br />
<li>Classpad 300+</li><br />
<li>Classpad 330</li><br />
<li>Classpad 330+</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Fx-Cg10</li><br />
<li>Fx-Cg20</li><br />
</ul><br />
</td> <br />
</tr><br />
<br />
<tr><br />
<th>[[File:text-Basic_Casio.png|link=Basic_Casio]]</th><br />
<td></td><br />
<td></td><br />
<td></td><br />
<td></td><br />
</tr><br />
<tr><br />
<th>[[File:text-C_ASM.png|link=Langage C]]</th><br />
<td></td><br />
<td></td><br />
<td></td><br />
<td></td><br />
</tr><br />
<tr><br />
<th style="border-radius: 0 0 0 10px;">[[File:Text-Dev. Alternatif.png|link=Développement Alternatif]]</th><br />
<td></td><br />
<td></td><br />
<td>[[CPLua]]</td><br />
<td style="border-radius: 0 0 10px 0;"></td><br />
</tr><br />
</table><br />
<br />
Page en cours de construction...<br />
<br/><br />
[[en:Main_Page]]</div>Cartixhttps://wiki.planet-casio.com/fr/index.php?title=Accueil&diff=229Accueil2012-06-16T09:17:39Z<p>Cartix : </p>
<hr />
<div>{{MsgBox |title=Bienvenue sur Casio Universal Wiki !|text=Retourner vers [http://casio-scene.com casio-scene.com] ?}}<br />
<br />
<br/>[[Comment écrire un article pour Casio Universal Wiki?]]<br />
<br />
<table id="homePageTable"><!--for edit style of the table, edit http://wiki.casio-scene.com/en/MediaWiki:Common.css--><br />
<tr id="homePageTableTop"><br />
<th width="1%" rowspan="2" style="border-radius: 10px 0 0 0;border-left: 1px solid #a7d7f9 !important;">[[File:Text-Catégories.png|link=:Catégorie:Catégories des calculatrices]]</th><br />
<th width="19%">[[:Catégorie:Calculatrices Basic|Basic]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Basic et C/ASM|Basic et C/ASM]]</th><br />
<th width="20%">[[:Catégorie:Calculatrices Classpad|Classpad]]</th><br />
<th width="20%" style="border-radius: 0 10px 0 0;">[[:Catégorie:Calculatrices Prizm|Prizm]]</th><br />
</tr><br />
<tr><br />
<td><center>[[File:GRAPH_35+_USB-h100.jpg|link=Graph 35+ USB]]</center></td><br />
<td>&nbsp;</td><br />
<td>&nbsp;</td><br />
<td>&nbsp;</td><br />
</tr><br />
<tr><br />
<th>[[File:text-Modèles.png|link=Catégorie:Calculatrices_Casio|Voir toutes les calculatrices]]</th><br />
<td><br />
<ul><br />
<li>Graph 25+ PRO</li><br />
<li>[[Graph 35+ USB]]</li><br />
<li>Graph 65</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Graph 75</li><br />
<li>Graph 85</li><br />
<li>Graph 100+</li><br />
</ul><br />
</td> <br />
<td><br />
<ul><br />
<li>Classpad 300</li><br />
<li>Classpad 300+</li><br />
<li>Classpad 330</li><br />
<li>Classpad 330+</li><br />
</ul><br />
</td><br />
<td><br />
<ul><br />
<li>Fx-Cg10</li><br />
<li>Fx-Cg20</li><br />
</ul><br />
</td> <br />
</tr><br />
<br />
<tr><br />
<th>[[File:text-Basic_Casio.png|link=Basic_Casio]]</th><br />
<td></td><br />
<td></td><br />
<td></td><br />
<td></td><br />
</tr><br />
<tr><br />
<th>[[File:text-C_ASM.png|link=Langage C]]</th><br />
<td></td><br />
<td></td><br />
<td></td><br />
<td></td><br />
</tr><br />
<tr><br />
<th style="border-radius: 0 0 0 10px;">[[File:Text-Dev. Alternatif.png|link=Développement Alternatif]]</th><br />
<td></td><br />
<td>[[CPLua]]</td><br />
<td></td><br />
<td style="border-radius: 0 0 10px 0;"></td><br />
</tr><br />
</table><br />
<br />
Page en cours de construction...<br />
<br/><br />
[[en:Main_Page]]</div>Cartix