jmax17 a écrit 49 commentaires

  • # wireguard

    Posté par  . En réponse au journal Dédier une clé SSH au rebond sur un serveur. Évalué à 3.

    J'ai eu à faire du reverse SSH pour administrer des linux embarqués avec une connectivité 4g mais sans IP public.
    jusqu'au jour au j'ai trouvé wireguard et là ma vie est devenue tellement plus simple.

    est ce que l'utilisation de wireguard ne permettrait pas même chose sans les clés avec différent niveau de criticité ?

    merci encore pour le partage

  • # KerguelenKerguelen !!!

    Posté par  . En réponse au journal Openstreetmap et GPS garmin. Évalué à 9.

    Un journal qui commence par une carto centrée sur port aux français est forcement un bon journal :)

    Ker58 for ever

  • # Projet low cost

    Posté par  . En réponse au message Projet apprentissage / robotique pour enfant de 12 ans ?. Évalué à 1.

    Bonjour, tu as la possibilité de faire des projets lowcost à partir de brique élémentaire
    un chassie :

    https://fr.aliexpress.com/item/1005002281271908.html?spm=a2g0o.productlist.0.0.c2771ae80W9SVo&algo_pvid=727e2ef8-ff1d-4a45-87db-dc8d671341f1&algo_exp_id=727e2ef8-ff1d-4a45-87db-dc8d671341f1-0

    la commande des moteurs basé sur L298N
    https://fr.aliexpress.com/item/1005002705632944.html?spm=a2g0o.productlist.0.0.61303ec7ROWJC1&algo_pvid=8c947d38-e0d8-4c45-b1a7-19ec5a33ce56&algo_exp_id=8c947d38-e0d8-4c45-b1a7-19ec5a33ce56-5

    un petit arduino :
    https://fr.aliexpress.com/item/1005002293889882.html?spm=a2g0o.productlist.0.0.61303ec7ROWJC1&aem_p4p_detail=202106140924092765981073461320014119525

    et 3 decteur à ultrasons un à droite , un à gauche l'autre derriére pour détecter les colision et s'amuser à faire des trajectoires

    ensuite pour le code à 12 ans il peux commencer à coder en arduino
    sinon il y a plusieur projet pour faire du "scratch" sous arduino :
    http://robot-educatif.fr/comment-programmer-arduino-scratch/
    https://github.com/technologiescollege/BlocklyArduino_electrified

    il y a quelque anné j'avais utilsé arduiblock mais ce n'est plus libre :(

    bienvenus dans le monde merveilleux de la robotique :)

  • [^] # Re: .

    Posté par  . En réponse au message migration Svn vers Git. Évalué à 1. Dernière modification le 06 août 2019 à 14:42.

    Merci pour les info
    je n'ai pas penser au git-svn , j'étais en train de lire les doc de git-tree

  • [^] # Re: pas clair

    Posté par  . En réponse au journal Tirez-vous une bûche, qu'on cause C++ et singletons. Évalué à 4.

    Je trouve le singleton pratique pour la configuration globale du système, (sinon je dois passer mon objet config comme paramètre à tout mes autres objets )

    Dans ce cas la fonction main est ami du singleton, cela me permet de passer des paramètres à la création de l'objet à la condition qu'il soit le premier objet créer dans le main.
    mon singleton dispose de paramètre par défaut pour les tests des autres objets

  • [^] # Re: Agenda du libre ?

    Posté par  . En réponse au journal AG du L@bx 2016. Évalué à 1.

    oui c'est pas faux :(

  • [^] # Re: Petite question

    Posté par  . En réponse à la dépêche Les ateliers du labx : 1 - l’oscilloscope numérique. Évalué à 0.

    une antenne branchée à la sonde ?
    j'en ai aucune idée

  • [^] # Re: I²C est multi-master

    Posté par  . En réponse à la dépêche Les ateliers du labx : 1 - l’oscilloscope numérique. Évalué à 3.

    Oui cela est possible. J'ai réalisé ce genre de montage avec deux µC qui souhaitaient interroger les mêmes capteurs.
    En général les capteurs qui communiquent en I2C fournissent un GPIO pour faire une alerte.
    Le masteur programme des seuils, quand ces seuils sont atteints ils le signal avec le GPIO qui peut être branchée sur une interruption du masteur.
    mais cela fait beaucoup de fils à router

  • [^] # Re: Analyseur logique

    Posté par  . En réponse à la dépêche Les ateliers du labx : 1 - l’oscilloscope numérique. Évalué à 4.

    J'ai un miniDSO une voie que j'ai pus avoir à 50€
    il a une bande passante 10-15Mhz je ne suis pas certain de ça précision (je pourrais le tester avec le rigol)
    mais je peux avoir un scope qui dépanne dans ma sacoche de portable :)

  • [^] # Re: Nommage des structures

    Posté par  . En réponse au journal Ulfius: framework pour faire des API Web en C. Évalué à 2.

    ah oui ça marche :)
    merci pour l'info

  • [^] # Re: Nommage des structures

    Posté par  . En réponse au journal Ulfius: framework pour faire des API Web en C. Évalué à 1.

    oui j'ai zappé l'étoile :)

  • [^] # Re: Nommage des structures

    Posté par  . En réponse au journal Ulfius: framework pour faire des API Web en C. Évalué à 2.

    j'utilise cette syntaxe pour déclarer des structures chainées, mais tout mes structure sont des types définit par typedef

    //element d'une liste chainée
    typedef struct _item{
     void *data;
     int sizeData;
     struct _item voisin;
    } item;
    
    
    item header
  • # kicad is good

    Posté par  . En réponse au message Modéliser et faire fabriquer sa propre PCB. Évalué à 3.

    Kicad est un bon voir très soft pour faire concevoir son PCB, mais comme tout les logiciels de conception il faut le prendre en main.

    seeedstudio de fais de bonne carte pour pas chère, il suffit d'être un peu patient, il y a aussi elecrow dans le même genre.

    ils peuvent aussi souder tes composants, et c'est propre. Mais les composants CMS, si il ne sont pas trop petit peuvent se souder à la main.

    pense à mettre des entretoise pour fixer tes cartes rfid & Co sur ton PCB.

    Bon courage

  • # moto deux roues motrices

    Posté par  . En réponse au journal Moto journal: Le nucléaire passera-t-il ?. Évalué à 6.

    En électrique ils pourraient faire des motos deux roues motrices ?

  • # it's nice

    Posté par  . En réponse à la dépêche [Nice] Le Nicelab 3.0 est ouvert!. Évalué à 1.

    Long vie au NiceLab

  • [^] # Re: liste chainé bon exo

    Posté par  . En réponse au message Affichage listes chainées en C. Évalué à 1.

    Je ne connaissais pas les fonctions LISP.

    void cons(item *p , List *l){
      item *prev = l->first; //sauvegarde de l'ancienne tête
      l->first = p; //ajout de la nouvelle tête
      p->next = prev; //création de la chaine
    }
    
    /// car est la fonction get first
    item *car(list *l){
      return l->first;
    }
    
    //cdr est la fonction GetNext
    item *cdr(item *i){
      if(i) return i->next;
       return null;
    }

    donc pour extraire le 4eme
    cdr(cdr(cdr(car(MyList))))

  • # liste chainé bon exo

    Posté par  . En réponse au message Affichage listes chainées en C. Évalué à 1.

    Les listes chainé sont des bons exo pour manipuler les pointeurs
    Il parait que le C est un langage de bas niveaux, mais on peut quand même avoir une approche objet ou au moins structuré

    dans ta fonction main évite de manipuler directement les éléments de ta liste utilise des fonction comme addTail,AddHeader, getNext, delete …
    considère tout les champs de la structure comme priver au moins en ecriture

    j'aime bien utiliser deux structures pour ma liste
    * la liste
    * un élément de la liste

    typedef struct _item{
     void * data;
     struct *_item next;
    }item
    
    typedef struct{
     int nbItems;
     items *First; 
    }List;
    
    List * CreateList(){
      List *l = malloc(sizeof(List));
      l->nbItems = 0;
      l-> First = NULL;
      return l;
    }
    
    Item * CreateItem(void *MyData ){
      Item *p = malloc(sizeof(Item));
      p->next = null;
      p->data = myData;  
    }
    
    void addTail(List *MyList , void *MyData){
      if (! MyList->First){ //premier ajout 
        MyList->First = CretateItem(MyData);
      }
      else{
       item *end=MyList->First;
       while(end->Next) end = end->Next;
    
       end->Next = CreateItem(MyData);
      } 
    
      MyList->nbItem++;
    }
    
    Item *GetNext(Item *p){
     if(p) return p->next;
    
     return null
    }
    
    
    void main (){
     List *l = CreateList();
    //ajout des donnés 
    addTail(l,data); 
    
      for(item *i=getNext(L->First);i;i=getNext(i))
       Show(i);
    }
  • [^] # Re: ateliers_débutant

    Posté par  . En réponse à la dépêche Atelier CLI de la semaine 41/2015 à Bordeaux. Évalué à 1.

    Il faut voire les ateliers débutants comme un espace non définit,
    il n'y a pas de cours ou de programme définit. Nous avons essayé mais nous avons pas réussi.

    Mais rien empêche au groupe débutant de demander ou de faire un ateliers à leur niveau.
    Mais comme on souhaite tirer tout le monde par le haut les ateliers avancés sont ouvert à tous.A la seule conditions que l'intervenant ne soit pas interrompus avec des questions qui n'ont rien a voire avec le sujet.

  • # c++11 , boost ou QT

    Posté par  . En réponse au message Exploration système de fichier en UTF8 & accès MySQL ?. Évalué à 2.

    Salut
    pour développer en C++ tu devrais utiliser C++11 boost ou Qt

    dans c++11 une grande partie des objets boost ont été intégrés.
    l'objet std::string gère l'encodage utf8

    Avec Qt le développement est vraiment facile
    * Qt creator intègre est un bon IDE, mais tu n'es pas obligé de l'utiliser
    * la doc Qt est vraiment très bien faite.
    * mais il faut faire gaffe aux licences de Qt

  • [^] # Re: Verrou et RAII

    Posté par  . En réponse à la dépêche Instantané sur le parallélisme et le code. Évalué à 2.

    En C++

    on crée un objet mutex qui utilise les fonctions mutex du système

     class mutex{
       system_mutex mut;
     public:
       mutex(){system_mutex_init(mut);}
       void lock(){system_mutex_lock(mut);}
       void unlock(){system_mutex_unlock(mut);}
    };

    puis un objet mutexeLocker qui gère :
    * le verrouillage dans le constructeur
    * le déverrouillage dans le destructeur

     class mutexeLocker {
       mutex &mut;
     public:
       mutexeLocker (mutex &_mut):mut(_mut){mut.lock();}
       ~ mutexeLocker (mutex &_mut):mut(_mut){mut.unlock();}
    };

    exemple d'utilisation :

    mutex mut_de_var;
    string var="";
    
    void f(string &str)
    {
      mutexLocker mutLocker(mut_de_var); //verrou
      var = str;
      fonction_avec_execption();
      cout << str
     //destruction de mutlocker déverrouillage implicite 
    }
    
    void thread_1()
    {
      int cpt=0;
      while(1){
      try(){
      f(string("thread1 : ")<<cpt );
      }
      catch(){}
     }
    }
    
    
    void thread_2()
    {
      int cpt=0;
      while(1){
      try(){
      f(string("thread2 : ")<<cpt );
      }
      catch(){}
     }
    }

    bon sous Qt et boost tout est fait et certainement mieux fait :)

  • [^] # Re: Verrous, sémaphore et mutex

    Posté par  . En réponse à la dépêche Instantané sur le parallélisme et le code. Évalué à 2.

    un sémaphore est bloquant, que si son compteur interne est égal à 0.
    Si la taille du tuyau est infini, on n'a pas besoin de compter les places libres, le producteur peut produire sans contrainte, donc le système à besoin que d'un sémaphore

    J'ai oublié de parler de l'initialisation :
    au début on initialise les sémaphores:
    * le sémaphore, qui compte les places occupées, est initialisé à 0
    ** il n'y a pas eu, encore, de production
    ** les consommateurs seront bloqués en attente d'une production
    * le sémaphore, qui compte les place libre, est initialisé à la taille du tuyau
    ** le producteur peut produire autant d'élément qu'il y a de la place dans le tuyau

    Ce système fonctionne si la production et la consommation ont une vitesse moyenne équivalente, sinon le plus rapide attendra le plus lent.

  • [^] # Re: Verrous, sémaphore et mutex

    Posté par  . En réponse à la dépêche Instantané sur le parallélisme et le code. Évalué à 1.

    merci

  • [^] # Re: Verrous, sémaphore et mutex

    Posté par  . En réponse à la dépêche Instantané sur le parallélisme et le code. Évalué à 2.

    Dans mes études j'ai eu du mal a comprendre et appliquer le principe du modèle producteur/consommateur et puis un jour la révélation :
    * le producteur compte le nombre de place libre dans le tuyau et il bloque quand il n'y a plus de place libre
    * le consommateur compte le nombre de place "occupé" ou le nombre d'élément dans le tuyau et bloque si il n'y a plus rien
    * donc il nous faut
    ** un semaphore qui compte les places libre
    ** un semaphore qui compte les places occupée

    Le producteur
    * décrémente les places libres (sem_wait(place_libre) )
    ** bloque si place libre égale 0
    * produit
    * incrémente place occupée (sem_post(place_occupé) )

    Le consommateur
    * décrémente les places occupées (sem_wait(place_occupé) )
    ** bloque si place occupée égale 0
    * consomme
    * incrémente place libre (sem_post(place_libre) )

    Mais j'ai oublié la signification de V() et de P()

  • # Verrou et RAII

    Posté par  . En réponse à la dépêche Instantané sur le parallélisme et le code. Évalué à 1.

    En objet avec le principe RAII on peut créer un verrou qui sera libérer par le destructeur de l'objet.sous QT il y les QMutexLocker.
    * On créer un objet QMutexLocker sur la pile
    * Quand le programme quitte la fonction ( return au milieu ou exception ) l'objet QMutexLocker est détruit et le mutex libéré.

  • # Merci

    Posté par  . En réponse à la dépêche Atelier CLI : TDD en Bash, mardi 14 avril 2015 ⌚ 20h ⌘ Bordeaux. Évalué à 1.

    Merci à Michael pour sa présentation :)