Examen du robot Makeblock mBot Neo avec le pack complémentaire Smart World

MakeBlock mBot Neo, également connu sous le nom de mBot2, est un robot éducatif qui s’appuie sur le robot mBot1 de la génération précédente, et la société nous a envoyé un échantillon d’évaluation, suite à notre examen précédent du kit de robot éducatif Ultimate 2.0 10-en-1, ainsi que avec le pack complémentaire Smart World.

Le mBot Neo est doté d’une nouvelle carte de contrôle CyberPi basée sur ESP32 avec connectivité WiFi pour la prise en charge de l’IoT et de l’IA. Le robot est également équipé d’un capteur à ultrasons de 2e génération avec une précision de détection d’objet et un indicateur d’état améliorés, d’un capteur de ligne RVB 4 canaux intégré capable de détecter les couleurs, ainsi que d’un nouveau moteur d’entraînement livré avec un encodeur pour une précision plus grande. contrôle de mouvement.

Le kit robot mBot Neo est extensible avec des pièces métalliques d’autres modèles Makeblock, des modules mBuild et divers modules électroniques peuvent être ajoutés, permettant également de construire des robots personnalisés avec des pièces structurelles tierces. Le kit robot mBot Neo convient aux élèves du primaire au lycée grâce à une programmation visuelle (par blocs), une programmation par glisser-déposer et une programmation plus avancée en langage Python.

Spécifications et composants clés du robot Makeblock mBot Neo

Le châssis est composé de pièces métalliques en aluminium bleu anodisé qui sont colorées, belles et durables.

Carte de contrôle CyberPi

Le CyberPi est la carte de contrôle principale du robot mBot Neo et a été conçu sur mesure par Makeblock lui-même. Il comprend un microcontrôleur ESP32 WiFi et Bluetooth, un écran couleur de 1,44 pouces, un port USB Type-C pour l’alimentation et la programmation, un gyroscope et un accéléromètre, un capteur de lumière, une LED RVB, un buzzer et un microphone. Les commandes utilisateur comprennent un joystick analogique, des boutons A/B pour naviguer dans les menus et un bouton Accueil pour sélectionner divers programmes de CyberOS.

Carte d’extension mBot Neo Shield

Équipé d’une batterie lithium-ion rechargeable intégrée, le mBot Neo Shield peut alimenter la carte de contrôle CyberPi et est livré avec deux ports multifonctions qui peuvent être utilisés pour connecter des servos et des moteurs à courant continu, ainsi que deux connecteurs de servo supplémentaires. , deux connecteurs de moteur CC supplémentaires, deux connecteurs de moteur d’encodeur et un port CyberPi pour le connecter à la carte de commande. MakeBlock fournit également des bibliothèques Block-Base et Python pour la carte d’extension

Capteur RVB quadruple

Le capteur Quad RGB est livré avec quatre capteurs de lumière d’une portée de 5 à 15 mm et quatre LED « fill light » pour réduire les interférences lumineuses avec le capteur depuis l’extérieur. Le capteur peut également mémoriser les valeurs de couleur pendant l’utilisation.

Le mode de mesure d’exposition automatique peut être calibré pour comparer deux valeurs de couleur en appuyant deux fois sur le bouton situé au centre du capteur. À ce stade, les lumières du capteur clignoteront rapidement et vous pourrez déplacer le capteur d’avant en arrière entre les deux couleurs (sur la piste) jusqu’à ce que la lumière LED s’éteigne. Cela prend généralement environ 2,5 secondes et le capteur mémorisera automatiquement les deux couleurs à l’avenir.

Capteur à ultrasons 2

Le capteur à ultrasons de deuxième génération de Makeblock a été amélioré pour augmenter sa précision de détection. La société a également ajouté un étui de protection soigné et une lumière LED bleue qui peut être utilisée pour détecter la distance par rapport aux objets devant le robot.

Le côté gauche du capteur est équipé d’un émetteur d’ondes ultrasoniques, tandis que le côté droit est doté d’un récepteur d’ondes ultrasoniques. Ainsi, lorsque le robot s’approche suffisamment d’un objet, il indique la distance avec une précision d’environ +/- 5 %.

Moteurs codeurs

Les moteurs à courant continu disposent d’un encodeur optique capable de compter les tours du moteur, ce qui nous permet de contrôler avec précision les roues du robot mBot Neo jusqu’à une vitesse de rotation de 180 tr/min. Les moteurs sont livrés avec deux trous filetés M4 de chaque côté pour une connexion facile aux pièces mécaniques du robot Makeblock.

Caractéristiques:

• Rapport de démultiplication : 39,6
• Tension : 7,4 volts
• Courant sans charge : 240 mA
• Courant sous charge : ≤750 mA
• Régime de ralenti : 350 ± 5 % (RPM)
• Vitesse de démarrage : 14 000 ± 5 % (RPM)
• Couple de démarrage : 5 g·cm
• Couple maximal : 800 g·cm
• Longueur de la tige : 9 mm
• Puissance : 3,7 watts
• Rotation de l’encodeur : 360°

Contenu du kit robot Makeblock mBot Neo

• Carte de contrôle CyberPi
• Bouclier mBot Neo
• 1x capteur à ultrasons 2
• 1x capteur Quad RVB
• 2x moteurs encodeurs avec 2x câbles, un moyeu de roue, 2x pneus slicks, 2x mini roues
• Câbles – Câble USB Type-C, 2 câbles mBuild de 10 cm, 1 câble mBuild de 20 cm
• Diverses vis – 4x M.2 x 12 mm, 6x M4 x 25 mm, 6x M4 x 14 mm, 6x M4 x 8 mm
• Tournevis
• Carte des voies de suivi de ligne

Logiciel permettant de programmer le robot Makeblock mBot Neo

mBlock 5 Editor est une plateforme de codage basée sur Scratch 3.0, prenant en charge la programmation visuelle et le langage Python, et spécialement conçue pour la robotique, STEAM et l’apprentissage du code. C’est un bon logiciel de codage pour les éducateurs, les étudiants, les créateurs et les enfants. Pour référence, Scratch est un outil de programmation développé par le MIT et est considéré comme le langage de programmation le plus populaire au monde pour les enfants. mBlock 5 comprend également des fonctionnalités telles que la programmation Python, l’IA, l’IoT, etc.

Programmation du robot mBot Neo à l’aide de l’éditeur mBlock5

Nous devrons d’abord connecter le robot mBot Neo à votre ordinateur à l’aide d’un câble USB Type-C branché sur le port USB situé sur le côté droit de la carte de contrôle CyperPi.

Cliquez maintenant sur l’icône « ajouter » dans l’onglet « Appareil », puis sélectionnez « CyberPi » et « mBot2 ».

Nous aurons alors accès au jeu de commandes du robot mBot Neo depuis l’interface mBlock 5.

Ensuite, cliquez sur « Connecter » pour vous connecter au robot, une fenêtre apparaîtra permettant à l’utilisateur de sélectionner le port COM, et une fois terminé, cliquez sur le bouton « Connecter ».

si « Connecté ! » apparaît, la connexion a réussi et nous sommes prêts pour la prochaine étape.

Programmation de l’affichage sur le mBot Neo

Aux fins de cet examen, nous avons programmé le mBot Neo pour afficher un message de test (« Logiciel Raspberryme ») sur l’écran en utilisant différentes couleurs.

Voici à quoi ressemble le programme de test avec la programmation par blocs…

et en Python :

</p><br /> <p>importer l’événement, l’heure, cyberpi @event.start def on_start() : cyberpi.display.set_brush(255, 0, 135) cyberpi.display.show_label(« C », 32, int(30), int(30), index = 0) cyberpi.display.set_brush(0, 182, 255) cyberpi.display.show_label(« N », 32, int(51), int(30), index = 1) cyberpi.display.set_brush(76, 255 , 0) cyberpi.display.show_label(« X », 32, int(71), int(30), index = 2) cyberpi.display.set_brush(255, 208, 0) cyberpi.display.show_label(« Logiciel » , 24, int(7), int(60), index = 3)

Programmation LED RVB

Développons maintenant notre exemple de code en programmant les LED RVB situées à l’avant du robot, juste sous l’écran. Nous allons programmer chacune des cinq LED avec une couleur différente.

Programme basé sur des blocs :
et le programme Python résultant :

</p><br /> <p>importer l’événement, l’heure, cyberpi @event.is_press(‘middle’) def is_joy_press() : cyberpi.led.set_bri(30) while True : cyberpi.led.on(255, 0, 0, 1) time.sleep(1 ) cyberpi.led.on(0, 0, 0, 1) cyberpi.led.on(255, 187, 0, 2) time.sleep(1) cyberpi.led.on(0, 0, 0, 2) cyberpi .led.on(16, 255, 0, 3) temps.sleep(1) cyberpi.led.on(0, 0, 0, 3) cyberpi.led.on(76, 0, 255, 4) temps.sleep (1) cyberpi.led.on(0, 0, 0, 4) cyberpi.led.on(255, 0, 208, 5) temps.sleep(1) cyberpi.led.on(0, 0, 0, 5 ) cyberpi.led.on(255, 0, 0, « tous ») time.sleep(1) cyberpi.led.on(0, 0, 0, « tous ») cyberpi.led.on(255, 187, 0 , « tous ») time.sleep(1) cyberpi.led.on(0, 0, 0, « tous ») cyberpi.led.on(42, 255, 0, « tous ») time.sleep(1) cyberpi .led.on(0, 0, 0, « tous ») cyberpi.led.on(0, 242, 255, « tous ») time.sleep(1) cyberpi.led.on(0, 0, 0,  » tous ») cyberpi.led.on(255, 0, 246, « tous ») time.sleep(1) cyberpi.led.on(0, 0, 0, « tous »)

Jouer de la musique via le buzzer

Le robot mBot Neo est également livré avec un buzzer, nous avons donc écrit un programme pour jouer de la musique avec différentes notes (fréquences) et durées.

Exemple de programme de programmation Block-Bases :Code Python :

</p><br /> <p>importer l’événement, l’heure, cyberpi @event.is_press(‘middle’) def is_joy_press(): cyberpi.audio.set_vol(30) cyberpi.audio.play_until(‘hi’) cyberpi.audio.play_drum(‘snare’, 0.25) pour le nombre dans la plage(2) : cyberpi.audio.play_music(62, 0.25) cyberpi.audio.play_music(63, 0.25) pour le nombre2 dans la plage(2) : cyberpi.audio.play_tone(700, 0.5) cyberpi.audio. play_tone(600, 0.5) cyberpi.audio.play_drum(‘grosse-caisse’, 0.25) cyberpi.audio.play_drum(‘side-stick’, 0.25) cyberpi.audio.play_until(‘running-water’) cyberpi.audio. play_until(‘au revoir’)

Contrôle moteur mBot Neo

Comme nous l’avons noté dans la description du robot Mbot Neo / mBot2, le kit est livré avec des moteurs encodeurs et des capteurs comme un accéléromètre. Nous les avons utilisés pour contrôler les moteurs du robot.

Exemple de programmation visuelle :

Programme Python résultant :

</p><br /> <p>importer un événement, une heure, cyberpi, mbot2 @event.is_press(‘middle’) def is_joy_press() : mbot2.forward(100) mbot2.straight(100) mbot2.turn_left(50) mbot2.turn(-90) mbot2.forward (80) mbot2.straight(120) mbot2.backward(50) mbot2.straight(-50) mbot2.turn_right(50) mbot2.turn(90) mbot2.forward(70) mbot2.straight(50)

Mouvement temporel du robot mBot Neo

Au lieu d’utiliser des capteurs pour contrôler le mouvement du mBot2, nous pouvons également le programmer pour qu’il se déplace dans une direction pendant une durée spécifique. Le programme basé sur des blocs ci-dessous montre comment procéder.
Programme Python :

</p><br /> <p>importer un événement, une heure, un cyberpi, mbot2 @event.is_press(‘middle’) def is_joy_press() : mbot2.forward(100, 1) mbot2.turn_right(100, 0.5) mbot2.forward(100, 1) mbot2.turn_left( 100, 0,5) mbot2.forward(100, 1) mbot2.turn_right(100, 0,5) mbot2.backward(100, 1) mbot2.turn_right(100, 0,5) mbot2.backward(100, 1) mbot2.turn_right(100, 0,5)

Programme d’évitement d’obstacles

Après l’exemple de base ci-dessus, passons maintenant à quelque chose d’un peu plus amusant, car nous utiliserons le capteur à ultrasons pour détecter les obstacles et nous assurer que le robot n’entre en collision avec aucun objet. Si un objet est détecté à moins de 10 cm, le robot mBot2 tournera de 90 degrés vers la gauche, et si aucun objet n’est détecté, il avancera à une vitesse de 50 tr/min. Remarque : des exemples de programmes supplémentaires d’évitement d’obstacles sont disponibles dans les exemples de programmes du programme mBlock 5.

Cela semble plus compliqué, mais la programmation visuelle rend les choses plutôt faciles.

Le programme Python est également court grâce à l’API CyberPi :

</p><br /> <p>import event, time, cyberpi, mbuild, mbot2 @event.is_press(‘middle’) def is_joy_press() : while True : si mbuild.ultrasonic2.get(1) < 10 : cyberpi.display.set_brush(0, 191, 255 ) cyberpi.display.show_label(« Détecté ! », 16, « center », index= 0) mbot2.turn(-90) else : cyberpi.display.set_brush(255, 0, 0) cyberpi.display.show_label( » Non détecté ! », 16, « center », index= 1) mbot2.forward(50)

Démo de suivi de ligne

Dans le test, nous avons écrit un programme de suivi de ligne utilisant une équation PID (proportionnelle-intégrale-dérivée) pour que le robot mBot2 suive au mieux la ligne sur la carte.

Exemple de programme utilisant la programmation visuelle :

Voici le programme Python pour cette démo un peu plus complexe :

</p><br /> <p>import event, time, cyberpi, mbot2, mbuild import time # initialiser les variables base_power = 0 kp = 0 left_power = 0 right_power = 0 @event.is_press(‘a’) def is_btn_press(): global base_power, kp, left_power, right_power cyberpi .stop_other() mbot2.drive_power(0, 0) @event.is_press(‘b’) def is_btn_press1() : global base_power, kp, left_power, right_power cyberpi.stop_other() base_power = 30 kp = 0,8 tandis que True : left_power = (base_power – kp * mbuild.quad_rgb_sensor.get_offset_track(1)) # En tant que « quantité d’écart », la position de décalage de ligne peut être utilisée pour la correction d’écart des tâches automatiques de suivi de ligne. C’est le « P » dans ce que nous appelons le contrôle PID. # # I et D impliquent des connaissances intégrales et différentielles et ont des exigences élevées en matière de mathématiques, de programmation et d’efficacité matérielle, qui ne seront pas développées ici. right_power = -1 * ((base_power + kp * mbuild.quad_rgb_sensor.get_offset_track(1))) mbot2.drive_power(left_power, right_power) @event.is_press(‘middle’) def is_joy_press() : global base_power, kp, left_power, right_power cyberpi.stop_other() while True : cyberpi.console.println(mbuild.quad_rgb_sensor.get_red(« R2 »,1)) time.sleep(0.1)

Jouez avec le robot Makeblock mBot Neo via l’application mobile Makeblock.

L’application Makeblock est disponible pour les systèmes d’exploitation iOS et Android. Une fois l’installation terminée, démarrez l’application Makeblock, sélectionnez le sous-menu « Appareil », puis sélectionnez « mBot2/mBot Neo ».

Allumez maintenant le commutateur du robot mBot2, appuyez sur le symbole Bluetooth et sélectionnez l’adresse MAC Bluetooth qui apparaît dans l’application.

L’application tentera alors de se connecter automatiquement au robot et signalera le succès si tout s’est bien passé.

Le menu Lecture permet à l’utilisateur de démarrer rapidement avec le robot sans avoir à écrire une seule ligne de code.

Quatre modes peuvent être sélectionnés dans le menu Lecture.

Mode 1 : Conduire – Il est livré avec un joystick, des boutons pour changer la couleur des LED RVB et divers boutons d’action par exemple pour émettre du son ou déplacer rapidement le robot.

Mode 2 : Dessiner et courir – Comme son nom l’indique, vous pouvez dessiner une piste virtuelle dans l’application, comme le cœur ci-dessous, et le robot courra le long de la carte dessinée dans l’application une fois que nous aurons appuyé sur l’icône de démarrage.

Mode 3 : Musicien – Ce mode affichera un petit piano qui permet à l’utilisateur de jouer de la musique et est également livré avec quatre icônes pour jouer automatiquement des chansons d’anniversaire ou de Noël.

Mode 4 : commande vocale. Le robot suit les commandes vocales (en anglais uniquement) avec six commandes prises en charge au moment de l’examen

1. Aller de l’avant
2. Aller à l’arrière
3. Tourner à gauche
4. Tournez à droite
5. Danse
6. Arrêt

Le menu Code est utilisé pour écrire du code sur votre smartphone comme vous le feriez sur un ordinateur via l’IDE mBlock 5, et vous pouvez également télécharger les programmes via Bluetooth.

Le mode Code se connectera automatiquement à l’application mBlock sur votre smartphone à condition que vous l’ayez déjà sur Android ou iOS.

Examen du pack complémentaire Smart World

Nous venons de passer en test certaines des fonctionnalités du robot mBot Neo, mais notre kit est également livré avec le pack complémentaire Smart World qui améliore encore l’expérience d’apprentissage STEAM avec des pièces et des instructions pour construire un porteur robotique, un robot d’arpentage et /ou un bras robotique.

Contenu du pack complémentaire Smart World

• 1x Faisceau 036, 2x Faisceau 060, 4x Faisceau 076, 1x Faisceau 092
• 1x poutre coulissante 016, 2,x poutre coulissante 032
• 6x Raidisseur
• 1x support 3×3
• 2x plaque 3×6, 1x plaque B 7×9
• Vis – 15x M4 x 8 mm, 8x M4 x 10 mm, 5x M4 x 10 mm, 3x M4 x 16 mm, 2x M4 x 22 mm, 2x M4 x 25 mm
• 6x vis sans tête M3 x 5 mm
• 2x Goujon en laiton M4 x 8+6mm
• 2x roues universelles
• 2x servomoteurs 9g (MS-1,5A)
• 7x écrou M4
• 6x collier d’arbre 4mm
• 7x anneau en plastique 4x7x3mm, 2x anneau en plastique 4x7x2mm
• 1x Clé, 1x Clé Allen HEX 1,5mm, 1x Clé Allen HEX 2,5mm
• Un câble de connexion de 20 cm
• 3x arbre en D 4x56mm
• 2x boules de couleur

Assemblage et test du kit Robotics Carrier du mBot Neo

Le robot mBot Neo Robotics Carrier peut transporter des objets vers différents points au fur et à mesure que nous le programmons. Dans ce test, nous allons faire avancer le robot pendant 5 secondes, puis régler le servomoteur à 0 degré pour livrer un colis, puis régler le servomoteur à 90 degrés et reculer pendant 5 secondes pour récupérer un colis (Voir le vidéo intégrée à la fin du post pour une démo)

Exemple de programme basé sur des blocs :

Programme Python :

</p><br /> <p>importer l’événement, l’heure, cyberpi, mbot2 importer l’heure @event.start def on_start() : mbot2.servo_set(90, »S4″) @event.is_press(‘middle’) def is_joy_press() : pour le nombre dans la plage (3) : cyberpi.led.on(255, 0, 0, « all ») cyberpi.display.set_brush(255, 0, 0) cyberpi.display.show_label(« Forward », 16, « center », index= 0) mbot2 .forward(50, 5) mbot2.servo_set(0, »S4″) time.sleep(1) mbot2.servo_set(90, »S4″) cyberpi.led.on(29, 255, 0, « all ») cyberpi .display.set_brush(114, 255, 0) cyberpi.display.show_label(« Backward », 16, « center », index= 0) mbot2.backward(50, 5) mbot2.EM_stop(« ALL ») time.sleep (6)

Test et assemblage du robot d’arpentage mBot Neo de Makeblock

Le robot d’arpentage mBot Neo utilise des servomoteurs pour faire pivoter et trouver des objets. Il fonctionne avec le capteur Ultrasonique 2 pour détecter la distance des objets et exploite le capteur Quad RGB pour détecter des objets de différentes couleurs. (Voir un exemple fonctionnel dans la vidéo ci-dessous).

Le programme basé sur des blocs…

… et le programme Python commence à être un peu plus compliqué :

</p><br /> <p>importer l’événement, l’heure, cyberpi, mbot2, mbuild importer l’heure @event.start def on_start() : mbot2.servo_set(10, »S3″) cyberpi.led.show(‘rouge orange jaune vert cyan’) mbuild.ultrasonic2.play (« sleepy », 1) mbuild.ultrasonic2.set_bri(0, « all », 1) mbuild.quad_rgb_sensor.color_mode(« enhance ») while True : pour le nombre dans la plage (43) : mbot2.servo_add(2, »S3 « ) si mbuild.ultrasonic2.get(1) < 10 : mbot2.EM_stop(« ALL ») CheckColor() time.sleep(0.05) mbot2.forward(50) pour count2 dans range(43) : mbot2.servo_add(2 , »S3″) si mbuild.ultrasonic2.get(1) < 10 : mbot2.EM_stop(« ALL ») CheckColor() time.sleep(0.05) pour count3 dans range(43) : mbot2.servo_add(-2, » S3″) si mbuild.ultrasonic2.get(1) < 10 : mbot2.EM_stop(« ALL ») CheckColor() time.sleep(0.05) pour count4 dans range(43) : mbot2.servo_add(-2, »S3″ ) si mbuild.ultrasonic2.get(1) < 10 : mbot2.EM_stop(« ALL ») CheckColor() time.sleep(0.05) def CheckColor() : if (mbuild.quad_rgb_sensor.is_color(« red », »any » ,1)) : mbot2.EM_stop(« ALL ») time.sleep(1) cyberpi.led.on(208, 2, 27, « all ») mbot2.forward(50, 0.5) mbot2.turn(-110) if (mbuild.quad_rgb_sensor.is_color(« green », »any »,1)) : mbot2.EM_stop(« ALL ») time.sleep(1) cyberpi.led.on(1, 208, 15, « all ») mbot2.forward(50, 0.5) mbot2.turn(-110) if (mbuild.quad_rgb_sensor.is_color(« blue », »any »,1)) : mbot2.EM_stop(« ALL ») time.sleep(1) cyberpi .led.on(1, 12, 208, « all ») mbot2.forward(50, 0.5) mbot2.turn(-110) if (mbuild.quad_rgb_sensor.is_color(« jaune », »any »,1)) : mbot2.EM_stop(« TOUS ») time.sleep(1) cyberpi.led.on(250, 255, 2, « tous ») mbot2.forward(50, 0.5) mbot2.turn(-110)

Le bras robotique de Makeblock mBot Neo

Le bras robotique mBot Neo peut soulever et ramasser des objets grâce à un bras qui peut monter et descendre verticalement et peut attraper des objets ne dépassant pas 15 centimètres. Le programme de démonstration conduit le robot vers un objet pour le ramasser et le déplacer vers un autre emplacement. Encore une fois, vous trouverez une démo dans la vidéo ci-dessous.

Démo de programmation visuelle :

Programme Python correspondant :

</p><br /> <p>événement d’importation, heure, cyberpi, heure d’importation mbot2 @event.is_press(‘middle’) def is_joy_press(): mbot2.straight(10) mbot2.turn(-100) mbot2.straight(15) cyberpi.display.set_brush(0 , 255, 255) cyberpi.display.show_label(« Objets trouvés », 16, « center », index= 0) mbot2.servo_set(140, »S3″) time.sleep(1) pour le nombre dans la plage(18) : mbot2.servo_add(-5, »S4″) time.sleep(0.1) mbot2.straight(-15) mbot2.turn(100) pour count2 dans la plage (18) : mbot2.servo_add(5, »S4″) time. sleep(0.1) mbot2.servo_set(90, »S3″) time.sleep(1) mbot2.straight(-15) pour count3 dans la plage(16) : cyberpi.led.show(‘rouge orange jaune vert cyan’) mbot2 .turn(-90) @event.start def on_start() : mbot2.servo_set(90, »all »)

Test vidéo et démo du Makeblock mBot Neo avec le pack complémentaire Smart World

Conclusion

Le kit robot éducatif mBot Neo et le pack complémentaire Smart World en option sont idéaux pour apprendre à construire des robots. Que vous appreniez par vous-même ou que vous enseigniez la robotique à des élèves du primaire au lycée, c’est une bonne plateforme pour apprendre la programmation grâce à sa programmation par blocs et à sa prise en charge Python.

La conception du robot est solide et durable, avec des couleurs vives, et elle peut également être étendue à diverses pièces structurelles provenant de tiers. La nouvelle carte de contrôle CyberPi avec boîtier ESP32 permet une connectivité sans fil, ce qui la rend plus pratique à utiliser pour les applications IoT et IA. Le support logiciel est bon grâce à une bibliothèque complète qui couvre toutes les principales fonctionnalités du robot.

Le robot mBot Neo est également livré avec un moteur encodeur pour un contrôle précis du moteur, un capteur de ligne qui peut comparer automatiquement les lignes et la deuxième révision du modèle ultrasonique de la société qui constitue une amélioration par rapport à la génération précédente avec une meilleure stabilité et précision. Parmi les autres points forts figurent un servomoteur de haute qualité, l’intégration d’un capteur de boussole, ainsi qu’un écran LCD couleur et plusieurs LED RVB. Le kit robot est extensible avec la prise en charge de divers modules MakeBlock, et un avantage supplémentaire par rapport aux solutions concurrentes est la possibilité de programmer le robot à la fois sur un ordinateur ou sur un smartphone, puisque la programmation par glisser-déposer est également prise en charge dans ce dernier.

Nous tenons à remercier MakeBlock d’avoir envoyé le kit robot mBot Neo et le kit complémentaire Smart World pour examen. Le kit robot mBot Neo avec le pack complémentaire Smart World peut être acheté pour 218,99 $ sur la boutique en ligne de la société. Le coupon « NEW10 » peut vous offrir une réduction supplémentaire de 10 $.

Retrouvez l’histoire de Raspberry Pi dans cette vidéo :