
ZArduino
zmaker/arduino_cookbook
gli sketch del nuovo progetto Arduino Cookbook e dei video di YouTube

📌 Le schéma suivant illustre ce montage :
Boite noire is an open-source printed circuit board by hibaelgoumri, from the hibaelgoumri/pcb repository on GitHub. It is a 2-layer board of 50.5 × 41.5 mm with 17 parts on 32 nets, routed with 97 tracks and 2 vias.
It is built around the ATMEGA328P-PU. Its parts include 5 capacitors, 2 ICs, 2 connectors, 1 resistor and 1 switch. It belongs with the AVR (ATmega, ATtiny) boards of this library.
Dans les systèmes embarqués modernes, la collecte et l’analyse de données en temps réel sont essentielles pour le suivi et la sécurité des équipements, notamment dans des domaines critiques comme l’automobile, l’aviation ou le ferroviaire. S’inspirant du fonctionnement des boîtes noires utilisées dans ces industries, ce projet a pour objectif de concevoir un système embarqué capable d’enregistrer et de transmettre en temps réel des données de mouvement (vitesse et orientation) à l’aide d’un capteur inertiel. Les informations sont ensuite visualisées sur une station de contrôle via un écran LCD. Ce projet s’inscrit dans le cadre du Tekbot Robotics Challenge et fait appel à plusieurs compétences majeures : programmation directe des microcontrôleurs ATmega328P sans utiliser de carte Arduino, communication via le protocole I2C, conception de circuits imprimés avec KiCAD, réalisation d’un boîtier cubique de 7 cm, intégration matérielle sur veroboard ou PCB, ainsi que la conception d’une alimentation spécifique.
Ce système embarqué est composé de deux unités : une boîte noire et une station de contrôle, connectées via le bus I2C. La boîte noire comprend un capteur MPU6050 qui détecte les mouvements de la main et envoie les données à un microcontrôleur ATmega328P configuré en maître. Celui-ci traite les données et les transmet à la station de contrôle, où un autre ATmega328P, configuré en esclave, les reçoit. Les informations sont ensuite affichées sur un écran LCD. Chaque unité est alimentée séparément par une source de 5V.
Ce bloc a pour objectif de fournir une tension continue et stable de 5V nécessaire au fonctionnement des différents composants électroniques du système, notamment le capteur MPU6050, les microcontrôleurs ATmega328P et l'écran LCD.
On utilise trois batteries de Li-Ion 3,7V rechargeables montées en série pour obtenir environ 12V.
Le régulateur L7805 reçoit ce 12V en entrée (Vin) et fournit du 5V en sortie (Vout).
Deux condensateurs (330nF et 100nF) sont utilisés pour stabiliser la tension et filtrer les parasites.
📌 Le schéma suivant illustre ce montage :
La simulation sur proteus Les condensateurs de filtrage ont été omis dans ce schéma pour simplifier la représentation, bien qu’ils soient indispensables en pratique pour assurer la stabilité et réduire le bruit.
Nous avons choisi le capteur MPU6050 parce qu’il intègre un accéléromètre et un gyroscope dans un seul composant. Cela permet de mesurer les mouvements et les rotations de la main avec précision. Il est facile à utiliser grâce au protocole I2C, et il fonctionne bien avec le microcontrôleur ATmega328P. En plus, il est peu coûteux et largement utilisé dans les projets embarqués. D’autres capteurs peuvent faire un travail similaire, comme le MPU9250 (qui ajoute un magnétomètre), le LSM6DS3 (plus récent et plus économe), ou le ADXL34
Avant de démarrer le système complet, l’équipe s’est d’abord focalisée sur le microcontrôleur ATmega328P. L’objectif était de comprendre pleinement sa structure interne, ses broches, ainsi que la manière de le configurer et de le simuler.
Nous avons étudié ses principales caractéristiques et son brochage :
Ces éléments nous ont permis de préparer une simulation fiable sous Proteus pour la suite du projet.
Après avoir étudié la configuration du microcontrôleur, nous avons réalisé une première simulation simple sous Proteus, afin de valider son fonctionnement dans un environnement simulé.
À ce stade :
Nous avons conçu un système simple dans lequel :
Le code Arduino correspondant a été compilé dans l’IDE Arduino, puis le fichier .hex généré a été intégré dans Proteus pour tester le comportement du circuit.
https://github.com/user-attachments/assets/d1cc5dd5-9109-4822-be6e-245693643c00
Pour l’affichage des données au niveau de la station de contrôle, nous avons opté pour un écran LCD équipé d’un module I2C. Ce choix permet de simplifier le montage électronique en réduisant considérablement le nombre de connexions nécessaires entre le microcontrôleur et l’écran. Grâce à cette interface, seules deux lignes (SDA et SCL) suffisent pour transmettre les informations, ce qui laisse davantage de broches disponibles pour d’autres composants. L’écran LCD I2C assure ainsi une lecture claire et en temps réel des données de vitesse et d’orientation envoyées par la boîte noire.
Ce document constitue une présentation détaillée et approfondie du protocole I2C (Inter-Integrated Circuit), qui est un standard de communication série synchrone très répandu dans l’électronique embarquée. Ce protocole facilite l’échange d’informations entre un ou plusieurs maîtres et plusieurs périphériques esclaves en utilisant seulement deux fils, simplifiant ainsi les connexions matérielles tout en assurant une communication fiable et efficace.
Protocole I2C (Inter-Integrated Circuit), développé par Philips (aujourd’hui NXP) dans les années 1980, est un standard mondial pour la communication série entre circuits intégrés, surtout dans les systèmes embarqués. Il utilise un bus bidirectionnel à deux fils : SDA pour les données et SCL pour l’horloge, permettant à plusieurs périphériques de partager le même canal tout en gérant précisément l’accès.
Contrairement à des protocoles comme SPI, I2C minimise le nombre de connexions nécessaires, ce qui simplifie le routage sur circuit imprimé et réduit les coûts. Ce protocole est largement utilisé dans des domaines variés : automobile, domotique, informatique, etc.
I2C fonctionne selon un modèle.maître-esclave: un ou plusieurs maîtres contrôlent la communication, et les esclaves répondent aux requêtes. Chaque communication commence par une condition Start, suivie de l’adresse de l’esclave et d’un bit de direction (lecture/écriture). Les données sont ensuite échangées octet par octet, chaque octet étant confirmé par un bit d’acquittement(ACK). La communication se termine par une condition Stop, qui libère le bus.
Techniquement, I2C utilise des lignes ouvertes (open-drain) : les dispositifs ne peuvent que tirer les lignes vers le bas, tandis que des résistances pull-up maintiennent le niveau haut par défaut. Cela évite les conflits, notamment en mode multi-maîtres.
Enfin, I2C offre une grande flexibilité en termes de vitesse, du mode standard (100 kHz) au mode rapide (jusqu’à 3,4 MHz) et au-delà dans certaines variantes propriétaires.
La prise de contrôle du bus par un maître débute par une condition Start (S), qui est un événement distinctif sur le bus. Cette condition correspond à une transition sur la ligne SDA de l’état haut à l’état bas, alors que la ligne SCL est maintenue à l’état haut. Cette séquence particulière est détectée par tous les périphériques connectés au bus, qui entrent alors en mode écoute, prêts à recevoir des données.
La condition Start joue un rôle fondamental : elle marque l’exclusivité du maître sur le bus, ce qui évite les collisions ou l’interférence avec d’autres maîtres éventuels. Elle sert aussi de synchronisation initiale à la transmission de données, en assurant que tous les appareils sont synchronisés sur le début de la communication.
Les résistances pull-up sur les lignes SDA et SCL maintiennent ces lignes à un état logique haut par défaut, garantissant ainsi que le bus est en repos quand aucune communication n’a lieu.
La transmission des données sur le bus I2C s’effectue par octets (8 bits). Chaque bit est transmis séquentiellement, en commençant par le bit le plus significatif (MSB).
Le protocole impose que chaque bit soit placé sur la ligne SDA pendant que la ligne SCL est à l’état bas. Ensuite, la ligne SCL passe à l’état haut, moment où le récepteur lit la valeur présente sur la ligne SDA. Lorsque la ligne SCL redescend à l’état bas, l’émetteur peut placer le bit suivant sur SDA, et ainsi de suite.
Après l’envoi des 8 bits d’un octet, la ligne SDA est libérée pendant le 9e cycle d’horloge. C’est alors au récepteur de signaler par un bit d’acquittement (ACK) s’il a correctement reçu l’octet, en tirant la ligne SDA à l’état bas. S’il ne tire pas SDA à zéro, un bit de non-acquittement (NACK) est détecté, ce qui indique que la communication doit être interrompue ou qu’une erreur s’est produite.
Ce mécanisme d’ACK/NACK est crucial car il assure la fiabilité des transmissions, permettant au maître de savoir si l’esclave est disponible et prêt à recevoir ou envoyer des données.
Après la condition Start, le maître envoie un octet d’adresse pour identifier l’esclave avec lequel il souhaite communiquer. L’adresse est généralement codée sur 7 bits, suivis d’un bit R/W indiquant si la transaction sera une lecture ou une écriture.
Le protocole prévoit aussi une extension 10 bits pour les réseaux comportant un grand nombre de périphériques, mais cette extension est moins fréquemment utilisée.
Tous les périphériques esclaves surveillent le bus et comparent l’adresse reçue avec leur propre adresse. Celui qui reconnaît son adresse répond alors par un bit ACK en tirant la ligne SDA à l’état bas pendant le 9e bit. Les autres esclaves restent silencieux jusqu’à la prochaine séquence.
Cette étape est essentielle car elle garantit que seules les communications destinées à un périphérique spécifique sont traitées, évitant ainsi toute interférence entre plusieurs périphériques sur le même bus.
Une fois l’adresse reconnue par l’esclave, la phase de transfert des données peut commencer. Le maître transmet alors les octets de données à l’esclave, chaque octet étant suivi d’un bit ACK envoyé par l’esclave pour confirmer la bonne réception.
Le protocole permet d’envoyer autant d’octets que nécessaire dans une même communication, ce qui permet des transferts efficaces et continus.
Pour terminer la communication, le maître génère une condition Stop (P), qui correspond à une transition de la ligne SDA de l’état bas à l’état haut alors que la ligne SCL est haute. Cette séquence indique à tous les périphériques que la transmission est terminée et que le bus est libéré pour une autre communication.
Il existe également une condition Restart, qui est une condition Start générée sans condition Stop préalable, permettant de chaîner plusieurs opérations sur le même bus sans interruption.
Le protocole I2C est conçu pour supporter un mode multi-maîtres, où plusieurs maîtres peuvent tenter d’accéder au bus simultanément. Pour éviter les conflits, un mécanisme d’arbitrage est mis en place.
Lorsqu’un maître commence à transmettre, il surveille la ligne SDA et la compare avec ce qu’il souhaite envoyer. Si un maître détecte que la ligne SDA est forcée à l’état bas par un autre maître alors qu’il tente de la maintenir haute, il comprend qu’il a perdu l’arbitrage et abandonne immédiatement la transmission, laissant le bus libre au maître dominant.
Ce mécanisme garantit qu’aucune collision électrique ne se produit sur le bus et que seule une source transmet à un instant donné. C’est une des forces du protocole I2C, qui permet une coexistence harmonieuse de plusieurs maîtres sur un même bus.
Le clock stretching est une fonctionnalité du protocole I2C qui permet à un esclave de ralentir temporairement la communication lorsqu’il n’est pas prêt à envoyer ou recevoir des données. Cela se fait en gardant la ligne SCL à l’état bas (LOW), empêchant ainsi le maître de continuer à envoyer des impulsions d’horloge. Une fois que l’esclave est prêt, il libère la ligne SCL, permettant au maître de reprendre la transmission. Cette technique est utile, par exemple, lorsque le capteur a besoin de plus de temps pour traiter ou préparer les données. Le maître doit respecter cet étirement d’horloge pour éviter des erreurs de communication.
Dans notre projet, le microcontrôleur ATmega328P communique avec le capteur MPU6050 à l’aide du protocole I2C. Ce protocole permet de transmettre les données d’accélération et de rotation via deux fils (SDA et SCL). Le MPU6050 agit comme esclave, et l’ATmega328P comme maître.
La connexion matérielle entre le MPU6050 et l’ATmega328P s’effectue via le protocole I2C (Inter-Integrated Circuit), qui utilise deux lignes de communication :
Sur le bus I2C, le dispositif qui initie la communication est appelé maître, tandis que celui qui répond s’appelle esclave. Dans notre cas :
L’ATmega328P joue le rôle de maître, c’est lui qui contrôle le bus, génère l’horloge, et initie les échanges.
Le MPU6050 est l’esclave, il attend que le maître lui demande des données spécifiques.
Le maître démarre la communication en envoyant une adresse unique correspondant à l’esclave (ici l’adresse I2C du MPU6050, généralement 0x68), suivie d’une commande indiquant quel registre ou donnée il souhaite lire.
| ATmega328P | MPU6050 |
|---|---|
| PC4 (SDA) | SDA |
| PC5 (SCL) | SCL |
| VCC | 5V |
| GND | GND |
| 🔧 Pull-up | Recommandé : 4.7kΩ sur SDA et SCL |
La communication suit ce processus :
Avant de réaliser directement le PCB de la boîte noire et de la station de contrôle, nous avons choisi de suivre une démarche progressive. L’objectif était de bien maîtriser la communication I2C et le fonctionnement du microcontrôleur ATmega328P.
Tester les fonctionnalités sur breadboard avec des composants simples (comme un bouton, une LED, un MPU6050 ou un LCD) permet plus de flexibilité et facilite le débogage. Contrairement au PCB, où les composants sont soudés, la breadboard permet des modifications rapides.
Cette approche nous a permis de valider chaque étape avant l'intégration finale sur le PCB, en réduisant les risques d’erreurs matérielles ou logicielles.
Valider le fonctionnement de la communication I2C entre deux microcontrôleurs en utilisant un exemple simple : un bouton poussoir et une LED.
(
https://github.com/user-attachments/assets/f24d194f-d3f9-40da-8c5a-b3b9a5e75ebc
Simuler une application plus réaliste en utilisant des capteurs réels(MPU6050) et un afficheur(lCD), tout en gardant la communication I2C entre deux cartes.
https://github.com/user-attachments/assets/1c67d0e5-90eb-4aa1-bebf-cd58e934528a
Remplacer la carte Arduino par le microcontrôleur brut (ATmega328P), afin de simuler les conditions réelles d’un circuit imprimé.
l'image de montage
la video
La réalisation d’un PCB nécessite des choix précis de composants et un bon fonctionnement garanti en amont. Cette démarche par étapes nous a permis de :
Pour la phase de routage de mon circuit imprimé, j’ai utilisé un routage automatique à l’aide de l’application FreeRouting. Ce choix m’a permis de gagner du temps, d’obtenir un routage optimisé, et de réduire les erreurs humaines dans le placement des pistes.
FreeRouting est un outil open source externe à KiCad, capable d’analyser les connexions (netlist) et de générer un routage respectant les règles de design (DRC). Il offre plusieurs avantages :
• 🔹 Optimisation automatique des longueurs et des croisements de pistes
• 🔹 Respect des règles de clearance et de largeur de pistes
• 🔹 Visualisation rapide des pistes critiques et des contraintes
• 🔹 Gain de temps par rapport au routage manuel complet
Le routage généré a ensuite été importé dans KiCad pour la vérification finale et l’inspection des règles électriques (DRC).
https://github.com/user-attachments/assets/f897ede6-44c2-42a2-96d0-31dc648d50c1
https://github.com/user-attachments/assets/c5784cd8-9c96-4c7d-97fa-074df501b6cc
| Qty | Value | Footprint | References |
|---|---|---|---|
| 4 | MountingHole | MountingHole:MountingHole_2.1mm | H1, H2, H3, H4 |
| 2 | 22pF | Capacitor_THT:C_Disc_D3.0mm_W1.6mm_P2.50mm | C4, C5 |
| 1 | 0.1uF | Capacitor_THT:C_Disc_D3.0mm_W1.6mm_P2.50mm | C1 |
| 1 | 100nF | Capacitor_THT:C_Disc_D3.0mm_W1.6mm_P2.50mm | C2 |
| 1 | 1k | Resistor_THT:R_Axial_DIN0204_L3.6mm_D1.6mm_P5.08mm_Horizontal | R2 |
| 1 | 330nF | Capacitor_THT:C_Disc_D3.0mm_W1.6mm_P2.50mm | C3 |
| 1 | ATmega328P-P | Package_DIP:DIP-28_W7.62mm | U1 |
| 1 | Battery | TerminalBlock:TerminalBlock_bornier-2_P5.08mm | BT1 |
| 1 | Conn_01x04 | Connector_PinHeader_1.00mm:PinHeader_1x04_P1.00mm_Vertical | J2 |
| 1 | Conn_01x08 | Connector_PinSocket_1.00mm:PinSocket_1x08_P1.00mm_Vertical | J1 |
| 1 | Crystal | Crystal:Crystal_AT310_D3.0mm_L10.0mm_Horizontal | Y1 |
| 1 | LM7805_TO220 | Package_TO_SOT_THT:TO-220-3_Vertical | U2 |
| 1 | SW_Push | Button_Switch_THT:SW_PUSH_6mm | SW1 |

zmaker/arduino_cookbook
gli sketch del nuovo progetto Arduino Cookbook e dei video di YouTube

coseyfannitutti/discipad
17-key numpad assembled with only through hole components, including usb type-c

matthewcieplak/super-sixteen
Code and schematics for the Super Sixteen Eurorack sequencer

coseyfannitutti/romeo
Staggered 40% keyboard pcb that can be assembled with only through hole components, including USB Type-C

mattybrad/drumkid
Version 4 was the first successful working design, with full code, schematics, Gerbers, etc available on GitHub.


leomil72/LM80C
A Z80-based homebrew computer withTMS9918, AY-3-8910, Z80 CTC, Z80 PIO, and Z80 SIO

It measures 50.5 × 41.5 mm and has 2 copper layers, 1.6 mm thick.
17 parts, built around the ATMEGA328P-PU. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.
From the hibaelgoumri/pcb repository on GitHub, at the commit this page was made from: the board is boite_noire/boite_noire.kicad_pcb and its schematic boite_noire/boite_noire.kicad_sch. PCBKit opens the board in the browser, with nothing to install.
Its repository states no licence, so its author keeps all rights: ask hibaelgoumri before reusing the design.