Basic Casio : Différence entre versions

De Casio Universal Wiki
Aller à : navigation, rechercher
(→‎Aller plus loin)
(Ajout d'un lien vers le tutoriel de programmation de Totoyo.)
 
(19 révisions intermédiaires par le même utilisateur non affichées)
Ligne 1 : Ligne 1 :
−
== Présentation du Basic Casio ==
+
== Présentation ==
  
−
Le Basic Casio est un langage de programmation simple destiné à la programmation d'algorithmes basiques voir plus complexes par des étudiants ne possédant pas une formation spécialisée.
+
Le Basic Casio est un langage de programmation simple, dérivé du Basic. Il est destiné à la programmation d'algorithmes et de programmes basiques par des étudiants ne possédant pas une formation spécialisée.
−
C'est un langage interprété, c'est à dire qu'il est "lu" par un programme spécial pour fonctionner.
+
C'est un langage interprété, c'est à dire qu'il est la calculatrice lit les programmes au fur et à mesure qu'elle les exécute. Cela s'oppose aux langages compilés comme le C ou le Lua, qui sont traités (« compilés ») à l'avance.
−
Les calculatrices Casio possèdent le même langage, mais qui peut ne pas être compatibles entre certaines calculatrice, comme la Prizm (FX-CG10/20), ou encore la Classpad.
 
  
−
Le Basic Casio, initialement destiné aux algorithmes, a vite été détourné afin de programmer des jeux sur les calculatrices. Toutefois, l'interprétation du basic reste beaucoup plus lente que celle du Lua (voir LuaFx) ou du C ([http://wiki.planet-casio.com/fr/SDK SDK]).
+
Le Basic Casio existe sur quasiment toutes les calculatrices Casio modernes, mais il y a des différences, par exemple entre la Graph 35+E, la Graph 90+E ou encore la Classpad. Un certain niveau de compatibilité existe (notamment quand des programmes pour Graph 35+E sont transférés à une Graph 90+E), mais porter un programme n'est jamais gagné d'avance.
  
−
C'est pour cela que les jeux en basic les plus agréables sont les jeux de réflexion, où la lenteur du Basic n'est pas gênante.
+
Initialement destiné à la programmation d'algorithmes en classe, le Basic Casio a vite été détourné pour programmer des jeux sur les calculatrices. L'interprétation (c'est-à-dire l'exécution) des programmes Basic reste beaucoup plus lente que celle du Lua (voir LuaFx), et encore plus que celle des add-ins en C (voir le système de développement des [http://wiki.planet-casio.com/fr/SDK SDK]).
  
 +
Ainsi, les bons jeux en Basic sont ceux qui parviennent à s'accomoder des difficultés de vitesse, généralement des jeux de réflexion ou au tour-par-tour.
  
−
== Créer un nouveau programme ==
+
== Tutoriel de programmation Basic ==
  
−
A partir du menu de la calculatrice, aller dans '''"PRGM"''' (ou taper "B"). Les onglets qui apparaissent en bas de la fenêtre permettent de gérer les programmes (EXE = exécuter, EDIT = éditer, NEW = nouveau, DEL = supprimer, DEL-A = supprimer tous les programmes, SRC = rechercher, REN = renommer).
+
Le tutoriel de programmation en Basic de Totoyo est disponible sur Planète Casio : [https://www.planet-casio.com/Fr/programmation/ Cours, Tutoriel de programmation Basic pour calculatrices Casio (v2)]
−
En appuyant sur [F3], on crée un nouveau programme. "base" permet de créer un programme base, et le symbole de la clé donne la possibilité d'ajouter un code d'accès.
 
  
 +
== Le menu de l'application PRGM ==
  
−
== Débuter en basic Casio ==
+
La programmation en Basic se fait dans le menu PRGM (touche <code>[9]</code> pour les anciennes Graph 35+USB, <code>[A]</code> pour les Graph 35+E et <code>[B]</code> pour les Graph supérieure). Les onglets qui apparaissent en bas de la fenêtre permettent de gérer les programmes :
 +
 
 +
* EXE  : Lancer le programme sélectionné.
 +
* EDIT  : Ouvre l'éditeur de code pour modifier le programme.
 +
* NEW  : Crée un nouveau programme.
 +
* DEL  : Supprime (après confirmation) le programme sélectionné. Aussi accessible par la touche <code>[DEL]</code> du clavier.
 +
* DEL-A : Supprime (après confirmation) tous les programmes.
 +
* SRC  : Rechercher un programme par son nom.
 +
* REN  : Renomme le programme sélectionné.
  
−
Le Basic Casio possède une multitude d'instructions, les plus élémentaires étant les instructions suivantes. Celles-ci permettent de réaliser des algorithme de base (en mathématiques par exemple).
+
Appuyer sur <code>[F3]</code> permet de créer un nouveau programme. Le bouton <code>BASE</code> permet de créer un programme dit *en mode Base* ; il s'agit d'un type différent de programmes Basic réservé aux calculs de conversions de bases. Le symbole avec la clé permet d'ajouter un code d'accès qui sera demandé à chaque fois que l'utilisateur tentera d'éditer le programme. Le niveau de sécurité est ridicule (on peut le retirer aisément sans recourir à un PC ou à une application externe), mais il permet d'éviter les modifications malencontreuses (surtout quand une erreur se produit et qu'il l'utilisateur incrédule se retrouve face à l'éditeur de code).
  
 +
== Débuter en basic Casio ==
  
−
● L'affichage de données : [[Fichier:DISPLAY.gif]] => [SHIFT][PRGM][F5]
+
Le Basic Casio possède une multitude d'instructions, les plus élémentaires étant les instructions suivantes qui sont utilisées pour réaliser des algorithme de base (par exemples en maths) :
  
−
● La saisie de données : ? => [SHIFT][PRGM][F4]
+
* Affichage la valeur d'un calcul avec le symbole DISP : <code>◢</code> (<code>[SHIFT],[PRGM],[F5]</code>)
 +
* La saisie de données : <code>?</code> (<code>[SHIFT],[PRGM],[F4]</code>)
 +
* Affectation de valeurs aux variables : <code>→</code> (touche <code>[→]</code> située au-dessus de <code>[AC/ON]</code>)
 +
* Affichage du texte à l'écran, avec les guillemets (e.g. <code>"Le résultat est :"</code>). (<code>[ALPHA],[×10^x]</code>)
 +
* Les commentaires de texte avec le symbole <code>'</code> (dure jusqu'à la fin de la ligne)
  
−
● Affecter une valeur à une variable : [[Fichier:arrow.gif]] => touche située au dessus de [AC/ON]
 
  
−
● Afficher du texte à l'écran : "texte à afficher"
 
  
 
== Commandes de base ==
 
== Commandes de base ==
  
  
−
● Les conditions :
+
* Les conditions
  
−
  '''if''' ''Condition''                //On définit la condition                                                 => [SHIFT][VARS][F1][F1]
+
  '''If''' ''Condition''                // On définit la condition                                                           => [SHIFT][VARS][F1][F1]
−
  '''Then''' ''Instructions''          //Les instructions à exécuter si la condition est vraie                   => [SHIFT][VARS][F1][F2]
+
  '''Then''' ''Instructions''          // Les instructions à exécuter si la condition est vraie                             => [SHIFT][VARS][F1][F2]
−
  '''Else''' ''Instructions''          //Facultatif, instructions à exécuter si la condition est fausse         => [SHIFT][VARS][F1][F3]
+
  '''Else''' ''Instructions''          // Facultatif, instructions à exécuter si la condition est fausse                   => [SHIFT][VARS][F1][F3]
−
  '''IfEnd'''                      //Fin de la condition                                                     => [SHIFT][VARS][F1][F4]
+
  '''IfEnd'''                      // Fin de la condition                                                               => [SHIFT][VARS][F1][F4]
  
−
ou
+
''Condition'' '''=>''' ''Instruction''    // Plus rapide mais ne permet d’exécuter qu'une seule instruction                    => [SHIFT][VARS][F3][F3]
  
−
''Condition'' '''=>''' ''Instruction''  //Cette méthode est plus rapide mais ne permet d’exécuter qu'une seule instruction => [SHIFT][VARS][F3][F3]
 
  
 +
* Les boucles
  
−
● Les boucles :
+
'''While''' ''Condition''            // On définit la condition de la boucle                                      => [SHIFT][VARS][F1][F6][F6][F1]
 +
''Instructions''                // Les instructions à exécuter tant que la condition est vraie 
 +
'''WhileEnd'''                    // Fin de la boucle                                                          => [SHIFT][VARS][F1][F6][F6][F2]
  
−
  '''While''' ''Condition''            //On définit la condition de la boucle => [SHIFT][VARS][F1][F6][F6][F1]
+
  '''Do'''                         // Début de la boucle                                                       => [SHIFT][VARS][F1][F6][F6][F3]
−
  ''Instructions''                //Les instructions à exécuter tant que la condition est vraie
+
  ''Instructions''                // Les instructions à exécuter tant que la condition est vraie
−
  '''WhileEnd'''                   //Fin de la boucle => [SHIFT][VARS][F1][F6][F6][F2]
+
  '''LpWhile''' ''Condition''           // On définit la condition de la boucle                                     => [SHIFT][VARS][F1][F6][F6][F4]
  
−
ou
+
La différence entre un boucle "While/WhileEnd" et une boucle "Do/LpWhile" est que, si la condition est fausse depuis le début, une boucle "While/WhileEnd" ne fera aucune itération, tandis qu'une boucle "Do/LpWhile" en fera toujours au moins une.
  
−
'''Do'''                          //Début de la boucle => [SHIFT][VARS][F1][F6][F6][F3]
 
−
''Instructions''                //Les instructions à exécuter tant que la condition est vraie
 
−
'''LpWhile''' ''Condition''          //On définit la condition de la boucle => [SHIFT][VARS][F1][F6][F6][F4]
 
  
−
La différence entre un boucle "While/WhileEnd" et une boucle "Do/LpWhile" est que, si la condition est fausse depuis le début, une boucle "While/WhileEnd" ne fera aucune itération, tandis qu'une boucle "Do/LpWhile" fera toujours au moins une.
+
'''For''' ''Valeur initiale'' [[Fichier:arrow.gif]] ''Variable'' '''To''' ''Valeur finale'' '''Step''' ''Pas''   
 +
''Instructions''                // Les instructions à exécuter pendant la boucle  
 +
'''Next'''                        // Fin de la boucle
  
 +
'''For'''                                                                                                          => [SHIFT][VARS][F1][F6][F1]
 +
'''To'''                                                                                                          => [SHIFT][VARS][F1][F6][F2]
 +
'''Step'''  (Facultatif, 1 par défaut)                                                                            => [SHIFT][VARS][F1][F6][F3]
 +
'''Next'''                                                                                                        => [SHIFT][VARS][F1][F6][F4]
  
−
'''For''' ''valeur initiale'' '''"Flèche vers la droite"''' ''variable utilisée'' '''To''' ''valeur finale'' '''step''' ''pas entre chaque itération''   
 
−
''Instructions''                //Les instructions à exécuter pendant la boucle
 
−
'''Next'''                        //Fin de la boucle
 
  
−
''For                                                        => [SHIFT][VARS][F1][F6][F1]''
+
* Les sauts inconditionnels
  
−
  ''To                                                          => [SHIFT][VARS][F1][F6][F2]''
+
  '''Goto''' ''nombre ou lettre''      // Fait un saut inconditionnel vers le "Lbl" avec le même identifiant                => [SHIFT][VARS][F3][F2]
 +
'''Lbl''' ''nombre ou lettre''        // Marque le point d'arrivée d'un "Goto" avec le même identifiant                    => [SHIFT][VARS][F3][F1]
  
−
''Step          (Facultatif, 1 par défaut)                  => [SHIFT][VARS][F1][F6][F3]''
 
  
−
''Next                                                        => [SHIFT][VARS][F1][F6][F4]''
+
* Les opérateurs relationnels :
  
 +
''Premier terme'' '''=''' ''Second terme''                                                                                => [SHIFT][VARS][F6][F3][F1]
 +
''Premier terme'' '''≠''' ''Second terme''                                                                                => [SHIFT][VARS][F6][F3][F2]
 +
''Premier terme'' '''<''' ''Second terme''                                                                                => [SHIFT][VARS][F6][F3][F4]
 +
''Premier terme'' '''>''' ''Second terme''                                                                                => [SHIFT][VARS][F6][F3][F3]
 +
''Premier terme'' '''≤''' ''Second terme''                                                                                => [SHIFT][VARS][F6][F3][F6]
 +
''Premier terme'' '''≥''' ''Second terme''                                                                                => [SHIFT][VARS][F6][F3][F5]
  
−
●Les sauts inconditionnels :
 
  
−
'''Goto''' ''nombre ou lettre''    //Fait un saut inconditionnel vers le "Lbl" avec le même nombre ou lettre        => [SHIFT][VARS][F3][F2]
+
* Les commandes de contrôle
−
'''Lbl''' ''nombre ou lettre''      //Marque le point d'arrivée d'un "Goto" avec le même nombre ou lettre            => [SHIFT][VARS][F3][F1]
 
  
 +
'''Prog''' ''Nom du programme''      // Exécute un autre programme dont on spécifie le nom comme une sous-routine        => [SHIFT][VARS][F2][F1]
 +
'''Return'''                      // Ramène dans le programme appelant                                                => [SHIFT][VARS][F2][F2]
 +
'''Break'''                      // Force la sortie d'une boucle                                                      => [SHIFT][VARS][F2][F3]
 +
'''Stop'''                        // Arrête l'exécution du programme                                                  => [SHIFT][VARS][F2][F4]
  
−
●Les opérateurs relationnels :
 
  
−
''premier terme de la condition'' "=" ''second terme de la condition''      //La condition est vraie si les deux termes de la condition ont la même valeur => [SHIFT][VARS][F6][F3][F1]
+
* Autres
  
−
  ''premier terme de la condition'' "≠" ''second terme de la condition''       //La condition est vraie si les deux termes de la condition ont des valeurs différentes => [SHIFT][VARS][F6][F3][F2]
+
[[Fichier:getkey.gif|200px|thumb|right|La répartition du Getkey sur Fx-9860]]
 +
  '''Locate''', ''x'', ''y'', ''"Texte"''       // Affiche du texte aux coordonnées spécifiées            => [SHIFT][VARS][F6][F4][F1]
 +
'''GetKey'''                     // Prend une valeur selon la touche pressée              => [SHIFT][VARS][F6][F4][F2]
  
−
''premier terme de la condition'' "<" ''second terme de la condition''      //La condition est vraie si la valeur du premier terme est strictement inférieure à celle de l'autre terme => [SHIFT][VARS][F6][F3][F4]
 
  
−
''premier terme de la condition'' ">" ''second terme de la condition''      //La condition est vraie si la valeur du premier terme est strictement supérieure à celle de l'autre terme => [SHIFT][VARS][F6][F3][F3]
 
  
−
''premier terme de la condition'' "≤" ''second terme de la condition''      //La condition est vraie si la valeur du premier terme est inférieure ou égale à celle de l'autre terme => [SHIFT][VARS][F6][F3][F6]
+
== Commandes avancées ==
  
−
''premier terme de la condition'' "≥" ''second terme de la condition''      //La condition est vraie si la valeur du premier terme est supérieure ou égale à celle de l'autre terme => [SHIFT][VARS][F6][F3][F5]
+
* Les opérateurs logiques:
  
 +
Ceux-ci servent à relier deux conditions ou plus pour n'en faire qu'une. Elles se situent dans l'onglet "LOGIC".
  
−
●Les comandes programme :
+
''C1'' '''And''' ''C2''      // Est vrai ssi les deux paramètres sont non nuls                      =>  [OPTN][F6][F6][F4][F1]
 +
''C1'' '''Or''' ''C2''        // Est vrai ssi au moins l'un des deux paramètres est non nul          =>  [OPTN][F6][F6][F4][F2]
 +
'''Not''' ''C''          // Est vrai ssi le paramètre est nul                                    =>  [OPTN][F6][F6][F4][F3]
 +
''C1'' '''Xor''' ''C2''      // Est vrai ssi un et un seul des deux paramètres est non nul          =>  [OPTN][F6][F6][F4][F4]
 +
Les paramètres non nuls sont soit des variables dont la valeur est différente de 0, soit des expressions conditionnelles vraies. On peut donc utiliser le résultat d'une condition logique en paramètre d'une autre.
  
−
'''Prog''' ''Nom du programme''      //Exécute un autre programme dont on spécifie le nom comme une sous-routine => [SHIFT][VARS][F2][F1]
 
−
 
−
'''Return'''                      //Dans un programme exécuté par intermédiaire d'un "Prog", cette instruction permet de revenir dans le programme d'origine => [SHIFT][VARS][F2][F2]
 
  
−
'''Break'''                     //Fait sortir d'une boucle "While/WhileEnd", "Do/LpWhile" ou "For/To/Next" => [SHIFT][VARS][F2][F3]
+
* Les chaînes de caractères (Strings)
 +
''Disponibles uniquement sur les calculatrices disposant d'une version de l'OS supérieur à 2''
  
−
'''Stop'''                      //Arrête l'exécution du programme => [SHIFT][VARS][F2][F4]
+
Les chaînes de caractères permettent d'insérer du texte dans des variables spéciales, les Strings (Str). Le Basic Casio dispose aussi de fonctions permettant de les manipuler.
  
 +
'''Str''' ''Identifiant (1[[Fichier:arrow.gif]]6)''      // Permet d'accéder à une chaîne à la manière des listes                                    => [VARS][F6][F5]
  
−
●Autres :
 
  
−
[[Fichier:getkey.gif|200px|thumb|right|La répartition du Getkey sur Fx-9860]]
 
−
'''Locate''', ''coordonnée en abscisse'', ''coordonné en ordonnée'', ''"texte à afficher"''      // Affiche du texte au coordonnées spécifiées (l'écran texte de toutes les calculatrices Casio possède 21 colonnes et 7 lignes)
 
−
=> [SHIFT][VARS][F6][F4][F1]
 
  
−
'''GetKey'''      //Prend une valeur qui correspond à la touche pressée => [SHIFT][VARS][F6][F4][F2]
+
== Commandes graphiques ==
  
  
 +
=== Les repères d'affichage ===
  
−
== Commandes avancées ==
+
Le Basic Casio permet de gérer deux écran. Le premier est l'écran de texte, qui a 21 colonnes, 7 lignes, et dans lequel on affiche du texte avec la commande '''Locate'''. Le second est l'écran graphique, qui permet de contrôler chaque pixel indépendamment. Il a 127 colonnes et 63 lignes (les dimensions de l'écran, dont une colonne et une ligne sont inaccessibles). Ces deux écrans sont indépendants et on peut pas afficher le contenu des deux en même temps.
  
−
●Les opérateurs logiques:
+
L'écran graphique utilise deux repères pour l'affichage.
 +
* Le premier est le repère du graphique, dans lequel sont tracées les courbes. Ce repère est défini par la commande ViewWindow.
 +
* Le second est le repère statique de l'écran. Chaque pixel a des coordonnées entières, et la valeur pour y=0 se trouve en haut de l'écran. Toutes les coordonnées y sont positives.
  
−
Ceux-ci servent à relier deux conditions ou plus pour n'en faire qu'une. Elles se situent dans l'onglet "LOGIC".
 
  
−
'''And'''                      // La condition est vraie si les deux conditions sont vraies  =>  [OPTN][F6][F6][F4][F1]
+
=== Préparer l'écran pour le programme ===
−
'''Or'''                        // La condition est vraie si au moins l'une des deux conditions est vraie  =>  [OPTN][F6][F6][F4][F2]
 
−
'''Not'''                        // La condition est vraie si la condition suivant l'opérateur est fausse (inverse la condition) =>  [OPTN][F6][F6][F4][F3]
 
−
'''Xor'''                        // La condition est vraie si au moins l'une des deux conditions est fausse  =>  [OPTN][F6][F6][F4][F4]
 
  
 +
Les commandes utilisées pour préparer l'écran graphique sont les suivantes.
  
−
●Les chaînes de caractères (Strings): ''Disponibles uniquement sur les calculatrices disposant d'une version de l'OS supérieur à 2''
+
  '''ViewWindow''' ''Xmin'', ''Xmax'', ''Xscale'', ''Ymin'', ''Ymax'', ''Yscale''                                                                      => [SHIFT][F3][F1]
 +
La commande '''ViewWindow''' définit les dimensions du repère graphique. Comme de nombreuses fonctions l'utilisent plutôt que le repère statique, il est utile de le définir au plus près de ce dernier.
 +
'''ViewWindow''' 1,127,1,1,63,1
  
−
Les chaînes de caractères permettent d'insérer du texte dans des variables spéciales, les strings. Le Basic dispose aussi de fonctions permettant de modifier ces chaînes.
+
Il est aussi recommandé d'enlever les axes, la grille et autres afin d'avoir un écran blanc.
  
−
'''Str + 1 à 6'''       // Variables contenant les strings. "Str" est à lier avec un chiffre de 1 à 6 pour différencier les 6 chaînes utilisables => [VARS][F6][F5]
+
'''CoordOff'''                                                                                                         => [SHIFT][MENU][F2][F2]
 +
'''GridOff'''                                                                                                          => [SHIFT][MENU][F3][F2]
 +
'''AxesOff'''                                                                                                          => [SHIFT][MENU][F4][F2]
 +
'''LabelOff'''                                                                                                        => [SHIFT][MENU][F5][F2]
  
  
−
== Commandes graphiques ==
+
=== Dessiner à l'écran graphique ===
  
−
On pourrait dire que dans le Casio-BASIC il y a deux écrans, le premier est l'écran texte, qui a 21 colonnes, 7 lignes, et affiche du texte avec la commande "Locate". Le second est l'écran graphique, qui permet de contrôler chaque pixel indépendamment. Il a 127 colonnes et 63 lignes (les dimensions de l'écran, dont une colonne et une ligne sont inaccessibles). Ces deux écrans sont indépendants et on peut pas afficher le contenu des deux en même temps. Les commandes utilisées pour afficher dans cet écran sont les suivantes:
+
Les fonctions utilisées pour dessiner à l'écran graphique sont les suivantes.
  
−
  '''ViewWindow''' ''valeur minimale en x, valeur maximale en x, échelle en x, valeur minimale en y, valeur maximale en y, échelle en y''       //Défini les dimensions de l'écran graphique. Pour pouvoir obtenir toutes les coordonnées des pixels sous la forme de nombres entiers, il est recommandé de la définir comme ceci: '''ViewWindow''' 1, 127, 0, 1, 63, 0 => [SHIFT] [F3] [F1]
+
  '''Cls'''                        // Efface l'écran graphique                                                                => [SHIFT][F4][F1]
 +
'''PlotOn''' ''x'', ''y''                // Allume le pixel aux coordonnées spécifiées                                      => [SHIFT][F4][F6][F1][F2]
 +
'''PlotOff''' ''x'', ''y''                // Éteint le pixel aux coordonnées spécifiées                                      => [SHIFT][F4][F6][F1][F3]
 +
'''PlotChg''' ''x'', ''y''               // Inverse l'état du pixel aux coordonnées spécifiées                              => [SHIFT][F4][F6][F1][F4]
 +
'''Line'''                        // Trace une ligne entre 2 pixels allumés avec PlotOn                              => [SHIFT][F4][F6][F2][F1]
 +
'''F-Line''' ''x1'', ''y1'', ''x2'', ''y2''      // Trace une ligne entre les points spécifiés                                      => [SHIFT][F4][F6][F2][F2]
 
   
 
   
−
Il est aussi recommandé d'enlever les axes, la grille et autres afin d'avoir un écran blanc
+
'''PxlOn''' ''x'', ''y''                  // Allume le pixel aux coordonnées spécifiées                                  => [SHIFT][F4][F6][F6][F3][F1]
 +
'''PxlOff''' ''x'', ''y''                // Éteint le pixel aux coordonnées spécifiées                                  => [SHIFT][F4][F6][F6][F3][F2]
 +
'''PxlChg''' ''x'', ''y''                // Inverse l'état du pixel aux coordonnées spécifiées                          => [SHIFT][F4][F6][F6][F3][F3]
 +
 
 +
Les commandes Plot, Line ainsi que F-Line utilisent le repère du graphe. <br />
 +
Les commandes Pxl utilisent le repère statique de l'écran.
 +
 
 +
 
 +
=== Utiliser les Pictures ===
 +
 
 +
Il est possible de stocker le contenu d'un écran graphique dans la mémoire sous la forme d'une Picture, puis de le rappeler. Ceci n'efface pas l'écran.
 +
 
 +
'''StoPict''' ''p''                  // Stocke l'écran graphique dans la Picture ''p''                                      => [OPTN][F6][F6][F2][F1]
 +
'''RclPict''' ''p''                  // Affiche à l'écran graphique le contenu de la Picture ''p''                          => [OPTN][F6][F6][F2][F2]
  
−
'''Cls'''      //Efface l'écran graphique => [SHIFT] [F4] [F1]
 
−
'''PlotOn''' ''coordonnée en x, cordonnée en y''      //allume un pixel aux coordonnées spécifiées => [SHIFT] [F4] [F6] [F1] [F2]
 
−
'''PlotOff''' ''coordonnée en x, cordonnée en y''      //éteint un pixel aux coordonnées spécifiées => [SHIFT] [F4] [F6] [F1] [F3]
 
−
'''PlotChg''' ''coordonnée en x, cordonnée en y''      //change l'état d'un pixel aux coordonnées spécifiées, c'est à dire que s'il est éteint il l'allume et s'il est allumé il l'éteint => [SHIFT] [F4] [F6] [F1] [F4]
 
−
'''PxlOn''' ''coordonnée en x, cordonnée en y''      //allume un pixel aux coordonnées spécifiées => [SHIFT] [F4] [F6] [F6] [F3] [F1]
 
−
'''PxlOff''' ''coordonnée en x, cordonnée en y''      //éteint un pixel aux coordonnées spécifiées => [SHIFT] [F4] [F6] [F6] [F3] [F2]
 
−
'''PxlChg''' ''coordonnée en x, cordonnée en y''      //change l'état d'un pixel aux coordonnées spécifiées, c'est à dire que s'il est éteint il l'allume et s'il est allumé il l'éteint => [SHIFT] [F4] [F6] [F6] [F3] [F3]
 
  
−
La différence entre les commandes Plot et les commandes Pixel est que, dans l'axe des ordonnées pour les commandes Plot l'origine est au en bas de l'écran, et pour les commandes Pixel il est en haut de l'écran. De plus, dans les commandes Plot le repère est la ViewWindow, Tandis que les commandes Pixel ont un repère indépendant
+
=== Utiliser les Captures ===
 +
 
 +
Les Captures sont des captures d'écran réalisées par le système lorsque vous appuyez sur [SHIFT][7]. Vous pouvez les utiliser pour afficher des images également, et elles ont l'avantage d'être deux fois mois lourdes que les Picture.
 +
 
 +
'''RclCapt''' ''p''                   // Affiche à l'écran graphique le contenu de la Capture ''p''                          => [OPTN][F6][F6][F5][F1]
 +
 
 +
Cependant, on ne peut dessiner par-dessus une Capture.
  
 
== Aller plus loin ==
 
== Aller plus loin ==
 
[http://www.planet-casio.com/Fr/programmation/tutoriels.php Tutoriels de qualité]
 
[http://www.planet-casio.com/Fr/programmation/tutoriels.php Tutoriels de qualité]
  
−
 
+
[[Catégorie:Basic]]
−
''Page non finie...''
+
[[Catégorie:Langages de programmation]]

Version actuelle datée du 10 janvier 2019 à 20:46

Présentation

Le Basic Casio est un langage de programmation simple, dérivé du Basic. Il est destiné à la programmation d'algorithmes et de programmes basiques par des étudiants ne possédant pas une formation spécialisée. C'est un langage interprété, c'est à dire qu'il est la calculatrice lit les programmes au fur et à mesure qu'elle les exécute. Cela s'oppose aux langages compilés comme le C ou le Lua, qui sont traités (« compilés ») à l'avance.

Le Basic Casio existe sur quasiment toutes les calculatrices Casio modernes, mais il y a des différences, par exemple entre la Graph 35+E, la Graph 90+E ou encore la Classpad. Un certain niveau de compatibilité existe (notamment quand des programmes pour Graph 35+E sont transférés à une Graph 90+E), mais porter un programme n'est jamais gagné d'avance.

Initialement destiné à la programmation d'algorithmes en classe, le Basic Casio a vite été détourné pour programmer des jeux sur les calculatrices. L'interprétation (c'est-à-dire l'exécution) des programmes Basic reste beaucoup plus lente que celle du Lua (voir LuaFx), et encore plus que celle des add-ins en C (voir le système de développement des SDK).

Ainsi, les bons jeux en Basic sont ceux qui parviennent à s'accomoder des difficultés de vitesse, généralement des jeux de réflexion ou au tour-par-tour.

Tutoriel de programmation Basic

Le tutoriel de programmation en Basic de Totoyo est disponible sur Planète Casio : Cours, Tutoriel de programmation Basic pour calculatrices Casio (v2)

Le menu de l'application PRGM

La programmation en Basic se fait dans le menu PRGM (touche [9] pour les anciennes Graph 35+USB, [A] pour les Graph 35+E et [B] pour les Graph supérieure). Les onglets qui apparaissent en bas de la fenêtre permettent de gérer les programmes :

  • EXE  : Lancer le programme sélectionné.
  • EDIT  : Ouvre l'éditeur de code pour modifier le programme.
  • NEW  : Crée un nouveau programme.
  • DEL  : Supprime (après confirmation) le programme sélectionné. Aussi accessible par la touche [DEL] du clavier.
  • DEL-A : Supprime (après confirmation) tous les programmes.
  • SRC  : Rechercher un programme par son nom.
  • REN  : Renomme le programme sélectionné.

Appuyer sur [F3] permet de créer un nouveau programme. Le bouton BASE permet de créer un programme dit *en mode Base* ; il s'agit d'un type différent de programmes Basic réservé aux calculs de conversions de bases. Le symbole avec la clé permet d'ajouter un code d'accès qui sera demandé à chaque fois que l'utilisateur tentera d'éditer le programme. Le niveau de sécurité est ridicule (on peut le retirer aisément sans recourir à un PC ou à une application externe), mais il permet d'éviter les modifications malencontreuses (surtout quand une erreur se produit et qu'il l'utilisateur incrédule se retrouve face à l'éditeur de code).

Débuter en basic Casio

Le Basic Casio possède une multitude d'instructions, les plus élémentaires étant les instructions suivantes qui sont utilisées pour réaliser des algorithme de base (par exemples en maths) :

  • Affichage la valeur d'un calcul avec le symbole DISP : ◢ ([SHIFT],[PRGM],[F5])
  • La saisie de données : ? ([SHIFT],[PRGM],[F4])
  • Affectation de valeurs aux variables : → (touche [→] située au-dessus de [AC/ON])
  • Affichage du texte à l'écran, avec les guillemets (e.g. "Le résultat est :"). ([ALPHA],[×10^x])
  • Les commentaires de texte avec le symbole ' (dure jusqu'à la fin de la ligne)


Commandes de base

  • Les conditions
If Condition                // On définit la condition                                                           => [SHIFT][VARS][F1][F1]
Then Instructions           // Les instructions à exécuter si la condition est vraie                             => [SHIFT][VARS][F1][F2]
Else Instructions           // Facultatif, instructions à exécuter si la condition est fausse                    => [SHIFT][VARS][F1][F3]
IfEnd                       // Fin de la condition                                                               => [SHIFT][VARS][F1][F4]

Condition => Instruction    // Plus rapide mais ne permet d’exécuter qu'une seule instruction                    => [SHIFT][VARS][F3][F3]


  • Les boucles
While Condition             // On définit la condition de la boucle                                      => [SHIFT][VARS][F1][F6][F6][F1]
Instructions                // Les instructions à exécuter tant que la condition est vraie  
WhileEnd                    // Fin de la boucle                                                          => [SHIFT][VARS][F1][F6][F6][F2]

Do                          // Début de la boucle                                                        => [SHIFT][VARS][F1][F6][F6][F3]
Instructions                // Les instructions à exécuter tant que la condition est vraie
LpWhile Condition           // On définit la condition de la boucle                                      => [SHIFT][VARS][F1][F6][F6][F4]

La différence entre un boucle "While/WhileEnd" et une boucle "Do/LpWhile" est que, si la condition est fausse depuis le début, une boucle "While/WhileEnd" ne fera aucune itération, tandis qu'une boucle "Do/LpWhile" en fera toujours au moins une. 


For Valeur initiale Arrow.gif Variable To Valeur finale Step Pas     
Instructions                // Les instructions à exécuter pendant la boucle 
Next                        // Fin de la boucle

For                                                                                                          => [SHIFT][VARS][F1][F6][F1]
To                                                                                                           => [SHIFT][VARS][F1][F6][F2]
Step  (Facultatif, 1 par défaut)                                                                             => [SHIFT][VARS][F1][F6][F3]
Next                                                                                                         => [SHIFT][VARS][F1][F6][F4]


  • Les sauts inconditionnels
Goto nombre ou lettre       // Fait un saut inconditionnel vers le "Lbl" avec le même identifiant                => [SHIFT][VARS][F3][F2]
Lbl nombre ou lettre        // Marque le point d'arrivée d'un "Goto" avec le même identifiant                    => [SHIFT][VARS][F3][F1]


  • Les opérateurs relationnels :
Premier terme = Second terme                                                                                 => [SHIFT][VARS][F6][F3][F1]
Premier terme ≠ Second terme                                                                                 => [SHIFT][VARS][F6][F3][F2]
Premier terme < Second terme                                                                                 => [SHIFT][VARS][F6][F3][F4]
Premier terme > Second terme                                                                                 => [SHIFT][VARS][F6][F3][F3]
Premier terme ≤ Second terme                                                                                 => [SHIFT][VARS][F6][F3][F6]
Premier terme ≥ Second terme                                                                                 => [SHIFT][VARS][F6][F3][F5]


  • Les commandes de contrôle
Prog Nom du programme       // Exécute un autre programme dont on spécifie le nom comme une sous-routine         => [SHIFT][VARS][F2][F1]
Return                      // Ramène dans le programme appelant                                                 => [SHIFT][VARS][F2][F2]
Break                       // Force la sortie d'une boucle                                                      => [SHIFT][VARS][F2][F3]
Stop                        // Arrête l'exécution du programme                                                   => [SHIFT][VARS][F2][F4]


  • Autres
La répartition du Getkey sur Fx-9860
Locate, x, y, "Texte"       // Affiche du texte aux coordonnées spécifiées            => [SHIFT][VARS][F6][F4][F1]
GetKey                      // Prend une valeur selon la touche pressée               => [SHIFT][VARS][F6][F4][F2]


Commandes avancées

  • Les opérateurs logiques:

Ceux-ci servent à relier deux conditions ou plus pour n'en faire qu'une. Elles se situent dans l'onglet "LOGIC". 

C1 And C2       // Est vrai ssi les deux paramètres sont non nuls                       =>  [OPTN][F6][F6][F4][F1]
C1 Or C2        // Est vrai ssi au moins l'un des deux paramètres est non nul           =>  [OPTN][F6][F6][F4][F2]
Not C           // Est vrai ssi le paramètre est nul                                    =>  [OPTN][F6][F6][F4][F3]
C1 Xor C2       // Est vrai ssi un et un seul des deux paramètres est non nul           =>  [OPTN][F6][F6][F4][F4]

Les paramètres non nuls sont soit des variables dont la valeur est différente de 0, soit des expressions conditionnelles vraies. On peut donc utiliser le résultat d'une condition logique en paramètre d'une autre.


  • Les chaînes de caractères (Strings)

Disponibles uniquement sur les calculatrices disposant d'une version de l'OS supérieur à 2

Les chaînes de caractères permettent d'insérer du texte dans des variables spéciales, les Strings (Str). Le Basic Casio dispose aussi de fonctions permettant de les manipuler. 

Str Identifiant (1Arrow.gif6)       // Permet d'accéder à une chaîne à la manière des listes                                    => [VARS][F6][F5]


Commandes graphiques

Les repères d'affichage

Le Basic Casio permet de gérer deux écran. Le premier est l'écran de texte, qui a 21 colonnes, 7 lignes, et dans lequel on affiche du texte avec la commande Locate. Le second est l'écran graphique, qui permet de contrôler chaque pixel indépendamment. Il a 127 colonnes et 63 lignes (les dimensions de l'écran, dont une colonne et une ligne sont inaccessibles). Ces deux écrans sont indépendants et on peut pas afficher le contenu des deux en même temps.

L'écran graphique utilise deux repères pour l'affichage.

  • Le premier est le repère du graphique, dans lequel sont tracées les courbes. Ce repère est défini par la commande ViewWindow.
  • Le second est le repère statique de l'écran. Chaque pixel a des coordonnées entières, et la valeur pour y=0 se trouve en haut de l'écran. Toutes les coordonnées y sont positives.


Préparer l'écran pour le programme

Les commandes utilisées pour préparer l'écran graphique sont les suivantes. 

ViewWindow Xmin, Xmax, Xscale, Ymin, Ymax, Yscale                                                                      => [SHIFT][F3][F1]

La commande ViewWindow définit les dimensions du repère graphique. Comme de nombreuses fonctions l'utilisent plutôt que le repère statique, il est utile de le définir au plus près de ce dernier. 

ViewWindow 1,127,1,1,63,1

Il est aussi recommandé d'enlever les axes, la grille et autres afin d'avoir un écran blanc. 

CoordOff                                                                                                         => [SHIFT][MENU][F2][F2]
GridOff                                                                                                          => [SHIFT][MENU][F3][F2]
AxesOff                                                                                                          => [SHIFT][MENU][F4][F2]
LabelOff                                                                                                         => [SHIFT][MENU][F5][F2]


Dessiner à l'écran graphique

Les fonctions utilisées pour dessiner à l'écran graphique sont les suivantes. 

Cls                         // Efface l'écran graphique                                                                => [SHIFT][F4][F1]
PlotOn x, y                 // Allume le pixel aux coordonnées spécifiées                                      => [SHIFT][F4][F6][F1][F2]
PlotOff x, y                // Éteint le pixel aux coordonnées spécifiées                                      => [SHIFT][F4][F6][F1][F3]
PlotChg x, y                // Inverse l'état du pixel aux coordonnées spécifiées                              => [SHIFT][F4][F6][F1][F4]
Line                        // Trace une ligne entre 2 pixels allumés avec PlotOn                              => [SHIFT][F4][F6][F2][F1]
F-Line x1, y1, x2, y2       // Trace une ligne entre les points spécifiés                                      => [SHIFT][F4][F6][F2][F2]

PxlOn x, y                  // Allume le pixel aux coordonnées spécifiées                                  => [SHIFT][F4][F6][F6][F3][F1]
PxlOff x, y                 // Éteint le pixel aux coordonnées spécifiées                                  => [SHIFT][F4][F6][F6][F3][F2]
PxlChg x, y                 // Inverse l'état du pixel aux coordonnées spécifiées                          => [SHIFT][F4][F6][F6][F3][F3]

Les commandes Plot, Line ainsi que F-Line utilisent le repère du graphe.
Les commandes Pxl utilisent le repère statique de l'écran.


Utiliser les Pictures

Il est possible de stocker le contenu d'un écran graphique dans la mémoire sous la forme d'une Picture, puis de le rappeler. Ceci n'efface pas l'écran. 

StoPict p                   // Stocke l'écran graphique dans la Picture p                                       => [OPTN][F6][F6][F2][F1]
RclPict p                   // Affiche à l'écran graphique le contenu de la Picture p                           => [OPTN][F6][F6][F2][F2]


Utiliser les Captures

Les Captures sont des captures d'écran réalisées par le système lorsque vous appuyez sur [SHIFT][7]. Vous pouvez les utiliser pour afficher des images également, et elles ont l'avantage d'être deux fois mois lourdes que les Picture. 

RclCapt p                   // Affiche à l'écran graphique le contenu de la Capture p                           => [OPTN][F6][F6][F5][F1]

Cependant, on ne peut dessiner par-dessus une Capture.

Aller plus loin

Tutoriels de qualité

Récupérée de « https://wiki.planet-casio.com/fr/index.php?title=Basic_Casio&oldid=1135 »