WEBDAV

Bonsoir

Comment créer un WEBDAV, j'ai voulu vous passer mon exemple de programme sur le convertisseur, message trop lourd le site m'écrit.

J'ai donc fait un programme sans aucun GOTO, il convertit jusqu'à la base 36, mais très très lourd   

gilles

Plusieurs d'entre nous utilisent ce site  pou' héberger des fichiers à partager avec les autres. Ce lien est celui utilisé par le  bouton "Webdav" dans ma signature.

Tu crées un compte gigi75 (absolument gratuit), et tu disposes d'un grand espace de stockage pour déposer tes fichiers. Tu peux télécharger, sur leur site, un outil à installer dans Windows qui permet de gérer cet espace comme un disque standard intégré à ton ordinateur. Il apparaît alors comme

Citation :

https://webdav.mydrive.ch (Z:)

dans ton explorateur, et tu peux y faire toutes les opérations que tu peux faire sur un dossier local.

Ensuite, tu crées un compte "invité" du nom "panoramic" ce qui permet de se connecter par panoramic@gigi75 avec un mot de passe de ton choix. N'oublie pas de donner l'accès lecture, mais pas plus, à ce compte pour invités.

Ainsi, tu as un moyen performant et confortable de partage de fichiers.

EDIT

N'oublie pas de donner le mor de passe panoramic123 au compte "invités" panoramic@gigi75. Nous donnons tous le même mot de passe à nos comptes invités, permettant ainsi une connexion automatique plus facile.

Klaus,

J'ai fait ce que tu as dis pour la création du compte, comment le faire apparaitre comme vous dans panoramic.

Merci

Clique sur Profil (en haut de cette page)
Dans la fenêtre qui s’ouvre, clique sur Signature

Dans la fenêtre Editer la signature, tape ceci (ou mieux, fais un copier/coller) :

Code:

[b][url=http://www.mydrive.ch/][img]http://nardo26.lescigales.org/images/webdav.png[/img][/url] [color=blue]username[/color] :[color=red] panoramic@gigi75[/color][color=blue] password :[/color][color=red] panoramic123 [/color][/b]

Clique sur Prévisualiser pour voir.
Si c’est correct, clique sur Enregistrer

Merci papy

Je vois bien que tu as su ajouter ton webdav à ta signature et j’en suis content pour toi.

Très bien, Gigi75 ! Maintenant, cela peut être utilisé comme n'importe quel webdav des autres Panoramiciens. Un bon point pour la facilité.

Tu sais que tu peux créer des dossiers avec des noms significatifs, des sous-dossiers etc, exactement comme sur une clé USB locale...

@gigi75

J’ai jeté un œil sur ton webdav et particulièrement sur ton programme convertisseur base36.bas.

Pour du lourd c’est super lourd : 4620 lignes de code !
Décidemment, pourquoi faire simple quand on peut faire compliqué ?

J’ai fais un programme de conversion de base, bien avant les SUBs que tu peux consulter ici

Sinon, voici un autre code : une seule SUB pour convertir du décimal vers une base quelconque.

Code:

rem ============================================================================
rem         Conversion de la base 10 à la base X ( X = 2 à 36)
rem ============================================================================
dim n,b,result$
height 0,600
n = 123456789             : ' nombre décimal à convertir
' n = 987654321
for b = 2 to 36           : ' base de conversion de 2 à 36
    Decimal_To_BaseX(n,b) : ' Appel à la procédure de conversion
    print str$(n) + " décimal = " + result$ + " en base " + str$(b)
next b
end

rem ============================================================================
' Procédure de conversion d'un nombre décimal vers la base X (de 2 à 36)
SUB Decimal_To_BaseX(nombre_decimal,base)
    dim_local quotient,reste,chiffre$
    if base < 2 or base > 36
       message "Base invalide !!!" + chr$(13) + "Doit être entre 2 et 36" : exit_sub
    end_if
    quotient = nombre_decimal : result$ = ""
    while quotient > 0
          reste = mod(quotient,base) : quotient = int(quotient/base)
          chiffre$ = str$(reste) : if reste > 9 then chiffre$ = chr$(reste + 55)
          result$ =  chiffre$ + result$
    end_while
end_sub
rem ============================================================================

Tu as bien sûr raison sur le fond, Papydall. Mais je te trouve sévère pour Gigi75. Ton code est certes excellent, mais encourage plutôt Gigi75 en lui montrant 2 ou 3 trucs dans on propre code qui pourraient être optimisés. Pour ma part, je suis content de voir un nouveau contributeur s'intégrer dans notre cercle. Bravo, Gigi75 !

Je me suis peut-être mal exprimé.
Je n’ai nullement l’intension d’être sévère avec quiconque et surtout pas avec  gilles.
Gigi75, ce que tu as fais est correct : la preuve ça fonctionne.
Ma remarque (amicale) était de remplacer les 35 sous-programmes (Base2, Base3, …. Base36) par une seule SUB avec la base (2 à 36) comme paramètre.

Bonjour Papy, Klaus

Bien sûr Papy a raison, la critique est constructive est celui qui nie ceci ne peut avancer.
Papy, j'ai utilisé 1024 boites de mouchoirs ou 2048, je suis désydraté (Sourire).
Pour le super lourd, j'en suis purement responsable, avec certe un melange de fierté et de honte.
On débute on fait des programmes super lourd, on s'améliore, on allège ses programmes. Et pour les sub on y viendra.
Une sub est elle comme une fonction? que l'on peut appeler comme un bout de programme?

Papy, J'ai loué un camion pour le programme de convertion, mon netbook pesait bien lourd pour lancer l'application.  

Klaus pour le WEBDAV je crois qu'il limite à une centaine de Méga je crois.

Le robot que vous voyez sur mon avatar fonctionne avec panoramic, il évite les murs, c'est pas mal, mais le hic est que j'utilise un cable usb pour l'arduino monté à bord. Pourtant l'arduino est équipée d'un pont wifi. Avec le logiciel Arduino, par sa console série, je communique.
J'envois un caractère "H" en exemple pour le commander, etccccc.
Sans cable usb, il fonctionne avec le programme ARDUINO, avec usb (Câble de deux mètre), il fonctionne avec Panoramic. L'avantage de panoramic, c'est le dévellopement futur, la modularité.

En fait je suis allé plus vite que la musique, le travail est sur papier, ordi, puis bien après robot.

Mais revenons à notre sujet, les Subs sont un sous-programme que où l'on peut passer une valeur lorsque on les appele?

Gilles

D'ailleur sur le WEBDAV la vidéo y est.

Ca viendra Gilles. Penser aux SUB n'est pas un raisonnement naturel, il s'acquiert avec le temps et l'expérience. Notamment en analysant les sources des autres. Klaus avait fait des squelettes de programmes il fut un temps pour s'astreindre à une certaine méthode (et gagner du temps puisqu'une fois cette étape franchie, tu peux réutiliser une partie de ton code d'un programme à l'autre)

En fait dans un premier temps continue de programmer et regarde ton code. Si une partie se répète, demande toi quelle fonction elle a et ce qui varie dedans et tu aura le nom de la SUB et son paramètre. Remplace ensuite tous ces morceaux de codes par un appel à ta SUB.

PS: Bravo pour ton robot, j'espère que tu arriveras à faire fonctionner ton radar interfacé avec lui et Panoramic

Pour le robot, jack est d'accord, je vais y adjoindre un fanion panoramic et si vous voulez le mettee en photo pour de futur projet robotique. Que personne ne se gene

Quelques infos sur les SUBs:

Dans un Basic de base (pardon pour le pléonasme), et dans Panoramic, bien sûr, il y a la commande GOSUB. Cela permet d'exécuter le code qui suit un label, comme si c'était un sous-programme, et la commande RETURN revient à la ligne qui suit le GOSUB ayant été exécuté juste avant. C'est déjà pas mal, mais il y a deux limitations importantes:
1. on ne peut pas passer de paramètres à ce sous-programme
2. toutes les variables sont globales, visibles partout, dans le programme principal et dans la sub

La commande SUB permet de définir une séquence de code séparée du flux normal du programme. Alors qu'un label pour un sous-programme appelé par GOSUB peut se trouver n'importe où dans le code, la SUB doit être totalement indépendante, et à aucun moment, l'exécution du code principal ne doit atteindre la commande qui définit une SUB.

Un définit une SUB par la commande:
SUB nom_de_la_sub([par1][,...[,parn]...])
Les parenthèses () sont obligatoires, mais les paramètres sont en nombre libre et optionnels. On peut très bien avoir une SUB sans paramètres. Les paramètres spécifiés ici sont des paramètres "formels" sous forme de variables. Ces variables sont utilisées à l'intérieur de la SUB en les remplaçant par la valeur des paramètres passés à la fonction au moment de l'appel. Tous les paramètres sont passés à la SUB par valeur, pas par référence. Ceci signifie qu'on ne peut pas retourner un résultat à travers un paramètre, et on ne peut pas passer un tableau en paramètre. Par contre, on peut passer des expressions, même complexes, étant donné que seul le résultat final de l'expression est réellement passé à la SUB.

Une SUB doit obligatoirement se terminer par la commande:
END_SUB
Cette commande doit être la dernière ligne de la sub. S'il faut sortir de la SUB à un autre endroit, dans une boucle par exemple, il faut utiliser la commande:
EXIT_SUB

Une SUB peut être appelée n'importe où dans le programme principal: dans la section d'initialisation (avant le END), dans une routine évènement (ON_CLICK etc), dans une autre SUB etc. Attention néanmoins: les SUB ne sont pas réentrantes. Ceci signifie que si une SUB s'appelle elle-même, il y a de fortes chances que le contenu des variables utilisées soit altéré de façon incontrôlable. Ceci est à éviter.

Un des grands avantages des SUB est qu'elles peuvent déclarer des variables locales. Contrairement aux variables déclarées par des commandes DIM (qui sont globales et visibles partout), les variables déclarées à l'intérieur d'une SUB et déclarées par la commande
DIM_LOCAL v[,...]
sont propres à la SUB en question et ne sont visibles que dans la SUB qui les a déclarées. Elles sont créées au moment du démarrage de la SUB, exactement comme si c'était la commande DIM qui les crée, puis elles sont supprimées à la sortie (par EXIT_SUB ou END_SUB). Aucune variable locale d'une SUB est visible dans une autre SUB ou dans le code du programme principal.

Tu peux, à l'aide des SUB, constituer un ensemble de procédures que tu places dans un fichier source à part, comme une bibliothèque de modules. Puis, tu utilises la directive #INCLUDE pour inclure tous ces modules. Tu places cette directive simplement en toute dernière ligne de ton programme, et automatiquement, tu as accès à l'ensemble de ces SUB.

A mon tour d' apporter mon grain de sel...  

Je ne reviens pas sur le poids, je suis un spécialiste des progs à rallonge.

Oui gigi75, c' est un bout de programme que l' on peut rappeler à souhait
mais à deux conditions :

1/ si tu déclares une variable globale par DIM , tu dois mettre sa création sous conditions 
( ex: if variable("x%")=0 then dim x% ) ou la libérer à la fin de la procédure (ex: free x% )
dans le cas ou tu n' en aurait plus besoin.

2/ les variables utilisées en interne de cette procédure doivent être déclaré par dim_local.

Pour les Sub qui sont des Procédures,
elles peuvent être des fonctions si elles retournent un résultat.
Dans ce cas il faut placer le résultat dans une variable globale déclarée par DIM .

ex:

Code:

sub MaFonction(par1%,par2$)
   if variable("MaFonction_return%")=0 then dim MaFonction_return%
   ....
   ....
End_sub

voilà,voilà, j' espère que j' ai été clair... 


edit: Mille excuses Klaus, on s' est croisé et du coup je fais doublon

Bonjour à tous.


Quand doit-on créer des sous-programmes ?

On crée des sous-programmes
• Pour modulariser le programme, c’est-à-dire le gérer sous formes de modules.
• Pour factoriser le code, c’est-à-dire lorsqu’on est amené à écrire plusieurs fois la même suite d’instructions (utilisant les mêmes données).
• Pour paramétrer l’appel, c’est-à-dire lorsqu’une même suite d’instructions utilisant des données différentes doit être écrite plusieurs fois.
• Pour réutiliser le code, c’est-à-dire si le traitement présente un intérêt général.

Il est fortement conseillé que votre sous-programme obéisse aux recommandations suivantes :
• La modularité : un sous-programme doit réaliser une tâche quelconque et une seule.
• L’autonomie : un sous-programme doit être autonome et ne doit pas modifier directement les variables du programme qui l’appelle ; pour cela, il doit passer par les paramètres.
• La transparence : La conception d’un sous-programme doit faire en sorte que l’utilisateur qui y fait appel (qui n’est pas nécessairement son concepteur) n’ait pas à se casser la tête pour tenir compte des choix du concepteur.
• La convivialité : L’appel et l’utilisation du sous-programme doit être le plus évident possible.


@gigi75

Tu peux (si tu veux) te rendre à cet endroit pour avoir une autre source d'information.

si jack est ok.
petite correction, sorry