Jekert

Hey,

On voit souvent sur les forums la question Arduino ou Raspberry, mais on croise plus rarement celle de microcontrôleur ou FPGA qui prend aussi un peu d'importance avec l'arrivée de FPGA abordables.

D'un côté, on a les microcontrôleurs que l'on a l'habitude de voir, on les programme facilement et ils exécutent le code qu'on leur donne ligne après ligne.

D'un autre coté, il y a les FPGA (Field Programmable Gate Array), ce sont des puces capables de reconfigurer leur logique interne en fonction de vos besoins. Il est possible de concevoir un schéma logique sur le logiciel et il sera automatiquement recréé dans la puce. La complexité du schéma peut aller d'une simple porte NAND à un microcontrôleur complet voir même un microprocesseur. Leurs avantages sont de pouvoir effectuer de nombreuses tâches en simultané lorsque l'on utilise une logique combinatoire (schéma à base de portes logiques uniquement) ou d'utiliser une architecture pipe-line pour faire plusieurs tâches en parallèle. Ils sont aussi utilisés pour tester les microprocesseurs avant de faire la première série de production.

Cela fait 3 ans que j'utilise des FPGAs lors de TP à la fac et je me suis souvent demandé si il existait une puce (SystemOnChip) qui comporterait à la fois un ASIC et un FPGA pour avoir le meilleur des 2 mondes. Et récemment, j'ai pu tester une carte SMF2000 (SmartFusion2) ainsi qu'une carte de développement à base de SmartFusion1. Pour le moment, je trouve encore leur utilisation plus complexe que si je disposai de 2 cartes séparées, malgré la HAL (Hardware Abstraction Layer, une couche entre la programmation haut niveau en C et le matériel). Celle-ci est plutôt bien documentée grâce à des programmes d'exemples pour les fonctions les plus utilisées ainsi qu'une description détaillée de chaque fonction de leurs bibliothèques.

Pour programmer la carte on commence par créer la partie FPGA sur le logiciel Libero SoC de MicroSemi qui contient aussi l'interface avec le Cortex-M3, il est possible de faire des simulations avec ModelSim avant de programmer la carte. Puis on génère les firmwares pour le programme C et on bascule sur un autre logiciel, SoftConsole, pour la compilation du code et le debug. C'est la première fois que j'utilise une fonction de debug et je dois avouer que c'est plutôt pratique, il permet de lancer le programme ligne après ligne et observer les différents états du microprocesseur.

Exemple:

J'ai fait un petit test simple à l'aide du bouton poussoir et d'une led sur la carte, le but de diviser l'horloge (programme fait en VHDL) pour qu'elle dispose d'un cycle d'une seconde puis de faire passer ce signal dans une porte logique ET pour compter le nombre de secondes pendant lequel le bouton est appuyé. Sur le microcontrôleur il y a une interruption qui détecte le changement d'état, incrémente le compteur et affiche la valeur sur le port Série. La partie logique ressemble à ceci :

 libero_QD3qwAWrrJ.png   270,94 Ko   106 téléchargement(s)

B est le bouton, s la led, et Y est la connexion entre le FPGA et le microcontrôleur.

Prix :

On m'a aussi parlé d'une carte intéressante nommée QuickFeather qui comprend elle aussi un FPGA et un Cortex-M3 mais qui possède une toolchain entièrement opensource.

Niveau prix, le SMF2000 et la QuickFeather sont toutes les deux proposées à un peu plus de 40€.

Pour le moment je n'ai pas encore de projet précis avec cette carte (je ne m'attendais pas à en avoir une prochainement), mais je trouvais ces cartes intéressantes pour tenter d'obtenir des systèmes Low Power sans avoir à atteindre entièrement le SoC. J'aimerais aussi tester une FFT ou au moins un FIR sur le FPGA et utiliser le Cortex-M3 pour communiquer avec le PC.

Est-ce que vous avez déjà utiliser des cartes similaires ? Et si oui, sur quel type de projets ?

• https://opencores.org/projects

• http://freerangefactory.org/cores.html

Hey !
Ça fait maintenant 2 ans que je n'ai pas fabriqué de robots en dehors des projets pour la fac et des Hacking Health mais la semaine dernière en utilisant ce petit delta lors d'un TP je me suis lancé dans une aventure express pour fabriquer le mien.

 1612097894195.jpg   58,1 Ko   101 téléchargement(s)

Je ne me souviens plus de la marque mais il est prévu pour l'industrie horlogère, il y a une pompe pour attraper les pièces et une caméra pour détecter leur emplacement.

Mes objectifs sont :

• Utiliser le matériel que je possède déjà
• Être le moins encombrant possible
• Tester avec une cinématique inverse existante
• Puis tenter de faire la mienne
• Pas de vision pour le moment

Ce robot est la moitié d'un projet qui consiste à apprendre à utiliser les méthodes de cinématique directe et inverse. La seconde moitié sera surement un mini bras à base de SG90.
J'ai donc décidé d'utiliser le matériel suivant :

• 3 moteurs pas à pas 28BYJ-48 avec leurs drivers ULN2003
• 3 Endstops
• 1 Arduino Nano
• 1 Electroaimant
• 1 transistor NPN 2N2222
• 12 billes aimantées
• 1m de tourillon bois 6mm
• 1m de tourillon bois10mm
• PLA blanc
• Beaucoup de vis et écrous M2, M2.5, M4

En faisant des recherches sur des deltas à base de 28BYJ-48, je suis tombé sur ce projet : https://tinkersproje...er-delta-robot/
Il m'a conforté dans l'idée d'utiliser ces moteurs et la bibliothèque ( https://github.com/t...ematics-Library ) qu'il a créé pour sa cinématique est super simple à utiliser. Mais j'ai repris le design de zéro pour avoir tout les composants électroniques sur la partie haute et éviter d'imprimer entièrement les bras. Et voici le résultat :

 1612097703390.png   968,49 Ko   105 téléchargement(s)

C'est aussi le premier projet où je tente d'assembler les pièces sur Fusion 360 :

 Delta v8.png   148,6 Ko   98 téléchargement(s)

Actuellement, j'ai fini la séquence d'initialisation et je commence à jouer avec la bibliothèque de cinématique inverse.

Il est plutôt lent pour un delta mais la vitesse n'est clairement pas l'objectif de ce projet   Le programme de cet essai est disponible ici, ainsi que l'implémentation de la bibliothèque ici. 

Problèmes rencontrés :

• Le bras reliant le robot aux pieds en bois était trop flexible (le nouveau est à gauche)

 1612097703409.jpg   62,7 Ko   100 téléchargement(s)

• Remplacer les vis M4 par les écrous sur l'effecteur permet de caler la bille magnétique

 1612097703399.jpg   70,34 Ko   106 téléchargement(s)

• Les pins des moteurs doivent être déclarés dans cet ordre pour pouvoir tourner dans les 2 sens : IN1-IN3-IN2-IN4
• C'est vraiment pas facile de le mettre à niveau en vissant les tiges de bois, peut-être que je fermerais l'ouverture supérieure pour empêcher la tige de sortir une fois que je saurais quelle hauteur il me faut

Ressources :
L'idée des liaisons mécaniques à base d'aimants vient de ce projet d'imprimante : https://www.thingive...ng:210028/files
Vous pourrez trouver la bibliothèque de cinématique inverse pour Delta ici : https://github.com/t...ematics-Library

Bonjour à tous,
 
Je vais vous présenter aujourd'hui le DHT22, un capteur de température et d'hygrométrie répandu très utile pour construire une petite station météo.

La datasheet fournie par Adafruit est disponible ici et en pièce jointe. Celle-ci indique que les capacités suivantes pour le capteur :

 opera_2019-05-17_17-31-08.png   151,76 Ko   155 téléchargement(s)

Quelques liens utiles :

• Documentation (Datasheet):  DHT22_Datasheet.pdf   406,57 Ko   503 téléchargement(s)
• Le composant Fritzing est disponible ici
• Modélisation 3D du composant : https://grabcad.com/...ensor-arduino-1
• Ce composant est entre autres contenu dans cette bibliothèque KiCad

J'avais déjà écrit rapidement une page (pour un ouvrage qui n'a pas encore été publié) sur l'utilisation de ce capteur, donc j'ai ressayé mes programmes avec ce montage (la résistance de pull-up est de 10k ohms):

 Fritzing_2019-05-17_17-14-48.png   73,19 Ko   168 téléchargement(s)
 

Ce programme permet d'afficher les valeurs de température et le pourcentage d'humidité dans l'air sur l'interface Série d'Arduino IDE :

//Bibliothèque :
#include "DHT.h"

//Déclaration du DHT22:
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  //Initialisation de la liaison Série :
  Serial.begin(9600);
  Serial.println("Test du DHT22");

  //Initialisation du capteur :
  dht.begin();
}

void loop() {
  //Lecture des données :
  float h = dht.readHumidity(); //Lis le taux d'humidité
  float t = dht.readTemperature(); //Lis la température en Celsius

  //Affichage des valeurs :
  Serial.print("Humidite: ");
  Serial.print(h);
  Serial.print("% | Temperature: ");
  Serial.print(t);
  Serial.println(" degres celsius");

  //Temporisation :
  delay(2000);
}

 javaw_2019-05-17_17-11-10.png   42,19 Ko   167 téléchargement(s)
 

Puis j'ai modifié un peu ce programme pour utiliser la fonction de Traceur Série d'Arduino pour afficher de belles courbes :
 

//Bibliothèque :
#include "DHT.h"

//Déclaration du DHT22:
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  //Initialisation de la liaison Série :
  Serial.begin(9600);
  //Serial.println("Test du DHT22");

  //Initialisation du capteur :
  dht.begin();
}

void loop() {
  //Lecture des données :
  float h = dht.readHumidity(); //Lis le taux d'humidité
  float t = dht.readTemperature(); //Lis la température en Celsius

  //Affichage des valeurs :
  Serial.print(h);
  Serial.print(" ");
  Serial.println(t);

  //Temporisation :
  delay(2000);
}

La température est représentée en rouge et l'humidité en bleu. On peut voir un pic quand je m'approche du capteur et un retour à la normal ensuite (il est très sensible aux mouvements d'air):

 javaw_2019-05-17_16-45-32.png   56,48 Ko   182 téléchargement(s)

Et enfin, j'ai fait un petit test avec un écran LCD 1602 contrôlé en I2C :

La résistance de pullup est toujours une 10k ohms.

//Bibliothèques :
#include "DHT.h"
#include "Wire.h"
#include "LiquidCrystal_I2C.h"

//Ecran LCD :
LiquidCrystal_I2C lcd(0x3F, 2, 1 , 0, 4, 5, 6, 7, 3, POSITIVE); //Seul le premier paramètre, l'adresse I2C de l'écran, est à modifier

//Déclaration du DHT22:
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

//Création du symbole symbole degrès :
byte degres[8] = { B00111, 
                    B00101, 
                    B00111, 
                    B00000, 
                    B00000, 
                    B00000, 
                    B00000, 
                    B00000 };
uint8_t deg = 0;

void setup() {
  //Initialisation du capteur :
  dht.begin();

  //Initialisation de l'écran :
  lcd.begin(16,2);
  lcd.backlight();

  //Ajout du caractère :
  lcd.createChar(deg, degres);
}

void loop() {
  //Lecture des données :
  float h = dht.readHumidity(); //Lis le taux d'humidité
  float t = dht.readTemperature(); //Lis la température en Celsius

  //Affichage des valeurs :
  lcd.clear();
  lcd.home();
  lcd.print("Humidite: ");
  lcd.print(h);
  lcd.print("%");
  lcd.setCursor(0,1);
  lcd.print("Temp :");
  lcd.print(t);
  lcd.write(deg);
  lcd.print("C");

  //Temporisation :
  delay(2000);
}

Salut,

Ça faisait un moment ^^

Mes exams viennent de se terminer et je me suis dit que ce projet commencé il y a 3 ans (en 2016) serait super pour me remettre dans le bain

(Je crois que c'est Jan qui avait fait cette image pour l'ouvrage que j'avais commencé)

Bon, voici le but : 

Proposer un projet en plusieurs niveaux de difficultés progressifs pour apprendre au fur et à mesure des itérations.

Voici comment on avait organisé l'ouvrage :

Chapitre 0: La station météo :

1. V.1 : Station météo LCD
2. V.2 : Station météo Bluetooth
3. V.3 : Stockage sur carte SD
4. V.4 : Mise en wifi (ESP8266)

L'objectif était de pouvoir réaliser ce projet en parallèle de  la lecture de Débuter avec Arduino (chaque version correspondant à un avancement dans l'apprentissage) et de faire de ce projet le premier cas de mise en pratique des connaissances acquises.

Le matériel utilisé pour la première version est disponible dans la boutique :

• Arduino UNO ou NANO
• Capteur de température et d'hygrométrie DHT22
•  Une horloge temps réel (RTC) 
• Des photorésistantes (LDR)
• Des potentiomètres multi-tours
• Un écran LCD 1602 avec un module I2C

A cela on ajoutera (on mettra pas tout en place simultanément) :

• Un module Bluetooth HC05
• Un lecteur de carte SD
• Un module wifi ESP8266

En complément, j'aimerais ajouter ces éléments là sur une dernière version utilisant pourquoi pas une NodeMCU  (et affichant les résultats à distance) :

• Un capteur de pluie
• Un capteur d'humidité dans le sol
• Un capteur de pression GY-BMP280

J'avais déjà fait la première version en 2016 mais je ne pense pas avoir assez détaillé le processus, donc je vais tout reprendre depuis le début en publiant des tests unitaires ici et dans les catégories spécifiques aux composants puis on établira les objectifs et pré-requis de chaque version avant de les faire pas à pas

A bientôt pour les différents tests

Salut,

Hackaday organise 5 challenges (dont open hardware et robotics module) avec des prix à la clé, si ça vous intéresse : https://hackaday.io/prize#home