Programmez vos microcontrôleurs en MicroPython

Magazine
Marque
Hackable
Numéro
47
Mois de parution
mars 2023
Spécialité(s)


Résumé

L’époque est mûre pour permettre aux motivés de bidouiller des objets connectés pour améliorer leurs conditions de vie ou simplement par jeu. Nous présentons dans cet article comment MicroPython peut faciliter le développement d’applications embarquées (ou au moins rassurer le débutant pour les premières expériences).


Body

L’Internet des Objets est plein de belles promesses. Les boutiques présentent de nombreux objets fournissant (ou pas) de merveilleux services pour les consommateurs. Le coût de ces objets est relativement élevé. Les protocoles de communication sont souvent opaques, non documentés et peu sécurisés.

La tentation est alors grande de bricoler de petits machins dans son garage. Pour cela, il faut utiliser des objets faciles d’accès, au moins pour la mise au point finale. Certains microcontrôleurs peuvent se programmer en utilisant un interpréteur MicroPython. Le site internet [1] liste les cartes supportées par l’interpréteur.

Dans le contexte de l’Éducation nationale, le langage Python, avec des variantes graphiques comme Scratch, est le langage recommandé. La société STMicroelectronics, ou ST, participe au projet STM32 pour l’éducation. L’objectif de ce projet est de fournir aux enseignants du lycée et aux lycéens des tutoriels open source pour la conception de supports pédagogiques et pour l’initiation à l’Internet des Objets pour l’enseignement [2].

Nous utilisons cela pour nos enseignements de BUT Réseaux et Télécommunications. Les étudiants peuvent facilement manipuler des objets lointains. Dans le cadre du projet Africonnect, nous avons ainsi fait une démonstration à Dakar pilotée depuis Marseille. Cela nous permet aussi d'interagir facilement entre les départements distants de l’IUT (projet Pinède).

La programmation d’applications sur les cartes STM32 peut se faire en utilisant des environnements de développement intégrés (IDE) comme STM32CubeIDE ou Arduino. L’IDE Arduino est beaucoup plus simple à prendre en main. Arduino propose aussi une version en ligne de commande Arduino-cli [3]. Toutes ces solutions utilisent le compilateur GCC qui peut aussi être appelé directement.

Dans cet article, nous proposons de montrer comment utiliser un interpréteur presque compatible avec Python, nommé MicroPython. Après avoir présenté la carte que nous allons utiliser, nous montrons comment installer l’interpréteur. Ensuite, nous présentons la carte environnementale qui nous permettra d’obtenir la température et l’humidité. Enfin, nous montrerons comment diffuser ces données en utilisant le Bluetooth à faible énergie (BLE).

1. Présentation d’un WB55

ST propose des cartes d’évaluation pour ses produits. Il y a en particulier la série des Nucleo qui disposent de connecteurs variés, dont le standard Arduino. Cela permet donc d’utiliser les shields conçus pour l’Arduino UNO.

La figure 1 présente la face supérieure de la carte. Elle dispose de trois boutons utilisateur, d’un bouton reset et de trois diodes accessibles à la programmation. Elle dispose d’une interface radio fournissant une connectivité Bluetooth à faible énergie. Nous utiliserons dans cet article l’ensemble de broches JP1 qui permet de sélectionner la source d’énergie.

P figure 01-s

Fig. 1 : Le Nucleo WB55.

La face inférieure, présentée à la figure 2, montre le logement pour une pile ronde CR2032. Le processeur est spécialisé faible consommation. La mise en sommeil du processeur permet d’augmenter la durée de vie de la pile. Il y a deux connecteurs USB qui permettent d’interagir soit avec le composant de debug ST-LINK, soit avec l’interpréteur.

P figure 02-s

Fig. 2 : L’arrière du Nucleo WB55 avec le logement pour la pile.

2. Installer MicroPython sur le microcontrôleur

L’installation sur un microcontrôleur est plus ou moins facile. Il faut commencer par obtenir le firmware contenant l’interpréteur. Pour cela, soit l’image est disponible, soit il faut la générer. Nous allons donc commencer par générer une image adaptée à notre microcontrôleur.

Il faut que l’administrateur installe les paquets utiles sur notre station de développement (une Debian) :

# apt install git gcc-arm-none-eabi

Puis télécharger les sources MicroPython :

$ git clone https://github.com/micropython/micropython

Nous commençons par compiler le cross-compilateur :

$ cd micropython/
$ git submodule update --init
$ make -C mpy-cross

Pour le support STM32, nous allons nous déplacer dans le répertoire STM32. Le site [2] présente la compilation et l’installation sur la carte Nucleo WB55 :

$ cd ports/stm32
$ make BOARD=NUCLEO_WB55
...
LINK build-NUCLEO_WB55/firmware.elf
   text    data     bss     dec     hex filename
394268     336   42904 437508   6ad04 build-NUCLEO_WB55/firmware.elf
GEN build-NUCLEO_WB55/firmware.bin
GEN build-NUCLEO_WB55/firmware.dfu
GEN build-NUCLEO_WB55/firmware.hex
$

Le fichier qui nous intéresse est le firmware.bin. Il fait (aujourd’hui) 380 Ko. L’interpréteur va donc utiliser un tiers de la place disponible sur le WB55 (1 Mo de flash).

Il faut copier le firmware sur le périphérique mass storage (une clef USB). Donc, à moins de n’être pas très concerné par sa propre sécurité et disposer des automontages conviviaux pour faire un glisser-déposer, il faut commencer par monter le périphérique, copier le fichier, démonter le périphérique.

$ pmount sdb wb55
$ cp build-NUCLEO_WB55/firmware.bin /media/wb55 ; sync
$ pumount wb55

Sur ce matériel, il faut alors changer l’alimentation. La carte dispose de deux ports USB. L’un est étiqueté ST-LINK, l’autre USB USER. Après l’achat du WB55, pour l’utilisation de l’IDE Arduino, c’était ce port qui fournissait l’énergie à la carte. Le ST-LINK est un composant qui fournit une interface de contrôle sur le microcontrôleur principal. Il faut maintenant utiliser le port utilisateur (USB USER) pour alimenter la carte et communiquer avec l’interpréteur MicroPython. Le sélecteur JP1 détermine la source de l’alimentation. Pour flasher l’interpréteur sur la carte, il faut utiliser le port USB ST-LINK et le positionner sur USB STL (alimentation par le ST-LINK, figure 3).

P figure 03-s 0

Fig. 3 : Le WB55 alimenté par le port ST-LINK (source Y. Marietti).

Il faudra ensuite placer le sélecteur sur USB MCU et brancher le port USB USER (figure 4).

P figure 04-s 0

Fig. 4: Le WB55 alimenté par le port USB USER (source Y. Marietti).

Le périphérique USB change son identification selon la position :

  • sur le port ST-LINK, nous voyons avec un lsusb :
ID 0483:374b STMicroelectronics ST-LINK/V2.1
  • sur le port USB USER, après installation de MicroPython :
ID f055:9800 MicroPython Pyboard Virtual Comm Port in FS Mode

Notre Nucleo est maintenant équipée d’un interpréteur Python. Pour interagir avec lui, il faut utiliser un logiciel terminal. Sous GNU/Linux, il en existe plusieurs, comme minicom, screen, etc. Nous allons utiliser minicom. Il faut commencer par identifier le port série qui relie notre ordinateur et la carte Nucleo. Pour cela, soit nous essayons les noms classiques, comme /dev/ttyACM0 ou /dev/ttyUSB0, soit nous listons les ports disponibles sur l’ordinateur.

Pour lister les ports série sur un ordinateur, nous pouvons (après avoir installé les librairies Python nécessaires) lancer la commande suivante :

$ python3 -m serial.tools.list_ports
/dev/ttyACM0        
/dev/ttyS0          
2 ports found

Sur cet ordinateur, nous avons un port série physique (ttyS0) et le port ttyACM0 qui identifie un modem. Certes, ce n’est pas un modem. Si le système d’exploitation est trop intelligent, il va vouloir programmer ce modem et générer un conflit avec notre logiciel terminal. Le blog [4] explique la différence entre les périphériques identifiés par un ttyACM et ceux qui sont ttyUSB.

Sur cette carte, le port USB permet de fournir une interface série et un UMS (USB Mass Storage). La figure 5 présente les données de cet espace. Il commence par un espace libre (sic) de 128 Ko, suivi d’un système de fichiers de 256 Ko. Le microcontrôleur dispose d’une flash d’un mégaoctet. La documentation de MicroPython indique qu’il est possible d’ajouter des modules Python gelés dans le firmware. Un module gelé est du code source ou bytecode placé dans le firmware.

P figure 05

Fig. 5 : L’interface de stockage de masse.

Le système de fichiers est reconstruit au lancement s’il n’existe pas. Tant que les octets n’ont pas été écrasés, les anciens fichiers redeviennent disponibles.

Nous allons pouvoir nous connecter avec minicom (minicom -D /dev/ttyACM0). L’interpréteur affiche un message d’identification et il est possible de lancer des commandes Python :

>>> MicroPython v1.19.1-543-gab317a0d6 on 2022-10-12; NUCLEO-WB55 with STM32WB56
Type "help()" for more information.                                             
>>> import os                                                                  
>>> os.listdir()                                                                
['boot.py', 'main.py', 'pybcdc.inf', 'README.txt']                              

Nous voyons ici comment accéder aux fichiers depuis l’interpréteur. Ces fichiers sont disponibles aussi en mémoire de masse et en montant le système de fichiers. Pour les microcontrôleurs ne permettant pas l’activation de ce support, il est possible d’utiliser pyboard (répertoire tools) qui fournit une interface de communication.

Le système de fichiers initial contient les fichiers suivants :

  • boot.py : premier fichier exécuté par l’interpréteur, définition du pays et des méthodes d’interaction entre le microcontrôleur et l’ordinateur. Il lance ensuite le fichier main.py ;
  • main.py : presque vide initialement, pour ajouter le code utilisateur ;
  • pybcdc.inf : un fichier Windows ;
  • README.txt : contient des instructions de lancement.

Pour jouer avec notre interpréteur, nous pouvons changer l’état des LED :

>>> 2+2
4
>>> from pyb import LED
>>> led=LED(1)
>>> led.toggle()
>>> led.toggle()
>>> led=LED(2)
>>> led.toggle()

La carte est maintenant prête à l’utilisation avec des capteurs.

3. Utiliser quelques capteurs

Dans les sources de MicroPython, il y a le code permettant d’utiliser quelques capteurs. Nous allons utiliser une carte fille qui contient des capteurs environnementaux, cela nous permettra de réaliser des mesures physiques réelles que nous transmettrons bientôt en Bluetooth.

La carte que nous utilisons, c’est la carte X-Nucleo IKS01A3 de ST (figure 6). Elle contient plusieurs capteurs de mouvement et environnementaux (accélération, gyroscope, magnétomètre, température, humidité, pression).

P figure 06-s 0

Fig. 6 : La carte environnementale et localisation IKS01A3.

Les sources de MicroPython disposent d’un fichier de driver permettant de manipuler l’un des capteurs sur la carte IKS : le HTS221 (température et humidité). Le fichier est nommé hts221.py et il contient, après la déclaration de la licence, un exemple de code permettant d’afficher sur la sortie série les données. Dans cet exemple, les broches I2C sont spécifiées et ne correspondent pas à notre installation. Nous modifions le fichier main.py ainsi :

import time
import hts221
from machine import Pin, I2C
 
print (" AF chez lamlis info : Hackable Env demo")
 
# Initialisation du bus I2C
bus = I2C(1)
 
# Certains recommandent d'attendre un peu avant d'utiliser l'I2C
time.sleep_ms(1000)
 
hts = hts221.HTS221(bus)
 
while (True):
    rH   = hts.humidity()
    temp = hts.temperature()
    print ("rH: %.2f%% T: %.2fC" %(rH, temp))
    time.sleep_ms(10000)

Il faut donc installer les deux fichiers sur le microcontrôleur, puis interrompre le programme précédent (CTRL-C), puis effectuer une légère réinitialisation (soft reset : CTRL-D).

(CTRL-C)
KeyboardInterrupt:
MicroPython NUCLEO-WB55 withType "help()" for more information.
>>>   (CTRL-D)
MPY: sync filesystems
MPY: soft reboot
AF: Hackable Env demo
rH: 67.74% T: 26.61C
rH: 67.61% T: 26.63C
rH: 67.93% T: 26.72C

Nous commençons à avoir une installation qui fonctionne, mais nous voulons pouvoir interagir à distance.

4. Bluetooth faible énergie

Le Bluetooth à faible énergie (BLE) est un protocole voisin du Bluetooth mais incompatible, néanmoins de nombreux équipements, dont les téléphones et les Raspberry, disposent d’une puce permettant d’utiliser les deux protocoles.

L’utilisation du BLE se fait principalement selon deux modes : connecté ou annonce.

Le mode connecté permet d’interagir entre deux équipements selon un protocole défini par le développeur de l’application. La communication est alors exclusive. Nous n’allons pas utiliser ce mode.

Le mode annonce est celui que nous allons utiliser. Le microcontrôleur va annoncer périodiquement un message permettant de l’identifier et de récupérer les données environnementales.

Il faut commencer par prendre le fichier ble_advertising.py dans les exemples fournis avec les sources MicroPython et l’installer sur le système de fichiers. Puis nous modifions le fichier main.py :

# ===================================================================== #
# Envoi des données environnementales en BLE
# (source: micropython examples, yannick Marietti)
# Auteur: Arnaud Février
# ===================================================================== #
# Matériel : une carte Nucleo WB55 et un shield X-Nucleo IKS01A3
from machine import I2C
import HTS221, pyb, time, bluetooth
from ble_advertising import advertising_payload
 
print ("AF: Hackable Env BLE demo")
# ===================================================================== #
mon_nom = "wb01"
# Voir org.bluetooth.characteristic.gap.appearance.xml
_ADV_APPEARANCE_GENERIC_ENVSENSOR = const(5696)
# ===================================================================== #
# Classe pour gérer l'advertising de données environnementales
class BLE_Adv_Env:
    # Initialisations
    def __init__(self, ble):
        self._ble = ble
        self._ble.active(True)
        self._connections = set()
        self._handler = None
        
        # Envoi des trames d'advertising
    def advertise(self, interval_us=500000, message = None):
        self._payload = advertising_payload( name=message,
                                             services=None,
                                             appearance=_ADV_APPEARANCE_GENERIC_ENVSENSOR)
        self._ble.gap_advertise(interval_us, adv_data=self._payload, connectable = False)
# ===================================================================== #
# Initialisation
ble = bluetooth.BLE()
wbdev = BLE_Adv_Env(ble)
 
i2c = I2C(1)
time.sleep_ms(1000)
sensor1 = HTS221.HTS221(i2c)
# ===================================================================== #
#
# Boucle principale
#
# ===================================================================== #
while True:
    t = round(sensor1.temperature(),2)
    h = round(sensor1.humidity())
    print("Temperature:", t, "Humidite:",h)
    # Publication en BLE de la température et de l'humidité
    wbdev.advertise(message = mon_nom + "|" + str(t) + "|" + str(h))
    time.sleep_ms(1000)

Nous commençons par importer tous les modules nécessaires, dont le support BLE et le chipset HTS221. Ensuite, nous définissons une classe pour gérer la diffusion des données environnementales. Cette classe peut être considérée comme magique dans un premier temps et réutilisée directement. Ensuite, nous faisons les initialisations (Bluetooth, I2C et HTS221). Nous arrivons à la boucle principale qui récupère les données du capteur et construit une chaîne de caractères qui sera diffusée régulièrement. Le terminal affiche les informations de debug :

MicroPython v1.18-155-g414b59d39 on 2022-02-24; NUCLEO-WB55 with STM32WB55RGV6
Type "help()" for more information.
>>>
>>>
MPY: sync filesystems
MPY: soft reboot
AF: Hackable Env BLE demo
Temperature: 28.04 Humidite: 65
Temperature: 27.98 Humidite: 65
Temperature: 28.02 Humidite: 65

Un scan BLE (par l’utilisateur root) depuis un ordinateur à proximité détecte notre chaîne de caractères qui contient l’identifiant wb01 et les valeurs de température et d’humidité.

# hcitool lescan
LE Scan ...
10:2B:41:96:67:CE (unknown)
02:02:27:4E:1B:0A wb01|27.98|65
02:02:27:4E:1B:0A (unknown)

Sur mon /e/phone, les données s’affichent aussi lors d’un scan Bluetooth. Le résultat est présenté dans la figure 7.

P figure 07-s

Fig. 7 : Affichage des données sur le téléphone.

Tous les appareils peuvent obtenir l’information en scannant les annonces BLE. Pour pouvoir traiter les données, il faut disposer d’un programme dédié.

5. Demandez à votre autre serpent les données

Quelques lignes de Python permettent de récupérer les données, pour par exemple les transmettre à un serveur MQTT ou les enregistrer directement dans une base de données, ou les afficher sur un joli écran. Le script Python minimal est le suivant :

#! /usr/bin/env python3
 
from bluepy import btle
from bluepy.btle import Scanner, DefaultDelegate
import time, binascii, datetime, sys
 
#####################################################################
class ScanDelegate(DefaultDelegate):
    def __init__(self):
        DefaultDelegate.__init__(self)
 
    def handleDiscovery(self, dev, isNewDev, isNewData):
        if isNewData:
            # print ("Nouvelles donnees de ", dev.addr)
            for (adtype, desc, value) in dev.getScanData():
                # print( " %s = %s" % (desc, value))
                if( desc == "Complete Local Name"):
                    objet, temp, humi = value.split("|")
                    print("Message de " + objet + " :")
                    print(" - Température : " + temp + "°C")
                    print(" - Humidité : " + humi + "%")
                    today = datetime.datetime.today()
                    tempspresent=today.strftime("%y-%m-%d %H:%M:%S")
 
    def handleNotification(cHandle, data):
        print ("Not: ",data)
 
#####################################################################
# main
 
scanner = Scanner().withDelegate(ScanDelegate())
devices = scanner.scan(55.0)

L’exécution fournit le résultat suivant :

# /usr/local/bin/blewb55.py
Message de wb01 :
- Température : 27.31°C
- Humidité : 66%

Le code dépend du module bluepy qui n’est pas disponible dans la Debian stable (Bullseye). Il faut donc l’installer avec pip3 install bluepy. Après l’initialisation des modules, nous ajoutons une classe ScanDelegate qui sera appelée quand le scan recevra une annonce. L’instruction print, en commentaire, affichera un message pour chaque annonce. Mais seuls les messages dont le nom correspond au motif seront détaillés. Le nom doit être composé de trois parties séparées par des caractères |. Nous demandons à scanner.scan de scanner pendant 55 secondes. Ce script peut être appelé toutes les minutes par un cron classique. Certaines annonces pourraient alors ne pas être reçues.

Un scan Bluetooth affiché par Wireshark est présenté à la figure 8. Le nom diffusé par la sonde contient bien la chaîne de caractères définie. L’adresse Bluetooth est une adresse locale, choisie par MicroPython. Il est possible de définir celle-ci lors de l’initialisation avec l’instruction BLE.config.

P figure 08-s

Fig. 8 : Affichage de l’annonce par Wireshark.

Tout appareil peut afficher les valeurs. La figure 7 montre la console série du microcontrôleur et le téléphone qui scanne les appareils Bluetooth à proximité. Mais pour aller plus loin, il faudrait développer une application spécifique.

6. Le bêtisier

Le développeur expérimentera souvent quelques déboires. Voici quelques pistes pour les éviter ou les résoudre.

L’interpréteur permet d’utiliser les fichiers sans les recompiler. La tentation est alors grande de modifier ceux-ci directement sur la carte. Les éditeurs créent souvent discrètement des fichiers (verrou pour éviter la manipulation simultanée par deux éditeurs ; version précédente). Ces fichiers vont être écrits sur le système de fichiers de la carte, ce qui pose parfois des problèmes.

L’écriture d’un fichier sur la carte prend un temps non négligeable. Le système d’exploitation de la station de travail va écrire les fichiers dans une partie de la mémoire pour rendre la main au programme d’écriture le plus rapidement possible. Au bout d’un certain temps, les fichiers seront synchronisés sur la carte. Pour forcer l’écriture et être sûr que les données écrites sont les données définitives, il faut alors soit démonter le périphérique, soit utiliser la commande sync qui terminera quand toutes les écritures en attente seront réalisées. Si, avant les écritures physiques, la carte subit un reset, est éteinte ou débranchée, alors le système de fichiers sera incohérent. Parfois, seule une intervention physique sur la carte (comme reflasher un nouveau firmware) pourra résoudre le problème. Dans le cas d’interactions lointaines, ce sera difficile.

Grâce à mes étudiants, j’ai constaté que cela arrivait. Pour récupérer le système de fichier, un fsck -y est un bon début. Après, le fsck a retrouvé des bouts de fichiers qu’il faut effacer.

Une erreur de programmation ou un bug du driver peut aussi bloquer la carte, dans ce cas l’utilisation d’un watchdog à titre de précaution pourra réinitialiser la carte.

Comme mentionné précédemment, le système d’exploitation peut interpréter la carte comme un modem et essayer de le configurer.

Conclusion

Nous avons montré comment installer l’interpréteur sur une carte. La documentation montre les adaptations à faire pour une autre plate-forme. Certes, la manipulation n’est pas si simple pour un débutant, mais en se rapprochant d’un fablab, il peut demander un firmware qui contient toutes les librairies dont il peut avoir besoin (ici, le driver hts221 et le support BLE). Il lui restera à finaliser son projet en modifiant uniquement le main.py.

Cet article ne présente pas un produit fini. Il permet aux amateurs motivés de mettre en place des applications. Nous n’avons pas l’intention de commercialiser ces produits. Il y a quelques contraintes à résoudre avant de déployer un produit. La première est le respect de la licence d’utilisation des cartes Nucleo qui interdit d’utiliser ces cartes pour un produit fini. D’autre part, nous n’avons pas vérifié le respect de la norme BLE, en particulier pour les adresses.

Références

[1] Site de la documentation de MicroPython : https://docs.micropython.org

[2] Le site de STM32 pour l’éducation : https://stm32python.gitlab.io/fr/docs/Micropython/install_linux

[3] D. Bodor, « Développer pour Arduino en ligne de commandes (pour de vrai) », 2023,
https://connect-ed-diamond-com/hackable/hk-046/developper-pour-arduino-en-ligne-de-commandes-pour-de-vrai

[4] S. Tardieu, « Blog sur la différence entre les périphériques ttyACM et ttyUSB », 2013,
https://rfc1149.net/blog/2013/03/05/what-is-the-difference-between-devttyusbx-and-devttyacmx/



Article rédigé par

Par le(s) même(s) auteur(s)

KeePassXC : utilisez la mémoire artificielle pour sécuriser vos mots de passe

Magazine
Marque
Linux Pratique
Numéro
142
Mois de parution
mars 2024
Spécialité(s)
Résumé

Les mots de passe, quelle galère ! Il en faut de plus en plus, sécurisés, difficiles à retenir, changés facilement, etc. L’utilisation de clefs asymétriques est une bonne alternative, mais les hébergeurs ne semblent pas prêts à les utiliser et préfèrent les mots de passe. Les logiciels KeePass* permettent de faciliter leur utilisation au quotidien.

Remettez de l'ordre dans votre WiFi avec un peu de programmation

Magazine
Marque
Linux Pratique
Numéro
134
Mois de parution
novembre 2022
Spécialité(s)
Résumé

Le WiFi, c’est pratique ! Enfin… quand il fonctionne bien. Parfois, cela ne marche plus, il suffit de cliquer sur le clickodrome jusqu’au retour de la connexion du bonheur. Mais parfois le système intelligent, il ne veut pas faire ce que nous, nous voudrions. Nous allons voir comment, avec les commandes systèmes et la programmation, l’aider un peu à accepter à être moins intelligent que nous et réaliser nos souhaits.

Les derniers articles Premiums

Les derniers articles Premium

PostgreSQL au centre de votre SI avec PostgREST

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

Dans un système d’information, il devient de plus en plus important d’avoir la possibilité d’échanger des données entre applications. Ce passage au stade de l’interopérabilité est généralement confié à des services web autorisant la mise en œuvre d’un couplage faible entre composants. C’est justement ce que permet de faire PostgREST pour les bases de données PostgreSQL.

La place de l’Intelligence Artificielle dans les entreprises

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

L’intelligence artificielle est en train de redéfinir le paysage professionnel. De l’automatisation des tâches répétitives à la cybersécurité, en passant par l’analyse des données, l’IA s’immisce dans tous les aspects de l’entreprise moderne. Toutefois, cette révolution technologique soulève des questions éthiques et sociétales, notamment sur l’avenir des emplois. Cet article se penche sur l’évolution de l’IA, ses applications variées, et les enjeux qu’elle engendre dans le monde du travail.

Petit guide d’outils open source pour le télétravail

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

Ah le Covid ! Si en cette période de nombreux cas resurgissent, ce n’est rien comparé aux vagues que nous avons connues en 2020 et 2021. Ce fléau a contraint une large partie de la population à faire ce que tout le monde connaît sous le nom de télétravail. Nous avons dû changer nos habitudes et avons dû apprendre à utiliser de nombreux outils collaboratifs, de visioconférence, etc., dont tout le monde n’était pas habitué. Dans cet article, nous passons en revue quelques outils open source utiles pour le travail à la maison. En effet, pour les adeptes du costume en haut et du pyjama en bas, la communauté open source s’est démenée pour proposer des alternatives aux outils propriétaires et payants.

Sécurisez vos applications web : comment Symfony vous protège des menaces courantes

Magazine
Marque
Contenu Premium
Spécialité(s)
Résumé

Les frameworks tels que Symfony ont bouleversé le développement web en apportant une structure solide et des outils performants. Malgré ces qualités, nous pouvons découvrir d’innombrables vulnérabilités. Cet article met le doigt sur les failles de sécurité les plus fréquentes qui affectent même les environnements les plus robustes. De l’injection de requêtes à distance à l’exécution de scripts malveillants, découvrez comment ces failles peuvent mettre en péril vos applications et, surtout, comment vous en prémunir.

Les listes de lecture

9 article(s) - ajoutée le 01/07/2020
Vous désirez apprendre le langage Python, mais ne savez pas trop par où commencer ? Cette liste de lecture vous permettra de faire vos premiers pas en découvrant l'écosystème de Python et en écrivant de petits scripts.
11 article(s) - ajoutée le 01/07/2020
La base de tout programme effectuant une tâche un tant soit peu complexe est un algorithme, une méthode permettant de manipuler des données pour obtenir un résultat attendu. Dans cette liste, vous pourrez découvrir quelques spécimens d'algorithmes.
10 article(s) - ajoutée le 01/07/2020
À quoi bon se targuer de posséder des pétaoctets de données si l'on est incapable d'analyser ces dernières ? Cette liste vous aidera à "faire parler" vos données.
Voir les 98 listes de lecture

Abonnez-vous maintenant

et profitez de tous les contenus en illimité

Je découvre les offres

Déjà abonné ? Connectez-vous