LES DOSSIERS DU GAULOIS : Développement - Cours Basic

Le cours de programmation sur Palm !
Partie 1&2

Introduction



Vous êtes nombreux a vouloir vous lancer dans la programmation, c'est une bonne idée. D'ailleurs la programmation est plus facile que vous ne pensez. Seulement voilà, quant on voit dans une boutique le nombre de livres qui aborde ce thème, il y a rapidement de quoi tomber les bras et abandonner. La multiplicité des langages, le niveau pré requis ainsi que les univers ou environnement sur lesquels ces langages tournent peut déconcerter les plus hardent. Voilà pourquoi, je vais essayer pendant plusieurs chapitres de vous transmettre les connaissances nécessaires pour que vous puissiez comme moi trouver plaisir a écrire des petits programmes pour le Palm. Après vous avoir présenté les notions théoriques et élémentaires de programmation nous allons passer à des cas concrets avec un langage. Pour que tout le monde en profite, le langage retenu sera d'abord le basic, une prochaine version du cours traitera également du C. Pourquoi le Basic, 1er parce qu'il ne nécessite aucuns investissement pour vous (il existe 2 versions gratuites) 2eme parce que le Basic est un langage de référence facile d'accès y compris pour les débutant, certes sur Palm ce n'est pas un langage très puissant pouvant rivaliser avec des programmes écrit en C toutefois le nombre de fonctions accessibles est tout a fait satisfaisant pour les Travaux Pratiques. Le cours est basé sur Hotpaw Basic, www.hotpaw.com/rhn/hotpaw/ version shareware du basic Palm et plus étendue que la version gratuite Cpaspad.
Les 2 langages sont aussi totalement indépendant de votre machine de synchronisation puisqu'ils sont "onboard" c'est a dire que l'environnement de travail est 100% sur le Palm, donc vous pouvez même programmer à la plage, dans la salle d'attente du dentiste ou dans les transports en commun. Pas besoin d'avoir le dernier PC ou le dernier Mac sortit pour programmer.

Les langages basic directement sur Palm

Langage: CbasPas
Editeur: Ronald Nicholson Url: http://www.nicholson.com/
Prix: $0
Niveau: Débutant Applications: restreintes
Description:

Programmez en Basic sur votre directement sur votre Palm en saisisant le code directement dans le programme mémo, donc depuis le Palm ou depuis le desktop de l'ordinateur
(gratuit jusque la version 0.97b4 )
 - la documentation http://www.rahul.net/rhn/basic/CBASPAD.TXT
 - quelques sources basic:
   http://www.eurocool.com/search/?search=cbaspad


Langage: HotPaw Editeur: Ronald Nicholson Url: http://www.hotpaw.com/
Prix: $20 Niveau: Débutant Applications: restreintes
Description:

Aprés CbasPad, Ronald remet le couvert et sort une version plus puissante batisée "cbaspad pro" puis "HotPaw" et elle devient Shareware au passage.

Version shareware est limité à 7 programmes maxi.
Quelques sources http://www.eurocool.com/search/?search=hotpaw


Langage: SmallBasic Editeur: ... Url: http://smallbasic.sourceforge.net/
Prix: libre (GPL) Niveau: débutant  
Description: SmallBasic et un autre basic directement utilisable sur le Palm. Cette version etant assez recente, que ne la connais pas bien.

 

Partie théorique

A quoi peut servir un programme ?
Un programme sur un ordinateur est essentiellement dédié a une tache qui peut prendre n'importe quelles formes en fonction d'un cahier des charges, et d'une partie imagination de son auteur. En fait un programme sert a traiter des données pour les transformer en informations exploitables pour les utilisateurs du programme.

Données Brutes
=>
Traitements
=>
Résultats
Entrées
     
Sorties
Clavier / souris / Stylet
Scanneur / photo num.
data
 
calculs
 
Visualisation
Impression
Transmission


L'entrées des données sont souvent le fait qu'acquisition par un clavier, un scanner, une liaison informatique, la souris ou tout autres périphériques. Le résultat après traitement est lui donné par un écran, une impression papier, ou encore une liaison vers une autre machine. On peut préciser aussi que les traitements peuvent fonctionner en cascade et donc le résultat d'un traitement peut devenir 'données" pour le traitement suivant. Pour effectuer un traitement, l'ordinateur exécute une liste d'instructions dans un ordre etabli, l'ordinateur peut indéfiniment réaliser le traitement, sans " râler " jusqu'à ce que l'opérateur lui ordonne d'arrêter. En fait l'ordinateur peut très bien réaliser bcp de traitements en parallèle et consolider les résultats au final. Parfois nous pouvons avoir l'impression que l'ordinateur fasse un choix, ou prenne une décision mais en fait il n'en est rien, simplement dans le traitement des instructions, le programmeur a introduit un test, et selon le résultat du test, l'ordinateur "change de comportement" mais tout était prévu à l'origine du programme. L'ordinateur ne devient pas intelligent.
Pour pouvoir traiter des informations, l'ordinateur a besoin de pouvoir stocker les informations soit celles des données du départ, soit celles issues de ses calculs intermediaires, ou encore celles des résultats. Ce stockage peut être physique sur un support magnetique enregistrable appelé "Mémoire de Masse" comme le disque dur ou une disquette, ou encore à la mode une carte d'extension mémoire. Quant au stockage des calculs intermediaire il est souvent dans la mémoire RAM dynamique de l'ordinateur, car cette dernière est trés rapide en écriture et lecture (on parle de µs pour micro-seconde 10^-6s) tandis que les accés au disque dur sont donné en ms (milli-seconde 10^-3s). Une fois l'ordinateur éteind, les informations en RAM sont éffacés tandis que celle sur le disque dur reste stocké magnétiquement. Pour le Palm les 2 types de support RAM et Disque Dur sont confondu dans les rôles en un seul et même circuit de mémoire. Toutefois pendant l'execution du programme le system d'exploitation utilise differentes partie du circuit mémoire pour son usage (pour plus d'informations sur le sujet se rapporter aux articles de Denis Faivre dans Team Palm Tops). Pour que le Palm puisse stocker des informations on lui fourni des "cases" où il range les données, les reprend, les modifie et range à nouveau. Ces "cases" sont des espaces mémoires appelés "variable". Une variable est donc un emplacement que le programme va utiliser pour y stocker des valeurs qui peuvent être numérique, décimales ou entieres mais également des suites de caractéres formant des "chaines".

L'importance du systeme d'exploitation.

Dans la majorité des cas, l'écriture d'un programme ne requiert pas de connaissance spécifique du matériel pour le programmeur, et heureusement. Par exemple quant une personne écrit un programme pour un PC elle ignore quelles seront les ressources ou le matériel que vous utiliserez pour exploiter le programme; si c'est un écran 15' , une souris sans fils ou un Pentium 700 ... et cela pour une raison simple est que le programme qui est écrit ne s'adresse pas directement à la machine pour excecution mais d'abord a son système d'exploitation: l'O.S (Operating System) Il en est de même avec le Palm. De nombreux langages pour cette machine passent par cette incontournable interprète qu'est PalmOS pour que le device (la machine) le comprenne matériellement. Prenons par exemple le cas du son, supposez que dans votre programme vous souhaitiez que la machine fasse un bip continu, et bien le programme contiendra une instruction spécifique et une fois en exécution, il transmettra l'ordre au PalmOs qui va a son tour solliciter le circuit électronique sonore de la machine pour émettre un bip avec le Buzzer si c'est un Palm ou un Visor, un Sony™ ou le HP si c'est un TRGpro ou un Handera. Certes il faut tout de même que l'auteur du programme choisir une famille de machine pour cibler les caractéristiques générales mais aussi les limites qui lui sont imposé par le matériel. Prenons le cas du Palm, les écran sont de 160x160 (un peu plus pour Handera et Sony™). donc inutile de vouloir afficher d'avantage de pixels comme sur un PC... Toutefois à l'interieur d'un programme, l'auteur peut lancer une serie de tests qui indiqueront au programme que vous utilisez un ecran couleur, ou que votre infrarouge est desactivé ou encore que vous n'avez pas la version de PalmOS nécessaire est suffisante pour faire fonctionner le programme parfaitement.

Aprés ces quelques notions théorique passont au langage proprement dit.

Le langage Basic - installation de l'environnement.

Télechargez HotPaw depuis http://www.hotpaw.com/ et installez-le sur votre machine.

exemple de regroupement des
programmes nécessaires sur un même onglet avec Lauch'em

JFilePro pour l'acces au base de données sera abordé en 4éme partie du cours,

SmallBasic est optionnel.

Le lancement de yBasic (HotPaw Basic)

La version d'évaluation affiche seulement les 7
premiers memo

Le lancement du programme Mémo (bloc-note du Palm)
pour l'édition du programme

affichage des 8 programmes

La modification du programme au sein du Mémo, peut se faire avec le stylet, par le clavier virtuelle, sur un vrai clavier mécanique comme le stowaway, voir même directement sur l'ordinateur.
par le desktop.

Remarquez que le source des programmes Basic ecris dans le mémo commence tous par # avec un nom suivi de .bas pour que HotPaw les identifie dans tout vos mémo quelques soit la catégorie où vous les placez.

Le langage Basic HotPaw- les instructions.

Au sein d'un programme quelque soit le langage, nous retrouvons souvent les mêmes familles d'instructions:
- les variables ou l'on stocke les données.
- les opérateurs qui executent les opérations de calcul entre variables et constantes.
- les tests qui dirigent le programme vers tel ou tel autre traitement en fonction du résultat du test.
- les boucles qui s'executent un nombre de fois prédéfini ou qui s'interomptent en fonction d'un test.
- les entrées de données (saisie-clavier, stylet ...)
- les sorties de résultats ( affichage, son ...)
- les fonctions programmable, procédures ou sous-programmes qui sont des mini-programmes réutilisable plusieurs fois avec passage ou non de paramêtres.
- les fonctions spécifiques bases de données, sonores, de convertion de types, d'horodatage, de données system ou encore graphiques sont des instructions particulieres avec passage de paramêtres pour execution des taches définies ou récupération de valeurs systémes.

Particularité du HotPaw
* Toutes les instructions peuvent être écrite en minuscule.
* Une ligne de code ne dépasse pas 80 caractéres.
* les instructions peuvent être sur une même ligne et séparée par le caractére de ponctuation " : "
* comme le code est écrit dans un mémo il ne peut dépassé les 4000 caractéres, toutefois un programme peut lui même appeler plusieurs mémo avec  #include < #memo 2> , memo 2 etant le titre du memo contenant la suite des instructions. Donc cette limitation de 4000 caractère n'est pas vraiment un handicap.

#
Item/opérateur/instruction
Exemple
1

Les variables:
Ce sont des "cases" mémoire qui permettent de stocker les données pendant le déroulement du programme, elles ne sont pas sauvegarder une fois le programme quitté,
elles peuvent avoir un nom qui va de 1 à 15 caractéres,
les variables entieres sont suivi de %
les variables contenant une chaine de caractéres (chaine de caractére = ensemble de caractéres qui forme un mot ou une phrase, ou plusieurs phrase) sont suivi de $, un programme est limité à 63 chaines de caractères.
les tableaux ont une ou deux dimentions et doivent etre defini en debut de code excepté r$() et s$() qui sont reservés automatiquement par HotPaw.


a=5
coucou=a+55



aa%=32243
b$="comment ça va ?"
c$="trés bien"


dim a(4) : dim b(10,10)

2

Les opérateurs:
Arithmétic : +,-,*,/,mod,^,(,)
test : =,<,<=,>,>=,<>
logique : and,or,xor,not,&
Les opérateurs sont des caractéres particulier ou instructions qui indique au programme un calcul ou la nature d'un test de comparaison, ou encore une transformation de la variable qui subit l'opérateur.


a=3*x^2+2*x-(12/23)
b=(a/2)*7
3

Les tests:
if test then
 action 1
else
 action 2
endif
Le test, partie fondamentale de tout programme, fait une comparaison entre 2 entités, variable et valeur ou variables entre elle. Selon le resultat du test qui est soit "vrai" ou " faux", le programme execute une (serie) d'instruction ou encore réalise un "saut" vers une autre partie du programme. L'exemple joint test si A x 2 = 25, si oui "c'est gagné"s'affichie, sinon "perdu" est affiché.
le "elseif" permet un second test en cascade

if a*2=25 then
  print " c'est gagné" 
else
  print "perdu"
endif

if (x = 1)
  y = 11
elseif (x = 2)
  y = 22
else
  y = 33
endif

4

Les boucles:
For x=a to b step c
Next x
a = valeur de départ
b= valeur d'arrivée
c= incrément
x est la variable qui change de valeur à chaque boucle.
La boucle est une instruction qui s'execute un nombre de fois défini à l'avance ou défini par calcul au sein du programme. Dans l'exemple ci joint, le programme affiche les carré des chiffres de 1 à 100. le "step" optionnel indique la valeur de l'incrément à chaque boucle, cette valeur par défaut est de 1 quant "step" est ommit.

for a=1 to 100
r=a^2
print r;
next a

while test
action
wend
Cette boucle a de particularité de s'executer tant que le test d'entrée est vrais.		 n = 1
while (n < 100)
  n = n + 2
wend
print n
6
 Le sous programme:
gosub / return / end sub

gosub execute un saut à l'adresse qui suit l'instruction, soit un numéro de ligne qui précede l'instruction d'arrivée , soit un nom avec en option un parametre, les exemples permettent de clarifier l'usage du code.		 Usage classique avec n° de ligne:

100 gosub 500
200 end
...
500 print x+1
510 return

Usage avec nom:

gosub foo(5)
end
...
sub foo(x)
print x+1
end sub

7
 Les entrées de données:
Sur Palm il y a plusieurs façon d'entrée des données, ce peut être une valeur à saisir au stylet, mais ce peut également être une position sur l'écran, de fait il y a plusieurs instructions  à utiliser selon l'usage final.
fn pen(0) récupére la position X courante
fn pen(1) récupére la dernière position X
fn pen(2) récupére la dernière position Y
fn pen(3) durée depuis le dernier appuis du stylet
fn pen(4) =1 si stylet appuyé sur l'écran
fn pen(5) 		 
inkey$()
cet instruction recupére dans une mémoire le dernier caractére saisie dans la zone graffiti.		  
input$(message$,[titre$[,defaut$]])
> message$ est le texte explicatif
> titre$ est le titre [optionnel] dans la fenetre
> defaut$ est la valeur par defaut [optionnel]
> input$ retourne une chaine de caractère donc il faut la convertir avec val(input$...) pour obtenir une valeur numérique

message$=" votre choix:"
titre$=" proposez une valeur entre 1 et 10"
defaut$=5
choix=val(input$(message$,titre$,defaut$)

8
Les sorties de résultat:
print
display
?

a=5:b=7
print a+b
display "bonjour"
? "comment ça va ?"

Msgbox(message$[,titre$[,n]])
> message$ est le texte explicatif
> titre$ est le titre [optionnel] dans la fenetre
> si n=1 alors il y a un bouton "OK"
> si n=2 alors il y a 2 bouton "OK" et "Cancel"

a$=" voulez-vous supprimer ce fichier"
b$=" confirmation "
reponse$=Msgbox(a$,b$,2)

Fin de la première partie

Partie 2a - 18/10/2001

Dans la première partie, nous avions abordé la théorie sur la programmation et les premières instructions du langage hotpaw. A présent nous allons voir ensemble quelques exemples de code commentès pour mieux appréhender la richesse des instructions.

#
L
Exemple
Commentaire
   
- > -
pour tester les exemples, recopiez le code dans votre mémo tel qu'à l'écran, lancez Howpaw et selectionner le mémo à tester puis "run"
1
1
2
3
4
5
6

# hello.bas
#
a$ = "Hello"
b$ = "World"
print a$, b$
end

Le traditionnel "hello world" qui consiste à afficher ces 2 mots sur l'écran de la machine.
Ligne 1: le nom du programme,
L3,4: les 2 variables a$ et b$ recoivent des valeurs au format texte
L5: affichage à l'écran des 2 valeurs, la virgule tient lieu de séparateur entre les 2 affichages.
L6: fin du programme.
2
1
2
3
4
5
6
7
8

# nombre_secret.bas
x = 0
secret = 1 + rnd(10)
while (x <> secret)
input "indiquez-moi un nombre entre 1 et 10", x
wend
display x; " exacte !"
end

->-

trouver un nombre entre 1 et 10
le programme fonctionne en boucle fermé, tant que la réponse n'est pas trouvé le programme continu pour celà on fait appel à une boucle while - wend qui inclut les instructions.
Ligne 1: le nom du programme
L2, chargement d'une valeur initiale pour la variable X servant au stockage de la réponse.
L3, secret est une variable qui va prendre la valeur d'un nombre aléatoire (au hazard) compris entre 1 et 10. En fait l'instruction basique RND(n) génére un chiffre décimal entre 0 et n-1, le fait de mettre RND(10) donne un nombre entre 0 et 9 donc on ajoute 1 pour obtenir un chiffre entre 0 et 10.
L4, début de la boucle avec la condition pour y rester a savoir il faut que X (la réponse) soit différente du nombre secret.
L5, on demande à l'opérateur d'introduire sa réponse qui se stock dans X.
L6, wend ferme la boucle, en fait il indique au programme qu'il ne poura franchir cette limite si la condition est vrais
L7 affichage du résultat suivi du message "exacte !"
L8 fin du programme
3
1
2
3
4
5
6
7
8
9
10
11
12
13

# nombre_secret.bas
x = 0
secret = 1 + rnd(10)
while (x <> secret)
input "nombre entre 1 et 10", x
if x > secret then
print " trop grand "
else
print " trop petit "
endif
wend
display x; " exacte !"
end

-<-

meme programme que le précédant mais cette fois on ajoute 1 test qui permet de mettre sur la voie l'opérateur.

Ligne 6 si X la reponse est plus grand que le nombre secret alors on affiche ligne 7 "trop grand" sinon (L8) on affiche la ligne 9 "trop petit"

en fait vous constaterez à l'usage que le programme contient une erreur,
Réponse: si x = secret alors le programme affiche d'abord la L9 " trop petit " puis la ligne 12 " exacte !"
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# nombre_secret.bas
x = 0
gosub sec
while (x <> secret)
input "indiquez-moi un nombre entre 1 et 10", x
if x > secret then
gosub grand
endif
if x < secret then
gosub petit
endif
wend
display x; " exacte !"
end

sub sec
secret = 1 + rnd(10)
endsub

sub grand
print " trop grand "
endsub

sub petit
print " trop petit "
endsub

 encore une autre variante du précedant programme avec la correction et un découpage du code en différent bloc appelé sous programme. (sub = subroutine en anglais)

L3, le "gosub sec" appel le sous programme ligne 15 puis la ligne 17 le "end sub" indiques au programme de retourner de là ou il vient fin de ligne 3 pour executer la ligne 4.
idem ligne 7 et 9.

Le sous-programme n'a pas vraiment d'utilité dans le cas présent car il est toujours appelé depuis le même endroit mais dans un autre programme il pourrait grandement simplifier l'écriture en "factorisant" les instructions:
dés qu'un traitement doit etre executé plus d'une fois au cours de la vie du programme, alors il peut etre intéréssant de confier la tache au sous-programme qui peut être appelé depuis n'importe quelle ligne avec un gosub.

Partie 2b - 20/10/2001
Voyons ensemble quelques nouvelles intructions pour completer nos programmes.

 
#
Item/opérateur/instruction
Exemple
9a
Les 3 boites de dialogue form:
form(9,n,titre$) affiche un formulaire de n lignes sur 2 colones avec un titre, il utilise des mémoires reservés a HotPaw qui vont de s$(0) à s$(63) dans le cas du form(9...) on se limite aux 16 premiers.
les indices pairs correspondent aux libéllés, et les indices inpairs aux valeurs, exemple:
n
numéro
de ligne
libéllé/
texte
affiché
valeur
récupéré ou
affiché
2
 s$(0) s$(1)
3
 s$(2) s$(3)
4
 s$(4) s$(5)
5
 s$(6) s$(7)
6
 s$(8) s$(9)
7
 s$(10) s$(11)
8
 s$(12) s$(13)
9
 s$(14) s$(15)

en bas du formulaire apparait 4 boutons: [ok] [cancel] [A] [B]
si on écrit j=form(9,n,titre$), la variable j prend comme valeur :

appuis sur le bouton
valeur retournée de j
[ok]
1
[cancel]
0
[A]
2
[B]
3

L'exemple ci contre, affiche un formulaire de 7 lignes avec les 5 première remplies.

n
numéro
de ligne
libéllé/
texte
affiché
valeur
récupéré ou
affiché
2
 s$(0)= "nom" s$(1)
3
 s$(2)= "principal" s$(3)
4
 s$(4)= "année" s$(5)
5
 s$(6)= "interêt %" s$(7)
6
 s$(8)= "periodes" s$(9)
7
 s$(10)= "loyer" s$(11)

Aprés saisie des valeurs, en cliquant sur OK la variable s$(11) est calculée grâce à la récupération des valeurs saisie en 3,5,7,9 et intégré dans la fonction HotPaw: fn pmt(p,i,n) qui fait le calcul d'un loyer d'emprunt.

# loan payment .bas
# calculates loan payments
for i=0 to 11: s$(i)="": next i
s$(0)="nom:"
s$(2)="Principal"
s$(4)="année"
s$(6)="Interets %"
s$(8)="Periodes": s$(9)=12
while (1)
j=form(9,6,"Prêt")
if j=0 then end
i=(val(s$(7))/100)/val(s$(9))
p=val(s$(3))
n=12*val(s$(5))
a=fn pmt(p,i,n)
a$=str$(a,5,2)
s$(10)="Loyer"
s$(11)=a$+"FF"
wend
end

9b

form(10,n,title$) affiche un formulaire avec une seule colonne.

s$(0), s$(2) ... affiche le texte, la premiere ligne est en font gras
si s$(0) est vide, s$(1) sera une ligne d'entrée de valeur.

les 4 boutons du bas réagisent pareils que dans form(9...)

9c

form(12,0,title$) affiche un formulaire a 2 colonnes + un clavier de saisie numérie sur le coté droit.

s$(0) and s$(1) affiche le text en haut et bas ("nom:" dans l'exemple ci contre)
s$(2), s$(4) ... correspond au texte des libéllé
s$(3), s$(5) ... sont les valeurs retourné
return values are 0 for Done, 1 for OK
2 for Calc button, and 3 for Calc2 button
9d
 résumé des 3 form
form(9...)
form(10...)
form(12...)
11

Les fonctions intégrés a HotPaw:
Fonctions - Mathématiques.

  • abs(x) retourne la valeur absolue d'un nombre positif ou negatif
  • acos(x) Arc cosinus (pour l'explication révisez vos cours de géométrie... ;-)
  • asin(x) Arc sinus
  • atn(x,y) Arc Tangente
  • bool(t) retourne une valeur vraie (1) ou fausse (0) d'une expression
  • cos(a) cosinus d'un angle en radian
  • exp(x) e puissance x,
  • hex$(x) convertit un nombre decimal (base 10) en nombre hexadecimal (base 16)
  • int(x) convertit un nombre décimal (avec chiffre derrière la virgule) en nombre entier (sans virgule)
  • log(x) nombre log de x
  • log10(x) nombre log base 10 de x
  • rnd(x) retourne un nombre aléatoire entre 0 et x-1
  • round(x) arrondie une valeur en entier
  • round(x,d) arrondie une valeur décimal avec d décimal derrière la virgule
  • sgn(x) retourne le signe du chiffre x
  • sin(a) sinus d'un angle en radian
  • sqr(x) retourne la racine carré du nombre x
  • tan(a) tangente d'un angle en radian
  • val(b$) retourne la valeur décimal de la chaine de caractère b$
  • fn deg(r) convertit un angle radian en degré
  • fn rad(a) convertit un angle degré en radian

12

Fonctions - chaine de caractères.

  • ucase$(a$) convertit une chaine de caractère en majuscule
  • lcase$(a$) convertit une chaine de caractère en minuscule
  • right$(a$,x) extrait d'une chaine de caractère les x caractères de droite
  • left$(a$,x) extrait d'une chaine de caractère les x caractères de gauche
  • mid$(a$,x,y) extrait d'une chaine de caractère y caractères depuis le x eme caractère de gauche.
  • eval(q$) evalue la valeur numérique d'une chaine de caractère
  • chr$(c) retourne le caractère ascii de la valeur c
  • field(a$,n,",") retourne le n éme champ
  • instr$(a$,b$) recherche la chaine b$ dans la chaine a$ et renvoie 0 si pas trouvé
  • len(a$) retourne la longeur de la chaine a$
  • str$(x,n) retourne une chaine de caractère formé de x et de longueur n
  • str$(x,n,2) retourne une chaine de caractère avec 2 décimals.


# exemple de conversion
a$="AbcdEfghijKL"
b$=ucase$(a$)
=> b$="ABCDEFGHIJKL"
c$=lcase$(a$)
=> c$="abcdefghijkl"
d$=right$(a$,3)
=> d$="jKL"
e$=left$(a$,3)
=> e$="Abc"
f$=mid$(a$,4,3)
=> f$="dEf"
j=eval("3+4")
=> j=7