Tutoriel 201 – Bienvenue chez Vous

Le tutoriel Welcome Home (Bienvenue Chez Vous) est la suite logique d’un tutoriel Hello World qui permet de vérifier que l’environnement fonctionne correctement et qui permet de faire vivre des notions fondamentales du système étudié.

Un tutoriel après Hello World

Après Hello World, vos Premiers Pas vous mènent forcément à Bienvenue chez vous.

Le traditionnel Hello World permet de vérifier que l’environnement de développement (compilateur, éditeur, installation Python, etc.) fonctionne correctement. Ils existent également un grand nombre de tutoriels Premiers Pas pour étudier un sujet particulier.

Le traditionnel Hello World permet de vérifier que l’environnement de développement fonctionne correctement : compilateur installé, interpréteur Python opérationnel, éditeur configuré, dépendances présentes.
Il valide l’outil, mais il n’enseigne pas encore le système.

À l’autre extrémité, il existe une multitude de tutoriels Premiers Pas qui abordent une fonctionnalité précise : une API, un framework, un composant matériel, une bibliothèque.

Le tutoriel Welcome Home est un tutoriel conceptuel et concret, conçu pour faire vivre ensemble plusieurs notions fondamentales dans un projet unique, cohérent et évolutif. Il ne cherche pas à être exhaustif, mais à donner une vision systémique.

Il s’adresse en priorité à la programmation système, mais le concept est volontairement plus large.

Spécification du tutoriel

La spécification d’un tutoriel Hello World est de vérifier le fonctionnement de la cible ou de l’environnement de travail

La spécification d’un tutoriel Premiers Pas sont d’approfondir un sujet et de l’implémenter en vue de sa compréhension.

Le tutoriel Bienvenue Chez Vous a pour spécification de faire fonctionner un projet complet:

• Appliquer les principales fonctionnalités du système
• Avoir un environnement propre et maintenable (style, architecture, format, etc.)
• Entrevoir certaines limites du système
• comprendre les interactions entre les briques

Scenario

Le scénario choisi représente un mini-système embarqué avec entrées, sorties, mémoire, horloge, et interface de communication. On cherche à développer un système activable par une interface, par exemple, via :

• une interface USB
• un capteur
• une interface graphique
• une commande réseau (socket)

Le système peut être activé uniquement si deux conditions sont réunies :

1. Le bouton (entrée discrète) est maintenu appuyé
2. Un délai de sécurité stocké en mémoire (EEPROM/ROM) s’est écoulé
3. Une commande externe (cmd on) est envoyée sur l’interface choisie

Le système simule :

• une LED (ou état logique) pouvant clignoter
• une PWM (vitesse, puissance, couleur, etc.)
• un RTC (horloge) permettant d’afficher ou synchroniser la date
• une EEPROM (mémoire persistante) pour sauvegarder les réglages

INPUTS	MEMORY	file.bin	OUTPUTS
Discrete (btn) Analog (sensor)	CPU		Discrete state PWM output
	Computer C gcc
RTC			INTERFACES
computer			Serial (socket)

Ce projet illustre ainsi les fondamentaux des systèmes embarqués :

Concept	Application dans le projet
Variables	état interne du système
Pointeurs (C)	accès aux valeurs, buffers, registres
Chaînes de caractères	protocole de communication
Fonctions	modules, périphériques, drivers
Types & tailles	uint16, float, conversion analogique
GPIO (entrée)	bouton, capteur analogique
GPIO (sortie)	LED / PWM
Bus de communication	UART / Socket
EEPROM	données persistantes
RTC	gestion du temps réel

HelloWorld code C

Test si l’environnement est correct

Dans la bonne arborescence de fichier, créer un fichier helloworld.c à compiler et à lancer pour tester l’environnement d’installation

/**
 * @file helloworld.c
 * @brief Simple Hello World program in C
 * 
 * @compilation:
 *      Win32: gcc helloworld.c -o helloworld.exe ; ./helloworld.exe
 *      Linux/Mac: gcc helloworld.c -o helloworld ; ./helloworld
 */
#include <stdio.h>

// ==================== MAIN ====================
int main() {
    printf("Hello, World!\n");
    return 0;
}

First Steps code C

1-Tâche principale

Test si le système est vivant

Créer ensuite une boucle infini, tâche principale ou tâche de fond, permettant d’incrémenter un compteur et de changer l’état d’une sortie discrète

NB: permet de voir si le système crash, initialise une variable (limite encodage variable), test sortie système vivant

/**
 * @file basic_prgm.c
 * @brief Emulate a basic program (Ctrl+C to stop)
 * 
 * @compilation:
 *      Win32: gcc basic_prgm.c -o basic_prgm.exe ; ./basic_prgm.exe 
 *             ./run.bat basic_prgm.c  
 *      Linux: gcc basic_prgm.c -o basic_prgm ; ./basic_prgm
 *                 ./run.sh basic_prgm.c 
 */
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

// ==================== GLOBAL ====================
bool state = false;

// ==================== MAIN ====================
int main() {
    //----------------- Initialization -----------------
    char name[] = "PRGM";
    printf("[%s] Initialized\n",name);
    
    //----------------- Main loop -----------------
    uint16_t counter = 0;
    while (1) {
        // Simulate MCU tasks
        if (counter % 10 == 0) {
            state = !state;
            printf("[%s] Main loop running... Counter=%d : %d\n", name, counter, state);
        }
        counter++;
    }
    printf("[%s] Exited\n",name);
    return 0;
}

Notions abordée

• mise en place d’un cycle d’exécution avec une période fixe (temps réel)
• overflow des types de variable (counter)
• timer et variable de temps (epoch)

2- Interface de communication

Créer une interface de base pour le debug, le traitement et l’échange de données

envoi de donnée : permet de comprendre le formatage, l’émission et la réception de paquet de byte

• envoyer / recevoir des données
• formater des messages textuels
• bus de communication

Options:

• GUI
• Socket
• UART
• BT
• SHM
• file
• MQTT

3- Entrée

• discrète : bouton ON/OFF
• analogique : tension simulée (0..12V → 0..1023)
• numérique : valeurs binaires, capteurs

4-Sorties

• discrète : LED ON/OFF simulée
• analogique : PWM (fréquence, puissance)
• numérique : signaux logiques

3-EEPROM

acquérir les notions de registre mémoire, opération binaire, conversion de type et adresse

• adresse mémoire
• conversion de données en entier
• opération binaire
• LSB et MSB

Options:

• mémoire physique (EEPROM)
• fichier (bin, csv, text, json)
• base de données

4-RTC

acquérir les notions de temps réel

Notion abordé

• scheduling des tâches
• timers
• manipulation de variable de temps (epoch)
• synchronisation

WelcomeHome code C

Une fois ces bases maitrisées, il est possible de les assembler pour concevoir un projet concret, évolutif et maintenable

• C_WelcomeHome

Applications

• Arduino
• PIC / Microchip
• ESP32 / ESP8266
• Raspberry Pi
• Programmation système en C
• Programmation système Python
• Interfaces GUI (GTK, Qt, Tkinter…)

Au-delà de la programmation

Le concept WelcomeHome peut s’appliquer à d’autres domaines :

• Web : serveur, base de données, API, interface

INPUTS	MEMORY	Database / Cookies	OUTPUTS
User actions (click, form) HTTP requests (GET/POST)	SERVER LOGIC		Web page API response
	Server Python / PHP / JavaScript HTML / CSS
RTC			INTERFACES
Server time Session expiration			Web browser REST API

• Électronique : alimentation, capteurs, actionneurs

INPUTS	MEMORY	EEPROM / Flash	OUTPUTS
Sensors (analog) Buttons (digital)	MCU		LEDs Motors / Relays
	Microcontroller Power supply Clock
RTC			INTERFACES
Hardware timer RTC module			UART / I2C / SPI

• Menuiserie / bois : matière, outils, assemblage, finitions

INPUTS	MEMORY	Plans / Measurements	OUTPUTS
Raw wood Dimensions	WORKFLOW		Assembled object Finished piece
	Workshop Hand tools Machines
TIME			INTERFACES
Drying time Assembly steps			Tools Jigs

• Artisanat : comprendre l’ensemble avant le détail

INPUTS	MEMORY	Experience / Knowledge	OUTPUTS
Materials Constraints	PROCESS		Finished object Skill acquisition
	Craftsman Techniques Tools
TIME			INTERFACES
Learning curve Iterations			Tools Environment

Avant d’apprendre un outil, il faut comprendre le système dans lequel il vit.