Tutoriel 201 - Bienvenue chez Vous • AranaCorp

Étiquettes : Programmation

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 :

Le bouton (entrée discrète) est maintenu appuyé
Un délai de sécurité stocké en mémoire (EEPROM/ROM) s’est écoulé
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

simplified-embedded-system-block-diagram Tutoriel 201 - Bienvenue chez Vous

	CPU
INPUTS	MEMORY	file.bin	OUTPUTS
Discrete (btn) Analog (sensor)	CPU		Discrete state PWM output
	Computer C gcc
RTC			INTERFACES
computer			Serial (socket)
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

	SERVER LOGIC
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
Server time Session expiration			Web browser REST API

Électronique : alimentation, capteurs, actionneurs

	MCU
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
Hardware timer RTC module			UART / I2C / SPI

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

	WORKFLOW
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
Drying time Assembly steps			Tools Jigs

Artisanat : comprendre l’ensemble avant le détail

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

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

Tutoriel 201 – Bienvenue chez Vous