Serveur Telnet Arduino · GitHub – Serveur d’impression

/ * *

* Serveur Arduino Telnet *

* 7 juillet 2010 *

* E / S Arduino de base via *

* une interface de ligne de commande *

* par Steve Lentz *

* stlentz[at]Gmail[dot]com *

Instructions de démarrage rapide:

1) Définissez l'adresse Ethernet dans le code ci-dessous.

2) Compilez et téléchargez le croquis.

3) Connectez Arduino à Ethernet.

Assurez-vous que le voyant de liaison est allumé.

4) Telnet à l'adresse IP d'Arduino.

5) Sur certains clients Telnet, appuyez sur Retour pour réactiver la connexion.

6) Une fois connecté, tapez? pour aider.

7) Essayez une commande simple telle que «ar».

Autres notes

Testé sur Duemilanove avec Ethernet Shield.

Devrait fonctionner sur des cartes compatibles.

Testé avec les clients Win XP, OS X et Debian Telnet.

Compile à environ 9 Ko, peut être réduit en supprimant

commandes inutiles, message d'aide, etc.

Je suis un programmeur C entièrement autodidacte; si tu

n'aime pas mon code, tant pis ;-). * /

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1278686415

// Paramètres Ethernet

#comprendre <SPI.h>

#comprendre <Ethernet.h>

octet Mac[] = 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ;

octet ip[] = 192, 168, 1, 7 ;

octet passerelle[] = 192, 168, 1, 1 ;

octet sous-réseau[] = 255, 255, 255, 0 ;

// Autres variables globales

#define textBuffSize 9 //longueur de la chaîne de commande la plus longue plus deux espaces pour CR + LF

carboniser textBuff[textBuffSize]; //un endroit pour mettre le texte reçu

int charsReceived = 0;

booléen connectFlag = 0; //nous utiliserons un indicateur distinct de client.connected

//afin que nous puissions reconnaître quand une nouvelle connexion a été créée

non signé longue timeOfLastActivity; //temps en millisecondes de la dernière activité

non signé longue allowedConnectTime = 300000; //cinq minutes

EthernetServer serveur(23); // Telnet écoute sur le port 23

EthernetClient client = 0; // Le client doit avoir une portée globale pour pouvoir être appelé

// des fonctions en dehors de la boucle, mais nous ne savons pas

// quel client est encore, donc créer un objet vide

néant installer()

// définition des broches 0 à 9 comme sorties

// les broches 10-13 sont utilisées par le blindage Ethernet

pour(int je= 0; je < dix; je++) pinMode (i, PRODUCTION);

Ethernet.commencer (mac, ip, passerelle, sous-réseau);

serveur.commencer();

néant boucle()

// regardez si une nouvelle connexion est créée,

// imprimer le message de bienvenue, définir le drapeau connecté

si (serveur.disponible() && !connectFlag)

connectFlag = 1;

client = serveur.disponible();

client.println (" nServeur Arduino Telnet de Steve");

client.println ("? pour aider");

printPrompt ();

// vérifier si le texte reçu

si (client.lié() && client.available ()) getReceivedText ();

// vérifiez si la connexion a expiré

si(connectFlag) checkConnectionTimeout ();

// code pour faire d'autres choses en boucle irait ici

néant printPrompt ()

timeOfLastActivity = millis();

client.affleurer();

charsReceived = 0; //nombre de caractères reçus

client.impression(" n>");

néant checkConnectionTimeout ()

si(millis() – timeOfLastActivity > allowedConnectTime)

client.println ();

client.println ("Déconnexion de temporisation.");

client.Arrêtez();

connectFlag = 0;

néant getReceivedText ()

carboniser c;

int attente;

// copier les caractères en attente dans textBuff

//jusqu'à ce que textBuff soit complet, que CR ait reçu ou plus de caractères

caractères = client.disponible();

faire

c = client.lis();

textBuff[charsReceived] = c;

charsReceived++;

caractères–;

tandis que(charsReceived <= textBuffSize && c ! = 0x0d && caractères > 0);

//si CR trouvé, regardez le texte reçu et exécutez la commande

si(c == 0x0d)

parseReceivedText ();

// après avoir terminé la commande, imprimez une nouvelle invite

printPrompt ();

// si textBuff plein sans atteindre un CR, imprimer un message d'erreur

si(charsReceived > = textBuffSize)

client.println ();

printErrorMessage ();

printPrompt ();

// si textBuff n'est pas plein et pas de CR, ne faites rien d'autre;

// revenir en boucle jusqu'à ce que plus de caractères soient reçus

néant parseReceivedText ()

// regardez le premier caractère et décidez quoi faire

commutateur (textBuff[[0])

Cas "une" : doAnalogCommand (); Pause;

Cas "ré" : doDigitalCommand (); Pause;

Cas "p" : setPinMode (); Pause;

Cas "c" : checkCloseConnection (); Pause;

Cas "?" : printHelpMessage (); Pause;

Cas 0x0d : Pause; //ignorer un retour chariot

défaut: printErrorMessage (); Pause;

néant doDigitalCommand ()

// si nous sommes arrivés ici, textBuff[0] = 'd'

commutateur (textBuff[[1])

Cas "r" : readDigitalPins (); Pause;

Cas "w" : writeDigitalPin (); Pause;

défaut: printErrorMessage (); Pause;

néant readDigitalPins ()

// si nous sommes arrivés ici, textBuff[0] = 'd' et textBuff[1] = 'r'

int épingle;

si (textBuff[[2] == 0x0d)

// sortie la valeur de chaque broche numérique

pour (int je = 0; je < dix; je++) outputPinState (i);

autre

épingle = parseDigit (textBuff[[2]);

si(épingle > =0 && épingle <=9) outputPinState (broche);

autre printErrorMessage ();

néant outputPinState (int épingle)

client.impression("broche numérique ");

client.impression (épingle);

client.impression(" est ");

si (digitalRead (pin))

client.println ("HAUTE");

autre

client.println ("FAIBLE");

néant writeDigitalPin ()

// si nous sommes arrivés ici, textBuff[0] = 'd' et textBuff[1] = 'w'

int épingle = –1;

int pinSetting = –1;

si (textBuff[[3] == "=" && textBuff[[6] == 0x0d) pinSetting < 0) printErrorMessage ();

autre printErrorMessage ();

int parsePinSetting ()

//regardez dans le tampon de texte pour trouver le réglage de la broche

//renvoie -1 si non valide

int pinSetting = –1;

si(textBuff[[4] == "l" && textBuff[[5] == "o") pinSetting = 0;

si(textBuff[[4] == "h" && textBuff[[5] == "je") pinSetting = 1;

revenir pinSetting;

néant doAnalogCommand ()

// si nous sommes arrivés ici, textBuff[0] = 'a'

commutateur (textBuff[[1])

Cas "r" : readAnalogPins (); Pause;

Cas "w" : writeAnalogPin (); Pause;

défaut: printErrorMessage (); Pause;

néant readAnalogPins ()

// si nous sommes arrivés ici, textBuff[0] = 'a' et textBuff[1] = 'r'

// check textBuff[2] est un CR alors

// sortie la valeur de chaque broche d'entrée analogique

si(textBuff[[2] == 0x0d)

pour (int je = 0; je < 6; je++)

client.impression("entrée analogique ");

client.imprimer (i);

client.impression(" est ");

client.println (analogRead (i));

autre printErrorMessage ();

néant writeAnalogPin ()

// si nous sommes arrivés ici, textBuff[0] = 'a' et textBuff[1] = 'w'

int épingle = –1;

int pwmSetting = –1;

si (textBuff[[3] == "=")

autre printErrorMessage ();

int parsepwmSetting ()

int pwmSetting = 0;

int textPosition = 4; //commencer à textBuff[4]

int chiffre;

faire

chiffre = parseDigit (textBuff[textPosition]); //rechercher un chiffre dans textBuff

si (chiffre > = 0 && chiffre <=9) //si chiffre trouvé

pwmSetting = pwmSetting * dix + chiffre; //décaler le résultat précédent et ajouter un nouveau chiffre

autre pwmSetting = –1;

textPosition++; //aller à la position suivante dans textBuff

//sinon à la fin de textBuff et pas trouvé de CR et pas eu d'erreur, continuez

tandis que(textPosition < 7 && textBuff[textPosition] ! = 0x0d && pwmSetting > –1);

//si la valeur n'est pas suivie d'un CR, retourne une erreur

si(textBuff[textPosition] ! = 0x0d) pwmSetting = –1;

revenir pwmSetting;

néant setPinMode ()

// si nous sommes arrivés ici, textBuff[0] = 'p'

int épingle = –1;

int pinModeSetting = –1;

si (textBuff[[1] == "m" && textBuff[[3] == "=" && textBuff[[6] == 0x0d)

//si oui, obtenez le numéro de broche, le réglage et définissez la broche

épingle = parseDigit (textBuff[[2]);

pinModeSetting = parseModeSetting ();

si(épingle > –1 && pinModeSetting == 0)

pinMode (broche, PRODUCTION);

client.println ("D'accord");

si(épingle > –1 && pinModeSetting == 1)

pinMode (broche, CONTRIBUTION);

client.println ("D'accord");

si(épingle < 0

autre printErrorMessage ();

int parseModeSetting ()

//regardez dans le tampon de texte pour trouver le réglage de la broche

//renvoie -1 si non valide

int pinSetting = –1;

si(textBuff[[4] == "o" && textBuff[[5] == "u") pinSetting = 0;

si(textBuff[[4] == "je" && textBuff[[5] == "n") pinSetting = 1;

revenir pinSetting;

int parseDigit (carboniser c)

int chiffre = –1;

chiffre = (int) c – 0x30; // soustraire 0x30 du code ASCII donne une valeur

si(chiffre < 0

néant printErrorMessage ()

client.println ("Commande non reconnue. ? pour aider.");

néant checkCloseConnection ()

// si nous sommes arrivés ici, textBuff[0] = 'c', vérifiez les deux suivants

// caractères pour vous assurer que la commande est valide

si (textBuff[[1] == "l" && textBuff[[2] == 0x0d)

fermer la connexion();

autre

printErrorMessage ();

néant fermer la connexion()

client.println (" nAu revoir. n");

client.Arrêtez();

connectFlag = 0;

néant printHelpMessage ()

client.println (" nExemples de commandes prises en charge: n");

client.println (" dr-lecture numérique: renvoie l'état des broches numériques 0 à 9");

client.println (" dr4 – lecture numérique: retourne uniquement l'état de la broche 4");

client.println (" ar -analog read: retourne toutes les entrées analogiques");

client.println (" dw0 = hi-écriture numérique: activer la broche 0 sur les broches valides sont de 0 à 9");

client.println (" dw0 = lo – écriture numérique: désactivez la broche 0, les broches valides sont comprises entre 0 et 9");

client.println (" aw3 = 222 – écriture analogique: définir la broche numérique 3 sur la valeur PWM 222");

client.println (" les broches autorisées sont 3,5,6,9");

client.println (" plage PWM autorisée 0 à 255");

client.println (" pm0 = en mode pin: définissez la broche 0 sur INPUT les broches valides sont de 0 à 9");

client.println (" pm0 = ou -pin mode: définissez la broche 0 sur OUTPUT les broches valides sont de 0 à 9");

client.println (" cl -close connexion");

client.println (" ? -imprimer ce message d'aide");

Click to rate this post! [Total: 0 Average: 0]