Open Bidouille Robot : Différence entre versions

De Les Fabriques du Ponant
Aller à : navigation, rechercher
(Code Arduino)
m (+ Catégorie:Arduino)
(12 révisions intermédiaires par un autre utilisateur non affichées)
Ligne 31 : Ligne 31 :
  
 
== Ce qu'OBR sait faire pour le moment ==
 
== Ce qu'OBR sait faire pour le moment ==
Pour le moment (version 0.4), OBR ne sait pas faire grand chose, si ce n'est gérer les connexions entre arduinos, télécommandes et PC.
+
Pour le moment (version 0.6), OBR gére les connexions entre arduinos, télécommandes et PC.
 
Les commandes sont fonctionnelles, et on peut connaître le nom du robot, ainsi que sa version d'OBR installé.
 
Les commandes sont fonctionnelles, et on peut connaître le nom du robot, ainsi que sa version d'OBR installé.
 
Une session administrateur est gérée, on peut l'utiliser (mot de passe par défaut : 2560) pour configurer le robot.
 
Une session administrateur est gérée, on peut l'utiliser (mot de passe par défaut : 2560) pour configurer le robot.
Lorsque l'administrateur se connecte, la LED 13 s'allume pour dire que la configuration est susceptible d'être modifiée.
+
Lorsque l'administrateur se connecte, la LED 13 s'allume pour dire que la configuration est susceptible d'être modifiée, sauf si la sortie 13 est utilisée.
 +
On peut lui configurer des moteurs, servomoteurs, sorties digitales et des entrées, ainsi que les MIN et MAX des sorties PWM et des entrées analogiques.
 +
La configuration est enregistrée en EEPROM, et est inchangée après un redémarrage.
 +
On peut lier une sortie (PWM ou digitale) avec 1 PIN analog, et 3 PINs E/S. Ces liens permettent de sécuriser une sortie, en lui empêchant de bouger si un des liens lui interdit (ex : un moteur peut tourner jusqu'à ce que le capteur sur A0 soit à plus de 80%, ou que l'entrée sur le PIN 10 soit à 1).
 +
Pour augmenter le nombre de PIN, On peut mettre jusqu'à 3 arduino (un maître et deux esclaves) reliés via les ports séries, la communication entre les cartes se fait toute seule grâce au protocole de communication OBR3.
 +
Pour le moment, OBR v0.6 ne sait pas utiliser les PIN des autres cartes (Maitre, Esclave1 et Esclave2).
  
 
== Ce qu'il sera sensé faire plus tard ==
 
== Ce qu'il sera sensé faire plus tard ==
Dans le futur (version 1.0), OBR devra toujours gérer les connexions automatiquement et à chaud, mais aussi enregistrer les configurations dans l'EEPROM, pour s'en servir lors du pilotage (l'EEPROM sera copié dans différents tableaux en RAM au démarrage).
+
Dans le futur (version 1.0), OBR devra toujours gérer les connexions automatiquement et à chaud, mais le maître saura aussi gérer les deux esclaves (si présents), pour piloter ses entrées/sorties.
Le maître saura gérer les deux esclaves (si présents), pour piloter ses entrées/sorties.
 
 
OBR devra gérer les batteries, et se désactiver si nécessaire.
 
OBR devra gérer les batteries, et se désactiver si nécessaire.
 
Un système de WatchDog fonctionnera sur les ports séries, pour détecter la déconnexion d'un périphérique.
 
Un système de WatchDog fonctionnera sur les ports séries, pour détecter la déconnexion d'un périphérique.
Ligne 68 : Ligne 72 :
 
Une bibliothèque a été créée pour faciliter la communication entre un programme codé en C, et un arduino tournant sous OBR.
 
Une bibliothèque a été créée pour faciliter la communication entre un programme codé en C, et un arduino tournant sous OBR.
 
Cette bibliothèque est dépendant d'une autre, qui gère les connexions séries.
 
Cette bibliothèque est dépendant d'une autre, qui gère les connexions séries.
Les deux bibliothèques (OBR.h et Serial.h) seront disponible au téléchargement dès que possible.
+
Les deux bibliothèques (OBR.h et Serial.h) sont disponible au téléchargement, [github.com/Aglesia/OBR/blob/master/Dev/Bibliotheque_C ici].
  
Code OBR.h :
+
Code [https://github.com/Aglesia/OBR/blob/master/Dev/Bibliotheque_C/OBR.h OBR.h], sur GitHub
/**
 
 
Copyright (C) 2014 Fragni Dorian
 
 
This program is free software; you can redistribute it and/or modify
 
it under the terms of the GNU General Public License as published by
 
the Free Software Foundation; either version 2 of the License, or
 
(at your option) any later version.
 
 
This program is distributed in the hope that it will be useful,
 
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
GNU General Public License for more details.
 
 
You should have received a copy of the GNU General Public License along
 
with this program; if not, write to the Free Software Foundation, Inc.,
 
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 
*/
 
 
#ifndef OBR_H_INCLUDED
 
#define OBR_H_INCLUDED
 
 
#ifndef SERIAL_H_INCLUDED
 
#error "Aucune fonction de lecture du port série n'est disponible !!!"
 
#error "Veuillez inclure Serial.h"
 
#endif // SERIAL_H_INCLUDED
 
 
 
/// définition d'une structure de commande
 
typedef struct Commande_OBR
 
{
 
    char* Commande[128]; // Derniere commande reçue
 
    char* Nom[128]; // Nom du robot
 
    int PortArduino; // Port série sur lequel est connecté l'arduino
 
    int NoEnvoyeur; // N° du dernier envoyeur
 
    int NoDestinataire; // N° du dernier destinataire
 
    int MAITRE_ESCLAVE; // Définit sur quel type de carte le PC est branché (la variable contient l'adresse)
 
    int TELECOMMANDE_PC; // 1 si c'est le PC, 2 si c'est la télécommande
 
    double OBR_Version; // Version de l'OBR installé sur l'arduino
 
} Commande_OBR;
 
 
#define OBR_VERSION "1.3"
 
#define OBR_PC 1
 
#define OBR_TELECOMMANDE 2
 
 
/// Récupère la commande tapée en console (inutile pour un programme graphique)
 
void OBR_Commande_Console(char* Buffer, Commande_OBR *Commande);
 
 
/// Récupère la dernière commande reçue par l'arduino, retourne l'adresse de l'envoyeur
 
int OBR_Recup_Commande(Commande_OBR *Commande);
 
 
/// Envoie une commande à l'arduino
 
void OBR_Envoie_Commande(char* Message, Commande_OBR *Commande, int NoDestinataire);
 
 
/// Demande à l'arduino s'il est pret, retourne 0 si OK
 
int OBR_Arduino_Pret(Commande_OBR *Commande);
 
 
/// Envoie un message de watchdog pour maintenir la connexion active
 
void OBR_Maintenir_Connexion(Commande_OBR *Commande);
 
 
/// Demande à l'arduino une connexion, en se faisant passer pour un PC (configuration) ou une télécommande (pilotage), retourne l'adresse de la Commande_OBR si connecté
 
int OBR_Connecter(int NoPort, int TypePeripherique);
 
 
/// Deconnecte l'arduino du PC
 
void OBR_Deconnecter(Commande_OBR *Commande);
 
 
/// Faire une pause x ms
 
void delay(int millis);
 
 
#include "OBR.c"
 
#endif // OBR_H_INCLUDED
 
  
Le code de OBR.c :
 
  
/**
+
Le code de [https://github.com/Aglesia/OBR/blob/master/Dev/Bibliotheque_C/OBR.c OBR.c], sur GitHub
+
 
Copyright (C) 2014 Fragni Dorian
 
 
This program is free software; you can redistribute it and/or modify
 
it under the terms of the GNU General Public License as published by
 
the Free Software Foundation; either version 2 of the License, or
 
(at your option) any later version.
 
 
This program is distributed in the hope that it will be useful,
 
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
GNU General Public License for more details.
 
 
You should have received a copy of the GNU General Public License along
 
with this program; if not, write to the Free Software Foundation, Inc.,
 
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 
*/
 
 
#include <stdio.h>
 
#include <stdlib.h>
 
#include <string.h>
 
#include <time.h>
 
#define Debug 0
 
 
/// Demande à l'arduino une connexion, en précisant si on doit se faire passer pour un PC (Configuration) ou une télécommande (Pilotage), retourne l'adresse de la Commande_OBR si connecté
 
int OBR_Connecter(int NoPort, int TypePeripherique)
 
{
 
    if(TypePeripherique!=OBR_PC && TypePeripherique!=OBR_TELECOMMANDE)
 
        return 0;
 
 
    /// On ouvre le port série en 57600 bauds
 
    int PortOBR = OuvrirCom(NoPort, 5);
 
    if(!PortOBR)
 
        return 0;
 
 
    /// On crée une Commande_OBR
 
    Commande_OBR *Commande = malloc(sizeof(Commande_OBR));
 
    if(!Commande)
 
        return -1;
 
 
    Commande->PortArduino = PortOBR;
 
 
    /// On vérifie la présence de l'OBR sur l'arduino
 
    // On vide le buffer d'entrée
 
    Recup_Commande(Commande);
 
 
    // Vérification de la présence de l'OBR sur l'arduino
 
    if(TypePeripherique==OBR_PC)
 
        Envoie_Commande("OBR_CONNECTER_PC", Commande, 0);
 
    else
 
        Envoie_Commande("OBR_CONNECTER_TELECOMMANDE", Commande, 0);
 
    delay(500);
 
    Recup_Commande(Commande);
 
 
    // Si l'OBR n'est pas présent
 
    if(strcmp(Commande->Commande, "OK"))
 
    {
 
        // On libère la mémoire de la Commande_OBR
 
        free(Commande);
 
 
        // On ferme le port série
 
        FermerCom(PortOBR);
 
 
        // On retourne 0;
 
        return 0;
 
    }
 
 
    if(Debug)
 
        printf("OBR Connecte\n");
 
 
    /// On récupère l'adresse
 
    Commande->MAITRE_ESCLAVE = Commande->NoEnvoyeur;
 
    Commande->TELECOMMANDE_PC = TypePeripherique;
 
 
    /// On récupère sa version
 
    Commande->MAITRE_ESCLAVE = Commande->NoEnvoyeur;
 
    Envoie_Commande("OBR_VERSION", Commande, Commande->MAITRE_ESCLAVE);
 
    Recup_Commande(Commande);
 
    Commande->OBR_Version = atof(Commande->Commande);
 
    if(Debug)
 
        printf("Version : %f\n", Commande->OBR_Version);
 
 
    /// On récupère son nom
 
    Envoie_Commande("OBR_NOM", Commande, Commande->MAITRE_ESCLAVE);
 
    Recup_Commande(Commande);
 
    strcpy(Commande->Nom, Commande->Commande);
 
    if(Debug)
 
        printf("Nom : %s\n", Commande->Nom);
 
 
    /// On retourne l'adresse de la Commande_OBR
 
    return Commande;
 
}
 
 
void OBR_Deconnecter(Commande_OBR *Commande)
 
{
 
    if(Commande->OBR_Version>=0.37)
 
    {
 
        Envoie_Commande("OBR_DECONNECTER_ADMIN", Commande, Commande->MAITRE_ESCLAVE);
 
        Envoie_Commande("OBR_DECONNEXION_AUTO-1", Commande, Commande->MAITRE_ESCLAVE);
 
        Envoie_Commande("OBR_DECONNECTER", Commande, Commande->MAITRE_ESCLAVE);
 
    }
 
    else
 
        Envoie_Commande("OBR_DECONNECTER", Commande, Commande->MAITRE_ESCLAVE);
 
    FermerCom(Commande->PortArduino);
 
    free(Commande);
 
}
 
 
int ArduinoPret(Commande_OBR *Commande)
 
{
 
    double InitTime = clock();
 
    double EndTime = InitTime;
 
 
    Envoie_Commande("OBR_PRET", Commande, Commande->MAITRE_ESCLAVE);
 
 
    while(InitTime+2000 > EndTime)
 
    {
 
        Recup_Commande(Commande);
 
        if(!strcmp(Commande->Commande, "VRAIE") || !strcmp(Commande->Commande, "ADMIN"))
 
        {
 
            if(!strcmp(Commande->Commande, "VRAIE"))
 
                return 1;
 
            else
 
                return 2;
 
        }
 
        delay(100);
 
        EndTime = clock();
 
    }
 
    return 0;
 
}
 
 
void Commande_Console(char* Buffer, Commande_OBR *Commande)
 
{
 
    int NbCaractere = 0;
 
    char DernierCaractere = NULL;
 
    strcpy(Buffer, "");
 
 
    /// Tant qu'on a pas de "\n", ou qu'on ne dépasse pas les 128 caractères, on attend.
 
    while(DernierCaractere!='\n' && NbCaractere<128)
 
    {
 
        /// On récupère les 128 premiers caractères (ou jusqu'au \n)
 
        DernierCaractere = getchar();
 
        if(DernierCaractere!=NULL && DernierCaractere!='\n')
 
        {
 
            /// Si c'est une lettre minuscule, on la met en majuscule
 
            if(DernierCaractere <= 'z' && DernierCaractere >= 'a')
 
                DernierCaractere-=32;
 
 
            Buffer[NbCaractere]=DernierCaractere;
 
            NbCaractere++;
 
            Buffer[NbCaractere]='\0';
 
            DernierCaractere=NULL;
 
        }
 
    }
 
}
 
 
int Recup_Commande(Commande_OBR *Commande)
 
{
 
    strcpy(Commande->Commande, "");
 
    char Buffer[130]="";
 
 
    /// Tant qu'on a pas de "\n", ou qu'on est pas encore dans les 100ms, on attend.
 
    unsigned long Delay = clock();
 
    int ChainePrete = 0;
 
 
    /// On récupère caractère par caractère, on s'arrête au '\n'.
 
    while(!ChainePrete && Delay+200>clock())
 
    {
 
        RecevoirCom(Commande->PortArduino, Buffer);
 
 
        /// On assemble la chaine
 
        if(strcmp(Buffer, "") && strlen(Commande->Commande)+strlen(Buffer)<sizeof(Commande->Commande))
 
            strcat(Commande->Commande, Buffer);
 
        strcpy(Buffer, "");
 
 
        /// On regarde si la ligne est complete
 
        if(strchr(Commande->Commande, '\n'))
 
            ChainePrete = 1;
 
        delay(1);
 
    }
 
 
    if(!ChainePrete)
 
        return 1;
 
 
    /// On séparre la commande, des adresses
 
    strcpy(Buffer, Commande->Commande);
 
    sscanf(Buffer, "[%d|%d]%s\n", &Commande->NoEnvoyeur, &Commande->NoDestinataire, Commande->Commande);
 
 
    /// On laisse le temps au système pour ne pas le surcharger
 
    delay(5);
 
 
    return 0;
 
}
 
 
void Envoie_Commande(char* Message, Commande_OBR *Commande, int NoDestinataire)
 
{
 
    char *Char = NULL, Temp[130]="";
 
    /// Si on ne demande pas à quitter
 
    if(strcmp(Message, "EXIT"))
 
    {
 
        /// On remplace tous les " " par des "-"
 
        do
 
        {
 
            Char = strchr(Message, ' ');
 
            if(Char)
 
                *Char = '-';
 
        } while(Char!=NULL);
 
 
        /// La commande exacte est du type "OBR_[COMMANDE]-[PARAM1]-[PARAM2]-...".
 
        /// Ici, on peut écrire "_[COMMANDE]-...", voir juste "[COMMANDE]-...", le programme ajoute le "OBR_" devant.
 
 
        /// On regarde si la commande commence par une adresse
 
        if(!strncmp(Message, "M:", 2)) // Maitre
 
        {
 
            strcpy(Temp, Message);
 
            strcpy(Message, Temp+2);
 
            NoDestinataire = 3;
 
        }
 
 
        if(!strncmp(Message, "E1:", 3)) // Esclave1
 
        {
 
            strcpy(Temp, Message);
 
            strcpy(Message, Temp+3);
 
            NoDestinataire = 4;
 
        }
 
 
        if(!strncmp(Message, "E2:", 3)) // Esclave2
 
        {
 
            strcpy(Temp, Message);
 
            strcpy(Message, Temp+3);
 
            NoDestinataire = 5;
 
        }
 
 
        if(!strncmp(Message, "P:", 2)) // PC
 
        {
 
            strcpy(Temp, Message);
 
            strcpy(Message, Temp+2);
 
            NoDestinataire = 1;
 
        }
 
 
        if(!strncmp(Message, "T:", 2)) // Telecommande
 
        {
 
            strcpy(Temp, Message);
 
            strcpy(Message, Temp+2);
 
            NoDestinataire = 2;
 
        }
 
 
        /// On regarde si "_" est présent.
 
        if(!strncmp(Message, "_", 1))
 
        {
 
            /// S'il le faut, on lui ajoute "OBR" devant la Commande->
 
            strcpy(Temp, "OBR");
 
            strcat(Temp, Message);
 
            strcpy(Message, Temp);
 
            strcpy(Temp, "");
 
        }
 
        /// On regarde si "OBR_" est absent.
 
        if(strncmp(Message, "OBR_", 4))
 
        {
 
            /// S'il le faut, on lui ajoute "OBR_" devant la Commande->
 
            strcpy(Temp, "OBR_");
 
            strcat(Temp, Message);
 
            strcpy(Message, Temp);
 
            strcpy(Temp, "");
 
        }
 
        /// On ajoute l'adresse à la commande
 
        sprintf(Commande->Commande, "[%d|%d]%s\n", Commande->TELECOMMANDE_PC, NoDestinataire, Message);
 
 
        /// On envoie la commande
 
        EnvoyerCom(Commande->Commande, Commande->PortArduino);
 
 
        /// On laisse le temps au système pour ne pas le surcharger
 
        delay(5);
 
    }
 
}
 
 
void MaintenirConnexion(Commande_OBR *Commande)
 
{
 
 
}
 
 
void delay(int millis)
 
{
 
    double InitTime = clock();
 
    double DelayTime = InitTime+millis;
 
    while(DelayTime>clock());
 
    return;
 
}
 
  
 
'''Des suggestions ? Des conseils ? Je suis preneur ;)'''
 
'''Des suggestions ? Des conseils ? Je suis preneur ;)'''
Ligne 441 : Ligne 85 :
 
TeC'OBiR utilise la bibliothèque OBR pour fonctionner...
 
TeC'OBiR utilise la bibliothèque OBR pour fonctionner...
  
Code : main.c
+
Code : [https://github.com/Aglesia/OBR/blob/master/Dev/TeC_OBiR/main.c main.c], sur GitHub.
 
 
/**
 
 
Copyright (C) 2014 Fragni Dorian
 
 
This program is free software; you can redistribute it and/or modify
 
it under the terms of the GNU General Public License as published by
 
the Free Software Foundation; either version 2 of the License, or
 
(at your option) any later version.
 
 
This program is distributed in the hope that it will be useful,
 
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
GNU General Public License for more details.
 
 
You should have received a copy of the GNU General Public License along
 
with this program; if not, write to the Free Software Foundation, Inc.,
 
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 
*/
 
 
#include <stdio.h>
 
#include <stdlib.h>
 
#include <string.h>
 
/// Bibliothèque de gestion des ports séries
 
#include "../Bibliotheques/Serial.h"
 
/// Bibliothèque de communication OBR
 
#include "../Bibliotheques/OBR.h"
 
 
/// Liste des fonctions
 
void AfficherAide();
 
 
int main()
 
{
 
    Commande_OBR *Commande = 0;
 
    int NoPort = 0, temp = 0;
 
    char Buffer[130] = "";
 
 
    #ifdef WIN32
 
        system("Title Tec'OBir");
 
        system("COLOR 09");
 
    #endif
 
 
    /// Message de bienvenue
 
    printf("Bienvenue dans TeC'OBiR (Terminal Configuration for Open Bidouille Robot) V1.3\nCe programme est developpe par Dorian Fragni et le FabLab des fabriques du ponan.\nIcone de http://icons8.com.\nLe programme sert a configurer/deboguer un arduino tournant sour Open Bidouille Robot.\n\n");
 
    SELECTPORT:
 
    printf("Scan des ports en cours...\n");
 
    Commande = 0;
 
 
    while(!Commande)
 
    {
 
        for(NoPort=0; NoPort<10; NoPort++)
 
        {
 
            Commande = OBR_Connecter(NoPort, OBR_PC);
 
            if(Commande)
 
                break;
 
        }
 
    }
 
 
    if(Commande)
 
    {
 
        printf("\n%s V%f Connecte !\n", Commande->Nom, Commande->OBR_Version);
 
        /// Si la version est plus grande que la 0.1
 
        if(Commande->OBR_Version >= 0.2)
 
        {
 
            /// On désactive la déconnexion auto
 
            if(Commande->OBR_Version >= 0.37)
 
                Envoie_Commande("OBR_DECONNEXION_AUTO-0", Commande, Commande->MAITRE_ESCLAVE);
 
            Recup_Commande(Commande);
 
 
            /// On s'authentifie si possible
 
            printf("Connexion en tant qu'admin...\n");
 
            /// Selon la version, la commande de connexion en admin n'est pas ma même
 
            if(Commande->OBR_Version<0.37)
 
                Envoie_Commande("OBR_CONNECTER-2560", Commande, Commande->MAITRE_ESCLAVE);
 
            else
 
                Envoie_Commande("OBR_CONNECTER_ADMIN-2560", Commande, Commande->MAITRE_ESCLAVE);
 
            Recup_Commande(Commande);
 
            if(!strcmp(Commande->Commande, "OK"))
 
                printf("Connecte en tant qu'administrateur.\n");
 
            else
 
            {
 
                /// Le mot de passe n'est pas 2560, on demande le mot de passe
 
                printf("Mot de passe : ");
 
                scanf("%s", Commande->Commande);
 
                /// On vide le buffer d'entrée
 
                while(getchar()!='\n' && getchar()!='EOF');
 
                if(Commande->OBR_Version<0.37)
 
                    sprintf(Buffer, "OBR_CONNECTER-%s", Commande->Commande);
 
                else
 
                    sprintf(Buffer, "OBR_CONNECTER_ADMIN-%s", Commande->Commande);
 
                Envoie_Commande(Buffer, Commande, Commande->MAITRE_ESCLAVE);
 
                Recup_Commande(Commande);
 
                if(!strcmp(Commande->Commande, "OK"))
 
                    printf("Connecte en tant qu'administrateur.\n");
 
                else
 
                    printf("Le mot de passe n'est pas bon, Connecte en tant que simple utilisateur.\n");
 
            }
 
        }
 
 
        /// On invite l'utilisateur à entrer ses commandes
 
        printf("Vous pouvez maintenant entrer vos commandes ;)\n128 caracteres MAX par commande !\n\nHELP=afficher l'aide et la liste des commandes\nVERSION=Afficher la version du programme\nEXIT=fermer la connexion et quitter\n\n");
 
        strcpy(Buffer, "");
 
 
        /// Tant qu'on ne quitte pas
 
        while(strcmp(Buffer, "EXIT"))
 
        {
 
            /// On vide les buffers
 
            strcpy(Buffer, "");
 
            strcpy(Commande->Commande, "");
 
 
            /// On demande à l'arduino s'il est prêt, il répond 1 si on est utilisateur, 2 si on est administrateur, et rien s'il est déconnecté
 
            temp = ArduinoPret(Commande);
 
            if(temp == 1)
 
                printf("@utilisateur>");
 
            else if(temp == 2)
 
                printf("@administrateur>");
 
            else
 
                {
 
                    printf("Impossible de communiquer avec l'arduino, verifiez sa connexion.\nDeconnexion et scan des ports en cours...\n");
 
                    OBR_Deconnecter(Commande);
 
                    Commande = 0;
 
                    goto SELECTPORT;
 
                }
 
 
 
            /// On récupère la commande entrée par l'utilisateur
 
            Commande_Console(Buffer, Commande);
 
 
            /// Si on demande l'aide
 
            if(!strcmp(Buffer, "HELP"))
 
                AfficherAide();
 
            /// Si on demande la version de l'OBR installé sur l'arduino
 
            else if(!strcmp(Buffer, "VERSION"))
 
                printf("Version d'OBR : %f\n", Commande->OBR_Version);
 
            else
 
            {
 
                /// On envoie la commande
 
                Envoie_Commande(Buffer, Commande, Commande->MAITRE_ESCLAVE);
 
 
                /// On récupère la réponse
 
                Recup_Commande(Commande);
 
                /// S'il y a une réponse, on l'écrit à l'écran
 
                if(strcmp(Commande->Commande, ""))
 
                {
 
                    switch(Commande->NoEnvoyeur)
 
                    {
 
                    case 1:
 
                        printf("P:>%s\n", Commande->Commande);
 
                    break;
 
 
                    case 2:
 
                        printf("T:>%s\n", Commande->Commande);
 
                    break;
 
 
                    case 3:
 
                        printf("M:>%s\n", Commande->Commande);
 
                    break;
 
 
                    case 4:
 
                        printf("E1:>%s\n", Commande->Commande);
 
                    break;
 
 
                    case 5:
 
                        printf("E2:>%s\n", Commande->Commande);
 
                    break;
 
 
 
                    default:
 
                        printf("?>%s\n", Commande->Commande);
 
                    break;
 
                    }
 
                }
 
            }
 
        }
 
 
        /// on se déconnecte et on arrête le programme
 
        printf("\nFermeture du port, et arret du programme...");
 
        OBR_Deconnecter(Commande);
 
        Commande = 0;
 
    }
 
    return 0;
 
}
 
 
void AfficherAide()
 
{
 
    printf("\n\nAide :\nPour envoyer une commande, tappez la commande certifiee OBR, puis faites 'entree'.\nApres 1/10 de seconde, le programme affiche le retour, et vous rend la main.\n");
 
    printf("\nListe des commandes de base :\n");
 
    printf("OBR_PRESENT=Retourne VRAIE si OBR est present\n");
 
    printf("OBR_VERSION=Retourne la version d'OBR installee\n");
 
    printf("OBR_PRET=Retourne VRAIE si vous etes un utilisateur, ADMIN si vous etes un administrateur\n");
 
    printf("Pour toutes les commandes, veuillez vous referer a la documentation.\n\n");
 
}
 
  
 
== Changelog ==
 
== Changelog ==
Ligne 650 : Ligne 101 :
  
 
0.3 :
 
0.3 :
 +
- Utilisation du protocole de communication OBR3
 
  - Ajout du système d'authentification sur les ports série
 
  - Ajout du système d'authentification sur les ports série
 
  - Ajout de la prise en charge des cartes d'extension (jusqu'à deux cartes d'extensions) via RS232 (Mais les cartes seront inactives, sauf pour demander la liste des connexions externes)
 
  - Ajout de la prise en charge des cartes d'extension (jusqu'à deux cartes d'extensions) via RS232 (Mais les cartes seront inactives, sauf pour demander la liste des connexions externes)
  - Ajout du mapage réseau, permettant de relier le PC, télécommande et les cartes d'extensions sur n'importe quel port série (de n'importe quelle carte d'extension)
+
  - Ajout du mappage réseau, permettant de relier le PC, télécommande et les cartes d'extensions sur n'importe quel port série (de n'importe quelle carte d'extension)
 
  - Ajout du système d'adresse dans les commandes, permettant le routage des données à travers les cartes ([1|2]OBR_...)
 
  - Ajout du système d'adresse dans les commandes, permettant le routage des données à travers les cartes ([1|2]OBR_...)
  - Ajout des constantes de compilation pour définir le nom du robot, et son rôle (maitre/esclave), ainsi que le type (MEGA, UNO...)
+
  - Ajout des constantes de compilation pour définir le nom du robot, et son rôle (maître/esclave), ainsi que le type (MEGA, UNO...)
 
  - Ajout de la détection de déconnexion série, et déconnexion auto de l'administrateur
 
  - Ajout de la détection de déconnexion série, et déconnexion auto de l'administrateur
  
 
0.4 :
 
0.4 :
  - WatchDog plus intelligent, évite la surcharge du réseau lorsque ça discute
+
  - Ajout des fonctions de gestion des E/S dans le noyau
  - Mise en place de la configuration des cartes d'extension via les ports série, permettant de les utiliser
+
  - prise en compte des limites imposées dans les sorties PWM
  - Centralisation du pilotage des cartes, via le maitre
+
- Mise à jour auto des valeurs des E/S
 +
  - Réorganisation du code et séparation des fonctions du noyau, des autres fonctions
 +
- Ajout de deux fonctions (user_setup et user_loop) modifiable par l'utilisateur
 +
 
 +
0.5 :
 
  - Mise en place des codes d'erreur dans le noyau du système
 
  - Mise en place des codes d'erreur dans le noyau du système
 
  - Mise en place des fonctions de copie RAM->EEPROM et EEPROM->RAM, contenant les données de fonctionnement (liste des moteurs, capteurs...)
 
  - Mise en place des fonctions de copie RAM->EEPROM et EEPROM->RAM, contenant les données de fonctionnement (liste des moteurs, capteurs...)
 
0.5 :
 
 
  - Ajout des fonctions de mise en place des périphériques (moteurs, capteurs...)
 
  - Ajout des fonctions de mise en place des périphériques (moteurs, capteurs...)
 +
- Sauvegarde des PIN E/S pour les restaurer au boot
 +
- Ajout d'une commande de redémarrage du système
 
  - Ajout de toutes les commandes de pilotage
 
  - Ajout de toutes les commandes de pilotage
- Gestion du pilotage des autres cartes
 
  
'''Pour le moment, la dernière version est la 0.37 : tout ce qui est dit dans la version 0.3 est faite, et une partie de la version 0.4 est traitée.'''
+
0.6 :
 +
- Redémarrage d'un moteur en douceur après un arrêt brutal (Lien qui bloque le moteur d'un coup)
 +
- Suppression du système de blocage de la carte, remplacé par un redémarrage complet du système
 +
- La remise à 0 du mot de passe ne bloque plus l'arduino
 +
- Changement de la gestion des commandes, chaque commande enregistre sa réponse et le système la retourne à la fin des commandes (permet de dire quand une commande est inconnue)
 +
- Séparation des commandes de pilotage et de configuration
 +
- Ajout de la gestion des liens, au sein d'une carte
 +
- L'état de l'activation du watchdog est enregistré en EEPROM, et est restauré au démarrage
 +
- Renommage des fonctions du noyau
 +
 
 +
0.7 :
 +
- Changement de la gestion des numéro de PWM : maintenant on envoie son n° de PIN (et non plus n°PWM) en paramètre
 +
- La liaison entre le PIN 12 et 13 au démarrage réinitialise le mot de passe, mais aussi toutes les configurations
 +
- WatchDog plus intelligent, évite la surcharge du réseau lorsque ça discute
 +
- Correction du BUG qui laisse la LED 13 allumée quand on la déconnecte
 +
- Déconnexion de l'administrateur lors du pilotage
 +
 
 +
0.8 :
 +
- Utilisation de F() pour économiser de la RAM, sur les String des différentes commandes
 +
- Correction de Bugs empêchant la connexion entre deux arduino
 +
- Refonte totale de la gestion des connexions entre les cartes
 +
- Passage partielle au protocole OBR4
 +
- Utilisation de la bibliothèque <Servo.h>
 +
- Déconnexion automatique des PWM connectés sur les PIN verrouillés par la bibliothèque <Servo.h>
 +
- Arrêt complet des moteurs lors de la déconnexion (Valeur_Voulue mis à 0, sauf pour les servomoteurs)
 +
- Ajout de la valeur à 0 pour une sortie (peut être 0 ou 1)
 +
- Watchdog non désactivable
 +
 
 +
0.9 :
 +
- Ajout d'identifiants devant la commande pour connaître le type de message (réponse, commande, watchdog...)
 +
- Gestion centralisée par le maître, on peut configurer une E/S d'une autre carte, en passant par le maître
 +
- Mise en place des liens entre toutes les cartes
 +
- Ajout des entrées/sorties virtuelles, qui se mettent à un automatiquement si tous les liens le permettent
 +
- Doublage du nombre de liens (passage à 2 liens Analogique et 6 liens numériques
 +
 
 +
1.0 :
 +
- Première version finale
 +
- Contient toutes les commandes de pilotage
 +
- Contient toutes les commandes de configuration
 +
- Utilise le protocole OBR4, non compatible OBR3 (utilisé jusqu'à la v0.7)
 +
- Le système de WatchDog des connexions séries est fonctionnel
 +
- On peut brancher et débrancher une carte du réseau à chaud
 +
- On peut connecter une télécommande OBRoC sans problème
 +
- Entièrement compatible avec TeC'OBiR 1.5 et supérieur
 +
 
 +
'''Pour le moment, la dernière version est la 0.8.'''
  
 
=== TeC'OBiR ===
 
=== TeC'OBiR ===
Ligne 686 : Ligne 186 :
 
  - Détection de la déconnexion de l'arduino
 
  - Détection de la déconnexion de l'arduino
 
  - Ajout de la connexion admin
 
  - Ajout de la connexion admin
  - Passage au baudrate de 57600 bauds.
+
  - Passage au baud-rate de 57600 bauds.
  
 
1.2
 
1.2
Ligne 697 : Ligne 197 :
  
 
1.3
 
1.3
  - Ajout du choix de l'adresse destinatrice (Commande sous forme "add:OBR_COMMANDE-PARAMS" ex : pour connaitre le nom du maitre, "M:OBR_NOM")
+
  - Ajout du choix de l'adresse destinatrice (Commande sous forme "add:OBR_COMMANDE-PARAMS" ex : pour connaitre le nom du maître, "M:OBR_NOM")
 
  - Ajout de l'adresse émettrice dans la réponse
 
  - Ajout de l'adresse émettrice dans la réponse
 
  - Séparation du code TeC'OBiR et de la bibliothèque OBR_Communication
 
  - Séparation du code TeC'OBiR et de la bibliothèque OBR_Communication
  
 
1.4
 
1.4
  - Adaptation au protocole OBR 0.4, qui inclus un watchdog sur la connexion série
+
- Passage à l'essai des 50 premier ports séries
 +
  - Adaptation partielle au protocole OBR 4, qui inclus un watchdog obligatoire sur la connexion série
 +
- Ajout d'un thread pour la gestion du watchdog
 +
 
 +
1.5
 +
- Adaptation complète au protocole OBR 4
 +
 
 +
1.6
 
  - Prise en charge des fichiers de config .map
 
  - Prise en charge des fichiers de config .map
 
  - Peut être ouvert avec, comme paramètre, un fichier .map. La configuration auto se fera dès que la connexion est effectuée
 
  - Peut être ouvert avec, comme paramètre, un fichier .map. La configuration auto se fera dès que la connexion est effectuée
  
'''Pour le moment, la dernière version est la 1.27, qui désactive le chien de garde à la connexion, pour éviter les déconnexions intempestives. (il faudrait mettre moins de 5 secondes à taper une commande, et ne jamais s'arrêter...)'''
+
'''Pour le moment, la dernière version est la 1.3, le chien de garde est désactivé à la connexion, pour éviter les déconnexions intempestives. (il faudrait mettre moins de 5 secondes à taper une commande, et ne jamais s'arrêter...)'''
  
 
== Liens de téléchargements ==
 
== Liens de téléchargements ==
Ligne 716 : Ligne 223 :
 
=== Binaires finalisées ===
 
=== Binaires finalisées ===
 
==== Open Bidouille Robot (à compiler sur un arduino) ====
 
==== Open Bidouille Robot (à compiler sur un arduino) ====
[https://github.com/Aglesia/OBR/blob/master/Versions_Finies/OBR/OBR%20v0.37.ino OBR v0.37]
+
[https://github.com/Aglesia/OBR/blob/master/Versions_Finies/OBR/OBR%20v0.6.ino OBR v0.6]
  
 
==== Terminal Console for Open Bidouille Robot ====
 
==== Terminal Console for Open Bidouille Robot ====
 
[https://github.com/Aglesia/OBR/blob/master/Versions_Finies/TeC'OBiR/TeC'OBiR%20v1.3.exe TeC'OBiR Win32 1.3]
 
[https://github.com/Aglesia/OBR/blob/master/Versions_Finies/TeC'OBiR/TeC'OBiR%20v1.3.exe TeC'OBiR Win32 1.3]
 +
[https://github.com/Aglesia/OBR/blob/master/Versions_Finies/TeC'OBiR/TeCOBiR%20v1.3_Linux TeC'OBiR Linux 1.3]
  
 
==== Open Bidouille Robot Contrôleur Arduino (à compiler sur un arduino) ====
 
==== Open Bidouille Robot Contrôleur Arduino (à compiler sur un arduino) ====
Ligne 733 : Ligne 241 :
  
 
[[Catégorie:Projets]]
 
[[Catégorie:Projets]]
 +
[[Catégorie:Arduino]]

Version du 13 octobre 2016 à 09:41

Qu'est-ce qu'Open Bidouille Robot (OBR) ?

Open Bidouille Robot est un micrologiciel pour arduino, permettant la gestion de moteurs, capteurs, servomoteurs, entrée numériques et sorties numériques. En d'autres termes, OBR sert à la création de robot, via un arduino. Une fois compilé et installé sur la carte, il faut configurer OBR (via le PC par exemple) en envoyant une série de commandes. Une fois configuré, on peut toujours le reconfigurer (ajouter/enlever des servomoteurs, changer la vitesse maximum d'un moteur, etc...), mais aussi le piloter. Lorsqu'on demande à un moteur de tourner, OBR va vérifier dans la configuration s'il est lié à d'autres objets (capteurs, entrées, sorties...), et verrouiller ou non le moteur (de même pour une sortie tout ou rien, et un servomoteur). De cette manière, nous pouvons créer des systèmes de fin de courses, en liant plusieurs choses (ex : le moteur ne peut tourner que si le capteur vaut moins que x, et que l'entrée n°y est à 0).

Pourquoi ce projet ?

A la base, j'ai été à l'Open Bidouille Camp (d'où le choix de reprendre ce nom pour le projet) de 2012, où j'ai rencontré une connaissance qui voulait faire un robot démineur sans savoir programmer. Je partais donc avec un engin sur roues, avec un bras motorisé au dessus, mais non pilotable. De base, je devais donc coder un programme sur un arduino Mega2560, permettant de piloter les moteurs inclus dans l'engin. il y a peu, j'ai mis de côté le robot démineur pour me concentrer sur les robots en général. C'est donc de là que m'est venu l'idée de coder un système modulable, et adaptable à tous types de robots.

Communication avec OBR

La communication avec OBR suit une norme qui lui est propre, sous la forme : "[AdresseEnvoyeur|AdresseDestinataire]OBR_COMMANDE-PARAMETRES\n" Le protocole est assez strict, mais simple :

- La communication se fait via les ports séries, en 57600 bauds.
- Le dialogue se fait via des commandes, avec (au max) trois paramètres, et deux adresses (envoyeur et destinataire)
- Toutes les commandes ont un retour, même si ce n'est qu'un "OK"
- Il n'y a aucun espace dans une ligne
- La commande se termine toujours par un retour à la ligne ('\n')
- Les paramètres sont séparés par des tirets ('-')
- Un message peut passer par plusieurs cartes, il y a un système de routage, d'où l'obligation des adresses
- Seul la commande de demande de connexion n'a pas d'adresse, mais la réponse en a une (On ne sais pas à qui on se connecte, mais on sait qui nous répond)
- Le réseau peut se constituer d'un maître, épaulé par deux esclaves (pour augmenter le nombre de PIN), une télécommande, et un PC.
- Il y a donc 5 adresses : 1=PC, 2=Télécommande, 3=Maître, 4=Esclave1 et 5=Esclave2.
- Il ne peut pas y avoir deux périphériques du même type, comme deux PC, ou deux télécommandes.
- Le maître, l'esclave1 et l'esclave2 sont distincts, et ne peuvent pas changer (définit à la compilation). De ce fait, les adresses des PIN allant jusqu'à 255, on peut déterminer le N° du PIN (pour 234, c'est 34) et le N° de la carte (pour 234, c'est l'eclave2).
- Les connexions peuvent se faire en série, les commandes seront routées pour arriver à bon port.

Exemple de connexion entre le PC et le maître : PC <===========> {Esclave2 <=> esclave1 <=> Maître} : L'esclave2 recevra le message, le transmettra à l'esclave1, qui le transmettra au maître. c'est le chemin inverse que fera la réponse.

Ce qu'OBR sait faire pour le moment

Pour le moment (version 0.6), OBR gére les connexions entre arduinos, télécommandes et PC. Les commandes sont fonctionnelles, et on peut connaître le nom du robot, ainsi que sa version d'OBR installé. Une session administrateur est gérée, on peut l'utiliser (mot de passe par défaut : 2560) pour configurer le robot. Lorsque l'administrateur se connecte, la LED 13 s'allume pour dire que la configuration est susceptible d'être modifiée, sauf si la sortie 13 est utilisée. On peut lui configurer des moteurs, servomoteurs, sorties digitales et des entrées, ainsi que les MIN et MAX des sorties PWM et des entrées analogiques. La configuration est enregistrée en EEPROM, et est inchangée après un redémarrage. On peut lier une sortie (PWM ou digitale) avec 1 PIN analog, et 3 PINs E/S. Ces liens permettent de sécuriser une sortie, en lui empêchant de bouger si un des liens lui interdit (ex : un moteur peut tourner jusqu'à ce que le capteur sur A0 soit à plus de 80%, ou que l'entrée sur le PIN 10 soit à 1). Pour augmenter le nombre de PIN, On peut mettre jusqu'à 3 arduino (un maître et deux esclaves) reliés via les ports séries, la communication entre les cartes se fait toute seule grâce au protocole de communication OBR3. Pour le moment, OBR v0.6 ne sait pas utiliser les PIN des autres cartes (Maitre, Esclave1 et Esclave2).

Ce qu'il sera sensé faire plus tard

Dans le futur (version 1.0), OBR devra toujours gérer les connexions automatiquement et à chaud, mais le maître saura aussi gérer les deux esclaves (si présents), pour piloter ses entrées/sorties. OBR devra gérer les batteries, et se désactiver si nécessaire. Un système de WatchDog fonctionnera sur les ports séries, pour détecter la déconnexion d'un périphérique.

TeC'OBiR (Terminal Configuration pour Open Bidouille Robot), un programme PC pour configurer OBR

Le Terminal TeC'OBiR est codé en C, en console, et permet de communiquer aisément avec un arduino tournant sous OBR. TeC'OBiR intègre la bibliothèque de communication OBR, ce qui lui permet de dialoguer avec OBR (un maître, un esclave ou une télécommande) facilement. Lorsqu'on lance TeC'OBiR, les 10 premiers ports séries sont scannés en boucle, tant qu'une carte sous OBR n'est pas connectée. Les avantages d'utiliser TeC'OBiR plutôt qu'un terminal série quelconque, sont multiples :

- La connexion se fait toute seule en arrière plan, aucune commande n'est à taper
- Une fois connectée, on a le nom du robot, et la version d'OBR installée.
- Les commandes que l'on tape sont mises en norme : Toutes les lettres sont mises en majuscule, les espaces sont remplacées par des tirets, les adresses sont automatiquement ajoutées, ainsi que le "OBR_" au début de la commande.
- L'adresse est automatiquement définie selon la carte sur laquelle nous sommes connectés (maître, esclave, télécommande).
- Il est possible de choisir sont destinataire en ajoutant 'x:' avant la commande, x étant variable (p: pour le PC, t: pour la télécommande, m: pour le maître, e1: pour l'esclave1 et e2 pour l'esclave2).
- Si le mot de passe est 2560, la connexion en tant qu'administrateur se fait automatiquement, sinon, le mot de passe est demandée, pour une connexion automatique.
- Entre chaque commande envoyée, le programme vérifie la connexion avec OBR, et se déconnecte si la carte est débranchée.

Exemple de commandes qu'on peut écrire avec TeC'OBiR, pour connaître le nom du maitre :

- "[1|3]OBR_NOM\n"
- "OBR_nOm"
- "nom"
- "m:nom"

Code Arduino

Le code de la version en développement, sur GitHub : ici.

Code C de TeC'OBiR

Bibliothèque de communication OBR en C

Une bibliothèque a été créée pour faciliter la communication entre un programme codé en C, et un arduino tournant sous OBR. Cette bibliothèque est dépendant d'une autre, qui gère les connexions séries. Les deux bibliothèques (OBR.h et Serial.h) sont disponible au téléchargement, [github.com/Aglesia/OBR/blob/master/Dev/Bibliotheque_C ici].

Code OBR.h, sur GitHub


Le code de OBR.c, sur GitHub


Des suggestions ? Des conseils ? Je suis preneur ;)

Code de TeC'OBiR

TeC'OBiR utilise la bibliothèque OBR pour fonctionner...

Code : main.c, sur GitHub.

Changelog

OBR

0.1 :

- Première version, non fonctionnelle

0.2 :

- Mise en place du système de question/réponse, sous forme de commande de type OBR_COMMANDE-PARAMETRE1-PARAMETRE2-PARAMETRE3
- Ajout du mode administrateur
- Ajout des modes configuration et pilotage
- Première version du calcul du niveau de batterie
- Passage du port série en 57600 bauds
- Ajout du mot de passe, et son système de réinitialisation à "2560"

0.3 :

- Utilisation du protocole de communication OBR3
- Ajout du système d'authentification sur les ports série
- Ajout de la prise en charge des cartes d'extension (jusqu'à deux cartes d'extensions) via RS232 (Mais les cartes seront inactives, sauf pour demander la liste des connexions externes)
- Ajout du mappage réseau, permettant de relier le PC, télécommande et les cartes d'extensions sur n'importe quel port série (de n'importe quelle carte d'extension)
- Ajout du système d'adresse dans les commandes, permettant le routage des données à travers les cartes ([1|2]OBR_...)
- Ajout des constantes de compilation pour définir le nom du robot, et son rôle (maître/esclave), ainsi que le type (MEGA, UNO...)
- Ajout de la détection de déconnexion série, et déconnexion auto de l'administrateur

0.4 :

- Ajout des fonctions de gestion des E/S dans le noyau
- prise en compte des limites imposées dans les sorties PWM
- Mise à jour auto des valeurs des E/S
- Réorganisation du code et séparation des fonctions du noyau, des autres fonctions
- Ajout de deux fonctions (user_setup et user_loop) modifiable par l'utilisateur

0.5 :

- Mise en place des codes d'erreur dans le noyau du système
- Mise en place des fonctions de copie RAM->EEPROM et EEPROM->RAM, contenant les données de fonctionnement (liste des moteurs, capteurs...)
- Ajout des fonctions de mise en place des périphériques (moteurs, capteurs...)
- Sauvegarde des PIN E/S pour les restaurer au boot
- Ajout d'une commande de redémarrage du système
- Ajout de toutes les commandes de pilotage

0.6 :

- Redémarrage d'un moteur en douceur après un arrêt brutal (Lien qui bloque le moteur d'un coup)
- Suppression du système de blocage de la carte, remplacé par un redémarrage complet du système
- La remise à 0 du mot de passe ne bloque plus l'arduino
- Changement de la gestion des commandes, chaque commande enregistre sa réponse et le système la retourne à la fin des commandes (permet de dire quand une commande est inconnue)
- Séparation des commandes de pilotage et de configuration
- Ajout de la gestion des liens, au sein d'une carte
- L'état de l'activation du watchdog est enregistré en EEPROM, et est restauré au démarrage
- Renommage des fonctions du noyau

0.7 :

- Changement de la gestion des numéro de PWM : maintenant on envoie son n° de PIN (et non plus n°PWM) en paramètre
- La liaison entre le PIN 12 et 13 au démarrage réinitialise le mot de passe, mais aussi toutes les configurations
- WatchDog plus intelligent, évite la surcharge du réseau lorsque ça discute
- Correction du BUG qui laisse la LED 13 allumée quand on la déconnecte
- Déconnexion de l'administrateur lors du pilotage

0.8 :

- Utilisation de F() pour économiser de la RAM, sur les String des différentes commandes
- Correction de Bugs empêchant la connexion entre deux arduino
- Refonte totale de la gestion des connexions entre les cartes
- Passage partielle au protocole OBR4
- Utilisation de la bibliothèque <Servo.h>
- Déconnexion automatique des PWM connectés sur les PIN verrouillés par la bibliothèque <Servo.h>
- Arrêt complet des moteurs lors de la déconnexion (Valeur_Voulue mis à 0, sauf pour les servomoteurs)
- Ajout de la valeur à 0 pour une sortie (peut être 0 ou 1)
- Watchdog non désactivable

0.9 :

- Ajout d'identifiants devant la commande pour connaître le type de message (réponse, commande, watchdog...)
- Gestion centralisée par le maître, on peut configurer une E/S d'une autre carte, en passant par le maître
- Mise en place des liens entre toutes les cartes
- Ajout des entrées/sorties virtuelles, qui se mettent à un automatiquement si tous les liens le permettent
- Doublage du nombre de liens (passage à 2 liens Analogique et 6 liens numériques

1.0 :

- Première version finale
- Contient toutes les commandes de pilotage
- Contient toutes les commandes de configuration
- Utilise le protocole OBR4, non compatible OBR3 (utilisé jusqu'à la v0.7)
- Le système de WatchDog des connexions séries est fonctionnel
- On peut brancher et débrancher une carte du réseau à chaud
- On peut connecter une télécommande OBRoC sans problème
- Entièrement compatible avec TeC'OBiR 1.5 et supérieur

Pour le moment, la dernière version est la 0.8.

TeC'OBiR

1.0

- Utilise le protocole OBR
- On peut enlever "OBR" et "OBR_" au début de la commande
- Tous les espaces sont remplacés par des tirets
- Commande 'HELP' affiche l'aide et les commandes existantes lors de la création de la version 1.0
- Commande 'EXIT' Ferme la connexion et quitte le programme

1.1

- La casse est automatiquement mise en majuscule sur les commandes envoyées
- Ajout de la couleur bleue
- Ajout de la commande 'VERSION' qui affiche la version du programme
- Connexion automatique en essayant les 10 premiers ports en boucles
- Détection de la déconnexion de l'arduino
- Ajout de la connexion admin
- Passage au baud-rate de 57600 bauds.

1.2

- réécriture du noyau
- Adaptation au nouveau protocole OBR 0.3
- Prise en compte des adresses

1.27

- Désactivation automatique du WatchDog inclus sur l'OBR 0.37 et +

1.3

- Ajout du choix de l'adresse destinatrice (Commande sous forme "add:OBR_COMMANDE-PARAMS" ex : pour connaitre le nom du maître, "M:OBR_NOM")
- Ajout de l'adresse émettrice dans la réponse
- Séparation du code TeC'OBiR et de la bibliothèque OBR_Communication

1.4

- Passage à l'essai des 50 premier ports séries
- Adaptation partielle au protocole OBR 4, qui inclus un watchdog obligatoire sur la connexion série
- Ajout d'un thread pour la gestion du watchdog

1.5

- Adaptation complète au protocole OBR 4

1.6

- Prise en charge des fichiers de config .map
- Peut être ouvert avec, comme paramètre, un fichier .map. La configuration auto se fera dès que la connexion est effectuée

Pour le moment, la dernière version est la 1.3, le chien de garde est désactivé à la connexion, pour éviter les déconnexions intempestives. (il faudrait mettre moins de 5 secondes à taper une commande, et ne jamais s'arrêter...)

Liens de téléchargements

Un compte a été ouvert sur GitHub pour centraliser les fichiers sources...

Documents techniques + notices

Notice d'utilisation d'OBR

Binaires finalisées

Open Bidouille Robot (à compiler sur un arduino)

OBR v0.6

Terminal Console for Open Bidouille Robot

TeC'OBiR Win32 1.3 TeC'OBiR Linux 1.3

Open Bidouille Robot Contrôleur Arduino (à compiler sur un arduino)

Open Bidouille Robot Contrôleur PC

Changelog

Changelog OBR Changelog TeC'OBiR

Lien GitHub

GitHub Open Bidouille Robot