L’ordinateur monocarte (SBC) Youyeetoo X1 x86 doté d’un processeur Intel Celeron N5105 Jasper Lake diffère d’un mini PC Intel ou AMD typique par sa gamme d’E/S, notamment SPI, I2C, UART, la connectivité NFC et la prise en charge du module PoE que vous avez gagné. On ne le trouve pas dans un ordinateur typique, et c’est ce que nous testerons dans la deuxième partie de l’examen du X1 SBC avec la consommation d’énergie.
Le Youyeetoo X1 SBC est également différent des ordinateurs monocarte basés sur Arm puisque nous pouvons simplement installer n’importe quel système d’exploitation compatible x86 par nous-mêmes, et nous n’avons pas besoin de flasher une image spécifique à la carte comme nous le ferions avec les SBC et les périphériques Arm. tels que SPI, I2C ou UART peuvent être ou non utilisables immédiatement en raison du manque de pilotes pris en charge.
Nous avons déjà installé Ubuntu 22.04 sur le Youyeetoo X1 dans la première partie de la test, donc dans la deuxième partie, nous utiliserons les instructions du wiki pour tester les GPIO et connecter des périphériques au SBC x86.
Configuration du niveau de tension GPIO sur le Youyeetoo X1
Le Youyeetoo X1 est livré avec plusieurs jeux de connecteurs GPIO JST (pas de 2 mm) qui peuvent être utilisés à 2 niveaux de tension : 1,8 V et 3,3 V. La configuration du niveau de tension implique de mettre à jour le BIOS de la carte, par exemple en utilisant le fichier « X1_01_Digital_S8_20231023175931_3.3V.bin » qui peut être décodé comme étant pour la carte X1 avec 8 Go de RAM, un microphone numérique activé et l’écran LCD MIPI 7 par défaut avec Tension GPIO de 3,3 V. Vous pouvez en savoir plus dans la section pour mettre à jour le BIOS dans la première partie de la test.
Utiliser des GPIO avec libgpiod
Nous pouvons utiliser le sous-système d’espace utilisateur GPIO et libgpiod pour contrôler les GPIO sur la carte.
Commençons par installer libgpiod et gpiod :
|
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
unoiot@unoiot-YouYeeToo-X1 :~$ sudo apt -y install libgpiod-dev Lecture des listes de packages… Terminé Construire un arbre de dépendances… Terminé Lecture des informations sur l’état… Terminé libgpiod-dev est déjà la version la plus récente (1.6.3-1build1). 0 mis à niveau, 0 nouvellement installé, 0 à supprimer et 38 non mis à niveau. unoiot@unoiot-YouYeeToo-X1 : ~$ sudo apt -y install gpiod Lecture des listes de packages… Terminé Construire un arbre de dépendances… Terminé Lecture des informations sur l’état… Terminé Les NOUVEAUX packages suivants seront installés : gpiod 0 mis à jour, 1 nouvellement installé, 0 à supprimer et 38 non mis à niveau. Besoin d’obtenir 24,3 Ko d’archives. Après cette opération, 143 Ko d’espace disque supplémentaire seront utilisés. Obtenez : 1 http://th.archive.ubuntu.com/ubuntu jammy/universe amd64 gpiod amd64 1.6.3-1build1 [24.3 kB] Récupéré 24,3 Ko en 0 s (151 Ko/s) Sélection du package gpiod précédemment non sélectionné. (Lecture de la base de données… 226776 fichiers et répertoires actuellement installés.) Préparation du décompression …/gpiod_1.6.3-1build1_amd64.deb … Déballage de gpiod (1.6.3-1build1)… Configuration de gpiod (1.6.3-1build1) … Traitement des déclencheurs pour man-db (2.10.2-1) … |
Tester les GPIO avec des outils de ligne de commande
Nous pouvons maintenant vérifier la puce GPIO avec la commande gpiodetect. chip0 sera détecté :
|
unoiot@unoiot-YouYeeToo-X1 : ~$ sudo gpiodetect gpiochip0 [INT34C8:00] (340 lignes) |
La commande gpioinfo nous permet de vérifier l’état de chaque broche GPIO :
|
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
unoiot@unoiot-YouYeeToo-X1:~$ sudo gpioinfo 0 gpiochip0 – 340 lignes : ligne 0 : sortie active-haute sans nom et inutilisée ligne 1 : sortie active-haute sans nom et inutilisée ligne 2 : sortie active-haute sans nom et inutilisée ligne 3 : sortie active-haute sans nom et inutilisée ligne 4 : sortie active-haute sans nom et inutilisée ligne 5 : entrée active-haute non utilisée et sans nom ligne 6 : sortie active-haute sans nom et inutilisée ligne 7 : entrée active-haute non utilisée et sans nom ligne 8 : entrée active-haute non utilisée et sans nom ligne 9 : entrée active-haute non utilisée et sans nom ligne 10 : entrée active-haute non utilisée et sans nom ligne 11 : entrée active-haute non utilisée et sans nom ligne 12 : entrée active-haute non utilisée et sans nom ligne 13 : entrée active-haute non utilisée et sans nom ligne 14 : entrée active-haute non utilisée et sans nom ligne 15 : entrée active-haute non utilisée et sans nom ligne 16 : entrée active-haute non utilisée et sans nom ligne 17 : entrée active-haute non utilisée et sans nom ligne 18 : entrée active-haute non utilisée et sans nom ligne 19 : entrée active-haute non utilisée et sans nom ligne 20 : entrée active-haute non utilisée et sans nom ligne 21 : entrée active-haute non utilisée et sans nom ligne 22 : entrée active-haute non utilisée et sans nom ligne 23 : entrée active-haute non utilisée et sans nom ligne 24 : entrée active-haute non utilisée et sans nom … |
Les commandes get/set définissent le GPIO en entrée ou en sortie. Si vous utilisez gpioset avec un GPIO spécifique pour changer le drapeau à 0, ledit GPIO sera automatiquement la sortie et si vous utilisez gpioget pour lire l’état du GPIO, il changera automatiquement le mode d’entrée :
|
unoiot@unoiot-YouYeeToo-X1:~$ sudo gpioset 0 160=0 unoiot@unoiot-YouYeeToo-X1:~$ sudo gpioinfo 0 | grep « ligne 160 » ligne 160 : sortie active-haute non utilisée et sans nom |
|
unoiot@unoiot-YouYeeToo-X1:~$ sudo gpioget 0 160 1 unoiot@unoiot-YouYeeToo-X1:~$ sudo gpioinfo 0 | grep « ligne 160 » ligne 160 : entrée active-haute non utilisée et sans nom |
| Code PIN | Description de l’entrée/sortie | Numéro d’E/S de contrôle libgpiod |
|---|---|---|
| 1 | GPIO-H19 | 179 |
| 2 | GPIO-H18 | 178 |
| 3 | GPIO-H17 | 177 |
| 4 | GPIO-H16 | 176 |
| 5 | GPIO-H00 | 160 |
Sous-ensemble de la broche GPIO vers la table des numéros libgpiod
Programmation Python pour contrôler les broches GPIO du Youyeetoo X1
Il est également possible d’utiliser Python pour gérer le GPIO, nous allons donc installer le python3-libgpiod comme suit :
|
sudo apt install python3-libgpiod |
Nous ferons ensuite un test rapide avec le programme suivant pour faire clignoter une LED (ou allumer et éteindre un relais) :
|
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
importer le gpiod, l’heure # épingles RELAIS1 = 160 RELAIS2 = 177 puce=gpiod.Chip(‘gpiochip0’) relay1=chip.get_line(RELAY1) relay1.request(consumer= »Relais1″, type=gpiod.LINE_REQ_DIR_OUT) relay2=chip.get_line(RELAY2) relay2.request(consumer= »Relais2″, type=gpiod.LINE_REQ_DIR_OUT) def run() : retard = 1,0 essayer: tandis que Vrai : relais1.set_value(1) time.sleep (délai) relais1.set_value(0) time.sleep (délai) »’ dupliquer le relais 2 ici »’ enfin: nettoyer() nettoyage par défaut() : relais.release() si __name__ == « __main__ »: courir() |
Tout va bien, comme vous pouvez le voir dans la vidéo ci-dessous.
Vérification d’I2C sur Youyeetoo X1
Vérification du pilote I2C
Installons les outils i2c pour vérifier si des périphériques I2C sont détectés.
|
sudo apt-get installer i2c-tools |
Après cela, nous pouvons exécuter la commande i2cdetect pour localiser les appareils I2C. Mais avant cela, jetons un coup d’œil aux schémas qui nous indiquent que I2C3 est accessible via un connecteur à 4 broches.
Nous avons donc connecté un module I2C au capteur ENS160 eCO2 et au capteur de température et d’humidité AHT21 en utilisant respectivement les adresses I2C 0x38 et x053.
|
unoiot@unoiot-YouYeeToo-X1:~/linux-nfc/linux$ sudo i2cdetect -r -y 4 0 1 2 3 4 5 6 7 8 9 a b c d e f 00 : — — — — — — — — dix: — — — — — — — — — — — — — — — — 20 : — — — — — — — — — — — — — — — — 30: — — — — — — — — 38 — — — — — — — 40 : — — — — — — — — — — — — — — — — 50 : — — — 53 — — — — — — — — — — — — 60 : — — — — — — — — — — — — — — — — 70 : — — — — — — — — |
Encore une fois, cela fonctionne bien avec les deux capteurs détectés sur le bus I2C.
Programme Python pour tester I2C
Nous allons écrire un programme Python simple pour lire les valeurs des appareils I2C avec la bibliothèque smbus2 comme suit :
|
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
importer le gpiod, l’heure # épingles RELAIS1 = 160 RELAIS2 = 177 puce=gpiod.Chip(‘gpiochip0’) relay1=chip.get_line(RELAY1) relay1.request(consumer= »Relais1″, type=gpiod.LINE_REQ_DIR_OUT) relay2=chip.get_line(RELAY2) relay2.request(consumer= »Relais2″, type=gpiod.LINE_REQ_DIR_OUT) def run() : retard = 1,0 essayer: tandis que Vrai : relais1.set_value(1) time.sleep (délai) relais1.set_value(0) time.sleep (délai) »’ dupliquer le relais 2 ici »’ enfin: nettoyer() nettoyage par défaut() : relais.release() si __name__ == « __main__ »: courir() |
Le code ci-dessus lit les données d’humidité relative et de température de l’air du capteur AHT21 et les transmet au terminal.
C’est une autre passe.
Connecteurs UART du Youyeetoo X1
Vérifier si le pilote fonctionne
Nous pouvons utiliser 3 ensembles d’UART : UART1 à UART3, qui sont ttyS0, ttyS4 et ttyS5, comme indiqué dans une fenêtre de terminal avec d’autres interfaces :
|
unoiot@unoiot-YouYeeToo-X1 :~$ sudo ls /dev/ttyS* /dev/ttyS0 /dev/ttyS11 /dev/ttyS14 /dev/ttyS17 /dev/ttyS2 /dev/ttyS22 /dev/ttyS25 /dev/ttyS28 /dev/ttyS30 /dev/ttyS5 /dev/ttyS8 /dev/ttyS1 /dev/ttyS12 /dev/ttyS15 /dev/ttyS18 /dev/ttyS20 /dev/ttyS23 /dev/ttyS26 /dev/ttyS29 /dev/ttyS31 /dev/ttyS6 /dev/ttyS9 /dev/ttyS10 /dev/ttyS13 /dev/ttyS16 /dev/ttyS19 /dev/ttyS21 /dev/ttyS24 /dev/ttyS27 /dev/ttyS3 /dev/ttyS4 /dev/ttyS7 |
Nous allons tester l’interface UART2 disponible via le périphérique /dev/ttyS5 avec le brochage suivant.
| Code PIN | Description | Remarques |
|---|---|---|
| 1 | VCC | Tension de sortie 3,3 V |
| 2 | TXD | Envoi de données niveau TTL |
| 3 | RXD | Recevoir le niveau TTL des données |
| 4 | GND | Masse de référence de puissance |
Test de l’UART avec un module GPS
Nous testerons l’UART en connectant le module GPS Beitian BN-180 basé sur le module u-blox NEO-M8N. En suivant les instructions du fabricant, nous avons ouvert le programme screen et défini le port /dev/ttyS5 sur un débit en bauds de 9 600 bps :
|
écran sudo /dev/ttyS5 9600 |
Nous avons reçu certaines données, mais pour les rendre lisibles par l’homme, nous avons installé le programme GPSD.
|
unoiot@unoiot-YouYeeToo-X1 : ~$ sudo apt-get install gpsd Lecture des listes de packages… Terminé Construire un arbre de dépendances… Terminé Lecture des informations sur l’état… Terminé Les packages supplémentaires suivants seront installés : outils gpsd libgps28 Forfaits suggérés : clients gpsd Les NOUVEAUX packages suivants seront installés : gpsd gpsd-outils libgps28 0 mis à niveau, 3 nouvellement installés, 0 à supprimer et 38 non mis à niveau. |
Nous avons également dû éditer /etc/default/gpsd pour démarrer automatiquement et pointer vers le port UART2 auquel le module GPS est connecté.
|
# Périphériques sur lesquels GPSD doit collecter au moment du démarrage. START_DAEMON= »vrai » # Ils doivent être lisibles/inscriptibles, soit par l’utilisateur gpsd, soit par le groupe de numérotation. APPAREILS= »/dev/ttyS5″ # Autres options que vous souhaitez transmettre à GPSD GPSD_OPTIONS= » » # Ajout/suppression automatique à chaud de périphériques GPS USB via gpsdctl USBAUTO= »vrai » |
Le programme cgps affiche les coordonnées GPS correctes et d’autres informations, comme indiqué dans la capture d’écran ci-dessous.
Tests NFC
La carte Youyeetoo X1 est équipée d’une puce NFC ST25DV04K prête à l’emploi. Il vous suffit d’installer une antenne NFC que Youyeetoo a à vendre. Un connecteur IPEX est utilisé et l’antenne peut y être connectée comme indiqué sur la photo ci-dessous.
Nous pouvons tester le NFC à l’aide d’un exemple de programme fourni par Youyeetoo qui envoie des données (par exemple une URL) après que l’antenne NFC a été exploitée avec un smartphone compatible.
|
unoiot@unoiot-YouYeeToo-X1 : ~$ wget http://d.youyeetoo.cn/X1/Linux-tools/linux-gpio-i2c-spi-nfc/nfc/linux-nfc-en.zip –2023-12-03 10:43:04– http://d.youyeetoo.cn/X1/Linux-tools/linux-gpio-i2c-spi-nfc/nfc/linux-nfc-en.zip Résolution de d.youyeetoo.cn (d.youyeetoo.cn)… 183.60.220.4, 183.60.220.9, 183.60.220.6 Connexion à d.youyeetoo.cn (d.youyeetoo.cn)|183.60.220.4|:80… connecté. Requête HTTP envoyée, en attente de réponse… 200 OK Longueur : 3496000 (3,3 M) [application/zip] Enregistrement dans : ‘linux-nfc-en.zip’ linux-nfc-en.zip 100%[=================================================================>] 3,33 M 1,34 Mo/s en 2,5 s 2023-12-03 10:43:07 (1,34 Mo/s) – ‘linux-nfc-en.zip’ enregistré [3496000/3496000] unoiot@unoiot-YouYeeToo-X1 :~$ décompressez linux-nfc-en.zip |
Après avoir téléchargé et décompressé avec succès le programme. Nous installerons les packages binaires nécessaires à la compilation du programme.
|
unoiot@unoiot-YouYeeToo-X1 :~$ sudo apt -y install libgpiod-dev |
Nous pouvons maintenant exécuter make pour construire le programme :
|
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 16 17 |
unoiot@unoiot-YouYeeToo-X1:~/linux-nfc$ cd linux/ unoiot@unoiot-YouYeeToo-X1:~/linux-nfc/linux$ make gcc -I ./ -O2 -Wall -g -fPIE -c i2c.c -o i2c.o g++ -I ./ -O2 -Wall -g -fPIE -c Gpio_Interrupt.cpp -o Gpio_Interrupt.o g++ -I ./ -O2 -Wall -g -fPIE -c I2cCtrl.cpp -o I2cCtrl.o g++ -I ./ -O2 -Wall -g -fPIE -c NFC_Ndef.cpp -o NFC_Ndef.o g++ -I ./ -O2 -Wall -g -fPIE -c NFC_St25DVXApp.cpp -o NFC_St25DVXApp.o g++ -I ./ -O2 -Wall -g -fPIE -c NFC_St25DVXCtrl.cpp -o NFC_St25DVXCtrl.o NFC_St25DVXCtrl.cpp : Dans la fonction ‘void* pthread_fun_nfc_gpio(void*)’ : NFC_St25DVXCtrl.cpp:24:1 : avertissement : aucune instruction de retour dans la fonction renvoyant un résultat non nul [-Wreturn-type] 24 | } | ^ g++ -I ./ -O2 -Wall -g -fPIE -c test_NFC.cpp -o test_NFC.o g++ -I ./ -O2 -Wall -g -fPIE -c Tools.cpp -o Tools.o gcc -o test_NFC i2c.o Gpio_Interrupt.o I2cCtrl.o NFC_Ndef.o NFC_St25DVXApp.o NFC_St25DVXCtrl.o test_NFC.o Tools.o -lm -lrt -lstdc++ -ldl -lgpiod rm -rf i2c.o rm -rf Gpio_Interrupt.o I2cCtrl.o NFC_Ndef.o NFC_St25DVXApp.o NFC_St25DVXCtrl.o test_NFC.o Tools.o |
La build est réussie, nous pouvons donc démarrer le programme de test NFC :
|
unoiot@unoiot-YouYeeToo-X1:~/linux-nfc/linux$ sudo ./test_NFC NFC_St25DVXCtrl() NFC_St25DVXApp() NFC_St25DVXCtrl :: ConnectDev :/dev/i2c-5,ret=0 pthread_fun_nfc_gpio Entrez dans le fil de discussion — NFC L’appareil a été connecté avec succès : s = IC Réf : 24 UID IC : F6 EC F5 DA 00 24 02 E0 Taille de stockage utilisateur = 512 B Nom du modèle de puce: ST25DV04K-XX Démarrer l’initialisation Briser les drapeaux int_flg=00H Briser les drapeaux int_flg=00H Briser les drapeaux int_flg=00H Briser les drapeaux int_flg=00H |
Nous pouvons maintenant utiliser un smartphone compatible NFC pour exploiter l’antenne NFC et ouvrir une URL telle que le logiciel Raspberryme, comme indiqué dans la vidéo ci-dessous.
.
Interface SPI sur Youyeetoo X1 SBC
Activation du pilote SPI
Par défaut, SPI n’est PAS activé :
|
unoiot@unoiot-YouYeeToo-X1 :~$ ls /dev/spi* ls : impossible d’accéder à ‘/dev/spi*’ : aucun fichier ou répertoire de ce type |
En effet, Ubuntu 22.04 n’est pas livré avec un noyau Linux permettant SPI. Donc, si nous voulons utiliser SPI, nous devons télécharger le code source du noyau, configurer SPI et compiler le noyau ou le module pilote SPI.
Nous devons installer plusieurs dépendances dont le code source Linux pour apporter l’interface utilisateur make menuconfig :
|
sudo apt-get mise à jour sudo apt install -y libncurses-dev flex bison libssl-dev sudo apt-get -y install libelf-dev sudo apt-get install linux-source-6.2.0 cd /usr/src/ tar -xvjf linux-source-6.2.0.tar.bz2 -C ~/ cd ~/linux-source-6.2.0 sudo make oldconfig cp /boot/config-$(uname -r) ./.config sudo make menuconfig |
Une fois là-bas, accédez à la section Pilotes de périphérique, faites défiler jusqu’à ce que vous voyiez SPI, puis appuyez sur la barre d’espace devant le message « Prise en charge du pilote de périphérique SPI en mode utilisateur » jusqu’à ce qu’il indique « * ».
Modification également du fichier .config pour supprimer deux valeurs clés : CONFIG_SYSTEM_TRUSTED_KEYS=”” et CONFIG_SYSTEM_REVOCATION_KEYS=””. Enregistrez et passez à l’étape suivante.
Construisons maintenant le noyau, les modules de pilotes et mettons à jour Grub :
|
sudo make -j4 sudo make modules_install sudo make install sudo mise à jour-grub |
Mais même après avoir installé le pilote SPI, cela ne fonctionne toujours pas. Il faut injecter le code ACPI ASL dans le système et redémarrer :
|
#Télécharger les outils et la configuration sudo mkdir spi2 cd spi2 sudo curl -o spi-enable_upn-ehl01.zip http://d.youyeetoo.cn/X1/Linux-tools/linux-gpio-i2c-spi-nfc/spi/spi-enable_upn-ehl01.zip sudo décompresser spi-enable_upn-ehl01.zip #Modifier les autorisations de script sudo chmod 777 acpi-ajouter sudo chmod 777 acpi-mises à niveau sudo chmod 777 install_hooks sudo ./install_hooks #Exécuter le script : injecter du code ASL dans le noyau sudo acpi-add spidev* redémarrage sudo |
Vérifier SPI sur Youyeetoo X1
Enfin! Le /dev/spidev1.1 est maintenant détecté.
|
unoiot@unoiot-YouYeeToo-X1 :~$ sudo ls /dev/spi* /dev/spidev1.1 |
Mais comme il manque des informations sur le brochage du SPI, nous n’avons pas écrit de programme pour le tester. Une fois que plus d’informations seront disponibles, nous mettrons à jour cet article
Module POE
Le X1SBC n’est pas livré avec le support PoE, mais il comporte deux connecteurs PoE à 6 et 4 broches qui nous permettent d’ajouter un module PoE à la carte.
L’installation du module peut être effectuée en le soudant sur le côté de la carte proche de l’endroit où se trouve le support de la carte MicroSD. Youyeetoo a envoyé un module POE de 60 W pour des tests, ce qui nous a obligé à courber deux des broches avant l’installation.
Nous avons pu souder le module PoE après ce petit changement, et nous avons testé la carte avec un switch POE 8 ports Zyxel GS1008HP. La carte X1 démarrera dès que le câble Ethernet sera branché sur la prise RJ45.
Consommation électrique du Youyeetoo X1
Bien que le TDP et la consommation d’énergie ne soient pas directement corrélés, l’Intel Celeron N5105 a un TDP de 10 W selon Intel Ark, et nous effectuerons un test réel pour mesurer la consommation d’énergie du Youyeetoo X1 avec les modules Wi-Fi et GPIO. et des capteurs, et un SSD M.2 NVMe connecté à la carte.
Nous avons mesuré la consommation électrique de la carte avec un wattmètre multifonction. Les résultats obtenus avec l’adaptateur avec une tension de 12V DC, nous pouvons calculer le retour d’énergie à partir de l’équation P=IxV :
- Mise hors tension – 47 mA ou 564 mW
- Au repos – 577 mA ou 6,9 watts
- Banc SBC (7-zip multi-thread) – 1,759 A ou 21,55 Watts
Conclusion
La carte Youyeetoo X1 est une carte informatique unique à carte de visite alimentée par un Intel Celeron N5105 avec plusieurs en-têtes GPIO que nous n’aurions généralement pas sur la plupart des autres matériels x86. La carte dispose également de connecteurs M.2, M Key et E Key, pour connecter un SSD et/ou un module sans fil, que ce soit Wi-Fi ou 4G LTE ou SSD, ainsi que des interfaces MIPI DSI et HDMI pour connecter un écran ou moniteur avec une résolution jusqu’à 4K.
Nous avons testé avec succès GPIO, UART, I2C, SPI et NFC sur le Youyeetoo X1, et c’était plutôt simple, sauf pour SPI qui nous obligeait à activer SPI dans le noyau Linux et à le reconstruire à partir des sources. Dans tous les cas, cela rend la carte Youyeetoo X1 SBC adaptée à l’informatique de pointe et que vous soyez un fabricant, un développeur IoT ou un intégrateur de systèmes, la carte Youyeetoo X1 SBC pourrait répondre à vos exigences pour des projets tels que l’automatisation industrielle, les passerelles IoT, la robotique, et plus.
Nous tenons à remercier Youyeetoo pour l’envoi de la carte X1 SBC avec 8 Go de RAM et un flash eMMC de 128 Go, ainsi que l’écran tactile YYT-MIPI7LCD de 7 pouces et d’autres accessoires pour examen. Le Youyeetoo X1 SBC peut être acheté sur Amazon, Aliexpress et la boutique en ligne de l’entreprise. Les prix commencent à 109,99 $ pour le modèle avec 4 Go de RAM sans stockage, et le modèle examiné ici coûte 139,99 $, tandis que l’écran YYT-MIPI7LCD ajoute 30 $ supplémentaires.
CNXSoft : cet article a été traduit, avec quelques modifications et informations supplémentaires, à partir de la critique originale sur Raspberryme Software Thailand par Arnon Thongtem, et édité par Suthinee Kerdkaew.
Retrouvez l’histoire de Raspberry Pi dans cette vidéo :
