Première expérience : une commande importante d’un distributeur « DIY »

J’ai acheté chez un distributeur du secteur DIY, pas mal de matériel pour aménager une salle de bain. Il y avait une vingtaine de colis dans ma commande, et donc cela faisait une « belle commande ». 

Déjà, les livreurs étaient incapables de me donner une fenêtre de livraison meilleure que 8h30 – 13h. Comme c’est une livraison pour une maison en construction, j’ai du attendre, depuis 8h30, sur le chantier, pour une livraison qui est arrivée à 11h30.

Les livreurs arrivent. Dès leurs arrivée il me disent qu’il sont pressés. Je leur dis qu’il faudra juste que je puisse pointer que ce qui est livré correspond à ce que j’ai commandé. 

Là, l’un des gars se retourne vers son collègue et dit : « on est encore tombé sur un con ». ça démarrait fort !

La suite a été à la hauteur de ce démarrage. Ton agressif, ils n’étaient que sur leur point de vue (on va être en retard, …). A aucun moment ils ne se sont souciés de mes sujets. 

Au final, je me suis retrouvé avec tous les colis, déposés à l’entrée du garage. Je n’ai pas voulu signer l’avis de réception, car ils n’ont pas voulu que je pointe les colis livrés. 

Je dois avouer que j’étais pas rassuré, ils étaient dans un tel état que je sentais bien qu’il n’en fallait pas beaucoup pour qu’ils deviennent violents.

Deuxième expérience : une commande chez un vendeur d’ameublement 

Hazard du calendrier, j’ai reçu ce matin un canapé, acheté chez un vendeur d’ameublement. 

Déjà, le créneau était d’une heure.

Les gars sont arrivés, calme et poli. Ils ont pris le temps de se présenter, de voir comment ils pourraient installer le canapé. 

Ils étaient attentifs à mes besoins… Bref, c’était parfait.

En conclusion

Les premiers livreurs étaient des sous traitants, sans doute avec des clauses pour livrer un maximum de commandes dans un temps limité. Les contrats doivent avoir des prix serrés, et il ne doit pas y avoir grand chose sur la qualité de service. J’imagine que le distributeur n’a même pas pris le temps de rencontrer les gars qui vont réellement faire la livraison. Bref, le distributeur a manifestement privilégié le prix à la qualité de service.

Les deuxièmes livreurs sont employés du vendeur. Ils y bossent depuis des années. Ils m’ont dit : la seule chose qu’on nous demande, c’est la satisfaction du client.

Cela ne veut pas dire qu’on ne peut pas déléguer une prestation à un sous traitant, mais par contre, il est fondamental de se poser les bonnes question quand on fait ça, et de s’assurer que le service sera de qualité. 

Cet article La qualité de la livraison : un sujet clé pour le ecommerce. Les extrêmes est apparu en premier sur Geek et Shift.

On a franchi le pas il y a quelques mois, avec Marcel, un berger australien.

(Marcel cet été, 18 mois, il adore se baigner )

Je me suis intéressé au dressage, et c’est génial a quel point cela a évolué. Aujourd’hui, le lien entre le chien et ses maîtres est bien plus subtil que ce qu’on faisait il y a quelques années. On parle d’éducation positive, on ne cherche pas le rapport de force, et c’est super.

Je me suis aussi intéressé au développement de l’intelligence. 

C’est comme ça que je suis tombé sur cette vidéo, qui montre une chercheuse qui teste les limites de l’intelligence du chien avec des raisonnement déductifs : 

Je me suis lancé dans le développement de cette machine !

L’idée est assez simple : 

• L’écran est séparé en deux parties
• On affiche une image dans chaque partie
• Si le chien clique du bon côté, il a une récompense

Le coeur de la machine est un Raspberry Pi.

J’ai d’abord essayé avec un écran tactile, mais la truffe humide du chien marche pas bien. J’ai donc ajouté deux panneaux de plastique, avec des petits boutons poussoirs pour savoir quel côté est cliqué, ça marche bien mieux.

En fait, le plus compliqué a été de faire le distributeur de récompenses. Je n’ai pas trouvé de modèles tout fait, et en impression 3D, je n’ai trouvé que des distributeurs de croquettes. 

Après plusieurs tentatives, ce modèle là marche plutôt bien : 

J’ai construit un premier prototype, très moche mais fonctionnel. 

Et comme ça marche bien, j’en ai construit un deuxième pour Martin, mon fils, qui a aussi pris un chien. Le deuxième modèle est aussi un proto, mais bien plus compacte, mieux fait, plus joli et plus solide.

Niveau programme, j’ai fait ça en python, vous pouvez récupérer ça ici. 

Rien de très compliqué, la classe Strategy peut être spécialisée, pour faire différents exercices. 

Bon ça c’est la technique.

Comment ça s’est passé avec Marcel ?

Et bien c’est intéressant ;).

D’abord, il a fallut lui apprendre à « cliquer ». Je pensais pas que ça serait si compliqué. Comme il ne comprenait pas du tout ce qu’il fallait faire, j’ai commencé avec un livre posé sur une table, avec un bout ouvert, et si Marcel réussissait à faire bouger le livre sur la commande « touche », il avait une récompense. 

Bon il a fini par comprendre, et on a pu rentrer dans le vif du sujet, avec la « Machine ». 

Au début, j’affichais une image blanche sur les deux côtés, et il avait une récompense quelque soit le côté cliqué.

Maintenant qu’il a bien compris, j’en suis au stade d’après : une image s’affiche, d’un côté ou de l’autre, et Marcel a une récompense s’il clique du bon côté. 

Là aussi, j’ai eu un peu de mal, et pour l’aider à comprendre, j’ai ajouté une séparation physique entre les deux parties de l’écran. 

On en est là, Marcel s’entraine tous les jours, et j’ai l’impression que les performances s’améliorent. 

J’ai bien tous les résultats en base de données, mais je n’ai pas encore fait d’application pour « voir » la progression

Une fois qu’il aura bien compris qu’il ne gagne que s’il clique du bon côté, on augmentera la difficulté, avec plusieurs images « négatives » qui changent, … Je vous raconterais ça.

Cet article Dog Training Machine – Comment tester et développer l’intelligence de votre chien ? est apparu en premier sur Geek et Shift.

J’aime bien les histoires de startups : ça parle d’un monde que je connais bien, et je trouve qu’effectivement il y a de quoi raconter de belles histoires, avec de l’émotion, des rebondissements, …

Là, Super pumped, c’est la grosse déception : 

L’histoire n’est absolument pas crédible, à un point qui rend l’histoire complètement inintéressante.

Par exemple, on nous montre comment Travis, ayant besoin d’argent, fini par se résoudre à aller voir son investisseur, et lui demande de l’argent, en lui transmettant le montant demandé…

C’est n’importe quoi : 

Un investisseur suit ses lignes d’investissements, en participant au conseil d’administration (ou Board en anglais). Le CEO a prévu un plan (le fameux Business Plan), et régulièrement, en général tous les trois mois, le CEO vient présenter la situation à son board, qui challenge le CEO pour comprendre pourquoi les choses ne se passent pas comme prévu (elles se passent rarement comme prévu )

Le niveau de Burn Rate (argent dépensé = argent gagné moins total des dépenses, sur une période donnée) est donc un indicateur tout à fait fondamental et suivi très régulièrement. 

Toujours sur cet exemple, si un investisseur réinjecte de l’argent dans une startup, il le fait dans un cadre bien défini : à quelle valeur, avec quelles règles du jeux : c’est le rôle du pacte d’actionnaires. 

J’ai donc lâché, je ne verrais pas la suite ;). 

Cet article La série sur Uber – Super Pumped : bof… est apparu en premier sur Geek et Shift.

En fait cela fait très longtemps qu’on parle de ça : 

Philippe Desfray avait dans les années 90 sorti un livre : La fin de la programmation.

L’idée générale est que programmer est compliqué, mais qu’on peut « faire des choses » sans apprendre à programmer.

Si on pense à une application web « classique », on peut découper le travail en trois couches : 

• Interface : comment l’application s’affiche, comment sont structurés les pages, avec quels contenus et quelle présentation ?
• Données : comment les données sont stockées, quelles sont les tables, les champs dans ces tables ?
• Logique applicative : quelle est la logique de l’application, quels sont les choses à faire en fonction des actions des utilisateurs et des données stockées ?

Ces grosso modo ce qu’on appelle la modélisation MVC.

L’approche No Code doit couvrir ces trois sujets. 

Pour la partie interface, il est clair que de bons outils de conception et d’édition WYSIWYG doivent pouvoir faire le job. C’est d’ailleurs ce que j’utilise en ce moment pour éditer ce billet dans WordPress, il y a plusieurs outils d’édition HTML intégrés. 

Pour les données, ça se fait également très bien : au lieu d’apprendre à manipuler une base de données, une interface où l’on peut définir des tables et des champs fait très bien l’affaire.

Pour la partie logique : on peut imaginer des blocs avec des traits entre les blocs pour définir le comportement de l’application. 

Alors, on est bon ? On peut vraiment réaliser une application sans coder ?

Oui on peut réaliser une application avec des outils comme Bubble.io sans écrire une ligne de code.

Mais au fond, qu’apporte le NoCode ?

Qui a dit que programmer c’était forcément ouvrir un éditeur de texte pour écrire le code ?

En fait, quand on défini la logique avec des blocs, on programme ! Simplement on utilise un langage et une représentation du langage qui n’est pas du texte, mais des boites, avec des boutons « DropDown ».

Et pour réaliser une vrai application, il va falloir passer du temps à apprendre ce langage. 

Alors je comprends bien que pour un débutant en programmation, cela peut sembler plus facile de faire les choses dans un environnement graphique qu’avec un éditeur de texte.

Pourtant, la programmation a beaucoup évoluée, et les outils d’éditions sont aujourd’hui extrêmement puissants.

Au final, je trouve que les solutions de type Bubble.io sont très bien, mais que l’appellation NoCode est bullshit : ces solutions permettent de réaliser des applications, mais demandent du temps pour bien s’y mettre et bien comprendre la logique de la solution. Au final, on doit apprendre un langage, qui a l’avantage d’être très guidé graphiquement, mais qui a l’inconvénient d’être spécifique à une solution, et forcément moins puissant qu’un « vrai » langage de programmation.

Une autre piste est également possible : on peut utiliser l’IA pour générer automatiquement un programme, à partir d’une description du besoin exprimée en « français ». C’est une piste intéressante, mais j’en parlerai dans un autre billet ;).

Cet article NoCode : Vraiment ? est apparu en premier sur Geek et Shift.

Il faut dire que le sujet de l’émission était important : La souveraineté numérique.

Mais c’est quoi la souveraineté numérique ?

L’idée générale est que la France, ou plus largement l’Europe, devraient avoir une dépendance limitée, contrôlée, dans le domaine du numérique.

J’ai découvert au passage qu’il y a même un institut et un site web sur le sujet (mais sans domaine HTTPS ).

Le problème, c’est que c’est très large comme sujet !

Je propose de découper le sujet avec les trois catégories suivantes : 

• Services Grand Public ;
• Plateformes de services B2B ;
• Infrastructures.

Ce découpage en trois catégories permet de mettre en avant que : 

• Il s’agit clairement de sujets stratégiques, qu’on n’aimerai bien maîtriser ;
• On est globalement très en retard sur ces différents domaines. Enfin on peut dire que c’est trié en ordre décroissant : 
  • L’Europe est pratiquement inexistante, au niveau des services Grands Publics ;
  • On a des acteurs qui savent faire des choses au niveau des services B2B, comme OVH, Scaleway, mais on est objectivement très loin d’un acteur comme Amazon ;
  • Des acteurs européens sont bien présents pour fournir des solutions d’infrastructure. Je dois avouer que c’est la partie que je connais le moins : je ne sais pas si un Ericsson est compétitif par rapport à Huawei.

Pour revenir à l’émission que j’ai écouté, j’ai trouvé ça dommage finalement de traiter les choses de manière aussi large. En mélangeant ces différents sujets, le débat est resté à un niveau très superficiel, et donc sans grand intérêt.

Chaque domaine doit être analysé indépendamment des autres.

Prenons les services grands publics :

Personne n’est obligé d’utiliser ces solutions ! Elles sont utilisés car elles sont très bien faites, et l’usage se développe de manière virale. Il est difficile, probablement impossible d’imposer une solution.

On peut imaginer que l’état légifère, et interdise certaines solutions ? J’y crois pas trop… Mais Trump n’a pas hésité lui… On peut également imaginer que l’Europe pousse à la construction de solutions locales, comme ce qui a été fait avec Qwant, et avec le succès très très limité que l’on connait.

Contrairement à ce que j’entends ou lis, il est extrêmement difficile de créer des services avec ce niveau de qualité. Ce n’est pas impossible pour autant : l’exemple de Whatsapp est intéressant… Même s’ils ont été ensuite racheté par Facebook : c’est un exemple concret d’une toute petite boite qui réussi a s’imposer au niveau mondial, avec des centaines de millions d’usagers (au moment de la revente).

Pour les autres sujets, plus B2B, on pourrait plus facilement imaginer une politique encourageant l’usage de solutions Européennes.

Cet article La souveraineté numérique ? est apparu en premier sur Geek et Shift.

Je l’ai fait.

Arduino ordinateur complet, avec l’Arduino Mega, le clavier, l’écran, le composant Horloge et le composant lecteur de carte SD

J’avais en tête de faire un ensemble d’articles, avec une progression « pédagogique », mais ce n’est pas très compatible avec mon agenda actuel… Je vais donc faire un article de résumé sur ce sujet. Si vous avez des questions, j’y répondrai avec plaisir.

donc un ordinateur, il faut un processeur, un clavier et un écran.

J’ai donc assemblé : 

• Un Arduino Mega
• Un écran LCD 40 caractères sur 4 lignes
• Deux claviers, chacun composé de 16 touches
  • Un premier clavier pour saisir des nombres en hexadécimal (de 0 à F donc)
  • Un deuxième clavier pour sélectionner les options

A cette configuration de base j’ai ajouté par la suite : 

• Un lecteur de carte SD, pour sauvegarder les programmes
• Une horloge, pour associer la date et l’heure aux programmes sauvegardés.

Une fois notre matériel défini, il faut passer à la couche logicielle, et en particulier au langage de programmation. 

Mon idée a été de partir sur un pseudo assembleur, ou chaque instruction est composé :

• D’une action
• Eventuellement d’un paramètre

L’environnement sera composé d’un espace mémoire (que j’appellerai RAM par la suite) et de trois registres, nommés A B et C.

Une action est une instruction simple, comme :

• Déplacer une valeur de la RAM vers un registre (ou l’inverse)
• Afficher un caractère à l’écran
• Faire une opération, comme, par exemple une addition. Dans ce cas, l’opération se fait de la manière suivante : C = A + B
• Définir un Label : c’est une adresse qui sera ensuite utilisée pour un branchement vers cet endroit du programme
• Faire un saut vers un label. Un saut peut être inconditionnel, conditionnel (si un registre vaut 0 par exemple). J’ai ajouté également la notion de Jump Sub, qui permet d’aller à un label, puis de revenir juste après le Jump Sub, avec un Return.
• … On dispose en tout d’une centaine d’instructions…

Vous trouverez dans ce document l’ensemble des instructions de ce pseudo assembleur.

Le langage est stocké de manière très simple : 

• Un octet pour enregistrer le code de l’opération
• Deux octets pour enregistrer le paramètre.

Le langage est stocké dans l’EEPROM de l’Arduino. En effet, un des problèmes de l’Arduino est la place très limitée de la mémoire vive. Stocker le programme en EEPROM permet donc d’économiser la place mémoire, et également au passage de rendre persistant le programme, même quand on éteint l’Arduino.

La RAM est composée de deux parties : 

• Une première partie de 1k octets, est stockée en mémoire vive
• Une deuxième partie, également de 1k, stockée en EEPROM

La RAM est utilisée pour :

• Enregistrer des variables applicatives
• Gérer la mémoire de l’écran
• Gérer une pile

La pile est en fait une double pile : 

• Une pile est utilisée pour enregistrer l’adresse du retour, suite à un JUMP SUB (on va donc se débrancher à un label donné, puis revenir poursuivre l’exécution)
• Une pile applicative, pour stocker des variables 

La petite astuce a consisté à utiliser le même espace mémoire, pour stocker les deux piles, chaque pile utilisant une extrémité de l’espace réservé.

L’ordinateur s’utilise de la manière suivante : 

• On est soit en mode Exécution, soit en mode Edition
• En mode Edition, on édite le programme, en tapant le code de l’action, et éventuellement le code du paramètre, avec le clavier hexadécimal donc. L’éditeur permet de faire défiler le programme, ligne à ligne, ou 4 lignes par 4 lignes ;
• En mode Exécution, on peut lancer l’exécution, ou alors passer en mode Pas à pas, et exécuter le programme ligne à ligne pour voir ce qui se passe et éventuellement débugger. Le mode exécution affiche sur la première ligne la valeur des 3 registres A B C, et affiche en dessous le programme en cours d’exécution ;
• En mode Edition, on peut également gérer les programmes stockés sur la carte SD. Le programme courant est automatiquement sauvegardé avec CURRENT.car comme nom.  On peut dupliquer un programme, le renommer, ou charger un programme pour l’exécuter. Petite subtilité : pour taper le nom d’un programme, il faut saisir la valeur hexadécimal de chaque caractère… 

Le mode Edition est plutôt sympa, car l’interface affiche l’instruction, dès qu’on a tapé son code.

Les programmes sont stockés sur carte SD en mode texte « Pseudo assembleur », et sont donc assez lisibles. Cela permet d’éditer ces programmes depuis un ordinateur, puis de les copier sur la carte SD (les programmes doivent être dans le répertoire PRGM de la carte SD avec comme extension « CAR »).

Voici un exemple de programme stocké sur la carte SD : 

SCR_ON       # Basculer en mode SCREEN
LABEL 0040   # LOOP
SCR_CLR      # Effacer l'écran
PRT_TM       # Afficher l'heure
SCR_NL       # retour à la ligne
PRT_DT       # Afficher la date
JUMP 0040    # LOOP

Vous trouverez ici l’ensemble du code source permettant de faire tourner l’ordinateur.

Le code est séparé en différentes classes. Voici les principales classes : 

• Engine est le point d’entrée principale, pointant vers l’Editor (l’éditeur) et le Program ;
• Editor est la classe en charge de l’édition ;
• Program est la classe en charge de l’environnement d’exécution. Cette classe contient le grand « switch » permettant d’exécuter une ligne du programme ;
• Instructions est la classe gérant le programme lui même, c’est à dire la liste des instructions.

Voici quelques remarques suite à cette expérience de programmation sur Arduino :

• La mise au point des programmes est assez délicate, car les erreurs ne sont en générale pas gérée, et génèrent des comportements aléatoires du processeur…
• Pour la mise au point, j’ai souvent utilisé une classe Log, permettant d’afficher sur le moniteur série des messages.
• L’espace mémoire est très limité, il faut en particulier mettre toutes les constantes en EEPROM.

Dans le doc sur le langage, vous trouverez également une page pour imprimer les étiquettes à coller sur les touches des claviers :

Voila, ceux qui veulent essayer doivent avoir a peu près ce qu’il faut pour le faire

Je vous souhaite à tous un bon été. 

Cet article Ordinateur à partir d’un Arduino est apparu en premier sur Geek et Shift.

La magie Arduino, c’est que c’est super facile.

Les composants que j’ai pris sont : 

• Arduino Mega (copie)
• Un écran LCD
• Deux claviers de 16 touches

Pour le montage, j’ai découpé une planche de 20 cm par 15 cm.

Pour que les fils puissent passer dessous, j’ai ajouté des petites cales en bois de 5 mm, à chaque coin. 

Le clavier a 8 fils : 4 lignes et 4 colonnes. On détecte qu’une touche est enfoncée si une ligne et une colonne sont connectées :

Il est assez facile de brancher ensemble deux matrices, il suffit de brancher les lignes entre elles (ou les colonnes, au choix), on aura donc 4 lignes, et 8 colonnes, soit 32 touches différentes, avec 12 fils.

J’ai utilisé des nappes toutes faites pour faire les branchements. 

Voici le plan de câblage pour brancher ensemble les deux claviers : 

Sur ce modèle de clavier, le premier et le dernier pin est non utilisé.

Les 4 premiers pins (après le 1er inutile donc) sont les colonnes, et les 4 suivants les lignes.

On branche ensemble les colonnes, et on soude une nappe comme indiqué sur le schéma ci dessus.

Le branchement sur l’Arduino se fait comme cela, des pin 22 à 44 :

J’ai fait passé la nappe sous la planche de bois, pour pas être embêté avec la nappe quand on utilise l’ordinateur.

Reste à programmer, pour s’assurer que ça marche.

Si vous ne savez pas programmer un Arduino, il existe des tonnes de tuto en ligne (comme celui ci par exemple).

On va donc écrire un petit programme, qui va tester que les claviers fonctionnent correctement.

voici ce que ça donne :

#include "Keypad.h"

define KEY_ROWS 8 // 8 lignes
define KEY_COLS 4 // 4 colonnes

// On indique ou sont branchés les lignes et les colonnes : 
const byte _colPins[KEY_COLS] = {44, 42, 40, 38};
const byte _rowPins[KEY_ROWS] = {36, 34, 32, 30, 28, 26, 24, 22};

// On défini un tableau ou chaque touche sera affecté à un caractère : 
const char _keys[KEY_ROWS][KEY_COLS] = {
// Première matrice : on met juste des lettres, qui permettrons d'identifié quelle touche est utilisée
  {'G', 'H', 'I', 'J'},
  {'K', 'L', 'M', 'N'},
  {'O', 'P', 'Q', 'R'},
  {'S', 'T', 'U', 'V'},

// Deuxième matrice : on met les caractères correspondants aux lettre Hexa, de 0 à F
  {'0', '1', '2', '3'},
  {'4', '5', '6', '7'},
  {'8', '9', 'A', 'B'},
  {'C', 'D', 'E', 'F'},
};

// On peut créer la variable globale, permettant de "piloter" le clavier
Keypad keypad = Keypad( 
  makeKeymap(_keys), 
  _rowPins, _colPins, 
  KEY_ROWS, KEY_COLS );

void setup() {
  // On ouvre le port série, pour pouvoir afficher sur l'ordinateur si notre montage fonctionne
  Serial.begin(9600);
};

void loop() {
  // On va afficher sur le port série toutes les touches tappées
  char key = keypad.getKey();
  Serial.println(key);
};

Pour que ça marche, il faut ajouter la librairie associée à ces claviers, en l’occurrence il s’agit de la librairie Keypad.

Après avoir entré ce programme, on peut le compiler, puis l’envoyer sur le arduino.

Si tout c’est bien passé, vous devriez voir s’afficher dans le moniteur série les caractères que vous tapez sur les claviers. Voila une bonne première étape.

reste à brancher l’écran. On voit ça lors de notre prochain épisode.

Cet article Les premières briques d’un ordinateur Arduino est apparu en premier sur Geek et Shift.

L’idée de l’Europe, reprise par chaque pays, est d’obtenir le consentement des clients, avant de collecter leurs données.

Comme les cookies sont le meilleur moyen pour tracer un internaute, les lois obliges les annonceurs à ajouter des popups, pour demander l’avis du client avant de le tracker.

L’idée semble raisonnable : les sites ont abusés de l’usage des cookies, pour gagner de l’argent grâce à la publicité. Les autorités n’ont rien contre la publicité, mais souhaitent que l’internaute soit au courant avant qu’on le piste de site en site.

Il faut le dire : la solution choisie est nulle !

A force de coller des popups posant des questions qui n’intéressent pas les internautes, on a habitués ceux ci (c’est à dire : nous) à cliquer sans réfléchir. On prend ça comme un mal nécessaire, sans intérêt.

Résultat : 

• Personne ne lit ou n’essaye de comprendre les questions qui sont posées
• Les internautes cherchent juste à fermer ce popup, intrusif et perçu comme inutile

Alors, qu’aurait-il fallu faire ?

Je pense que la solution aurait du se faire au niveau du navigateur ou encore mieux au niveau de l’OS. 

Cela aurait eu plusieurs avantages :

• Regrouper les choix des internautes, au lieu de demander site par site, navigateur par navigateur ;
• Harmoniser la façon dont on pose les questions, au lieu de laisser chaque boite créer ses propres questions, en générale géré par le service juridique (d’ou une grande lisibilité ) ;
• Garder les préférences dans la durée, au lieu de stocker ça dans des cookies, qui sautent dans le temps.

Je ne sais pas combien de temps on va se traîner ces boulets : les lois à venir ne vont pas arranger les choses…

Cet article L’erreur fatale des lois sur les Cookies est apparu en premier sur Geek et Shift.

J’ai trouvé ça super intéressant, ça m’a remis des choses en tête sur le fonctionnement d’un processeur, et j’ai appris beaucoup de nouvelles choses, comme, par exemple, les notions assez intime (pour un processeur) de micro instructions.

Je me suis demandé quelle suite donner à cette aventure. 

Ben lui a poursuivi, en construisant un ordinateur, à partir d’un processeur 6800.

Je suis parti sur autre chose :

Et si je construisais un ordinateur, à partir d’un Arduino ?

Déjà, c’est quoi un Arduino : 

Pour faire très simple, un Arduino, c’est un circuit électronique, contenant un contrôleur et des entrées sorties.

C’est un ordinateur donc ?

Non, car il n’y a pas de système d’exploitation, pas d’interface (clavier, souris)…

On envoie un programme dans le contrôleur depuis son ordinateur, puis le contrôleur exécute en boucle le programme qu’on a envoyé. 

Donc, mon idée est de partir d’un Arduino, d’ajouter un clavier et un écran, et d’en faire un ordinateur.

Comme clavier, j’ai pris deux matrices 4×4

Une matrice permettra d’entrer les valeurs à saisir, sous forme hexadécimal (de 0 à 15 donc, ou au format hexa : de 0 à F)

L’autre matrice permettra de piloter l’ordinateur : lancer le programme, passer en mode édition, pour modifier le programme, …

Un écran permettra d’afficher ce qu’on veut, j’ai pris cet écran, de 4 x 20 caractères : 

Comme Arduino, j’ai pris un Arduino Mega, pour avoir un peu plus d’espace mémoire. 

Voici le résultat (proto #1) en état de marche : 

L’ordinateur fonctionne, et permet de faire tout ce qu’on fait habituellement avec un ordinateur : 

• Faire des calculs
• Demander ou afficher des informations à l’écran

Le langage de programmation est un assembleur « maison ».

L’utilisation est assez simple : 

• L’ordinateur est soit en mode édition, soit en mode exécution.
• En mode édition, on peut afficher et éditer le programme.
• En mode exécution, on peut exécuter le programme, normalement ou en mode pas-à pas.

J’ai trouvé cette expérience là encore très enrichissante. Cela faisait un moment que je me demandais quoi faire d’un Arduino, et là j’ai trouvé un terrain de jeu assez riche :).

Je vais vous proposer, dans les semaines à venir, de décomposer cette aventure. Je ferais ça sur mon temps libre, donc il faudra être patient

Le programme que j’ai créé sera mis en open source, donc vous pourrez l’utiliser.

au fait, tout cela ne coute vraiment pas cher : le circuit Arduino m’a couté 15 €, les claviers 16 €, et l’écran 13 €, soit un total de 44 € !

A suivre donc !

Cet article Faire un ordinateur avec un arduino ? est apparu en premier sur Geek et Shift.

Faut il attendre les nouveaux mac ARM, et prendre le risque d’avoir pas mal de logiciels plus lents, car pas encore portés sur ces processeurs, ou peut on acheter un Mac Intel, en sachant que les nouveaux logiciels seront bientôt développés en priorité sur ARM ?

J’ai écouté ce matin OnRefaitLeMac sur le sujet. Ce qui m’a marqué, c’est l’enthousiasme de Jean Louis Gassé pour ces nouvelles machines : il pense que la migration va être bien plus rapide que les deux ans annoncés, et attend un retour rapide à des produits innovants, en tout cas plus fin, plus puissants, avec une meilleure autonomie.

Contrairement à ce que disent plusieurs « influenceurs », pour ma part, je pense que si vous pouvez attendre, il vaut mieux attendre… Après si vous n’avez pas le choix, un mac Intel aura probablement quelques années de vie… Mais avec un risque de valeur de revente plus faible.

Cet article Apple ARM : attendre les Mac ARM ou acheter un Intel ? est apparu en premier sur Geek et Shift.