ArduinoMania

XGO Duck is an open source, 3D-printable robot duck that Luwu Dynamics built starting from Pollen Robotics’ Microduck. From the original project it keeps the body, the layout of the 15 servos and the joint order, but replaces all of the electronics. In place of the Pollen Robotics board there is an Arduino UNO Q, which runs neural policies for walking, getting up from the ground and picking. So there is no need to wait for a commercial robot: anyone with a 3D printer can build one.

The heart of the system is the Arduino UNO Q itself, which hosts two computers on a single board. On one side there is a host with a Qualcomm processor running Linux, on the other an STM32U585 MCU running Zephyr. This division of tasks is the most interesting architectural choice in the project. The host handles the neural policies, the MCU handles real-time motor control. On top of that, the link between the two is a 2 Mbps Bridge, so the two worlds stay synchronised without Linux ever having to wait on the servo bus.

Two computers, two loops: 50 Hz for the policies and 100 Hz for the bus

The host runs the ONNX policies at 50 Hz on a dedicated thread, with the web UI listening on port 9527. The MCU, on the other hand, runs a 100 Hz bus loop and does not wait for Linux. It publishes a 240-byte duck_state snapshot at 100 Hz; the host filters every snapshot on arrival and the 50 Hz thread reads the latest available one, skipping late cycles. That way the robot does not stall if the host is busy.

The servo bus always addresses all 15 servos in the order ID 10-14, 20-24, 30-34. The order in action 14-D of the policy is instead 10-14, 30-33, 20-24. The servo bus is on Serial1 at 1 Mbps, while the QMI8658 IMU is on Wire at 400 kHz, with I2C address 0x6A then 0x6B. Servo positions are saturated to the encoder range 0-4095, with a raw centre position of 2047.

• 15 FeeTech 1910 servos on a serial bus
• Arduino UNO Q with Qualcomm host and STM32U585 MCU
• QMI8658 IMU on the Wire bus at 400 kHz
• Bridge host-MCU link at 2 Mbps
• servo bus on Serial1 at 1 Mbps

The neural policies: observation [1, 61], action [1, 14] and automatic get-up

The policies expect an observation [1, 61] and output an action [1, 14]. There are three: xgoduck_walk.onnx for walking, xgoduck_getup.onnx for getting up from the ground and xgoduck_pick.onnx for the pick, which lasts 4 s. A tilt above 55° for 0.15 s triggers the get-up model, then the action is forced to 0 for 1 s. When the tilt drops below 15° for 1 s, the robot goes back to walking.

The home pose has hip and ankle at ±24°, knee at 0°, hip roll at ±5°, neck and head pitch at 20°, mouth at 0°. The action_scale is 1. The walking commands are vx ±0.4, vy ±0.3 and ωz ±1.0, with a joystick dead zone of 0.1. The four head channels sit within ±1 radian. The mouth is driven from the web UI from 0° to 30°, and in the pick cycle it opens to 30° and closes when φ ≥ 0.4.

Action smoothing uses α = 0.45 on the slices [0:5], [5:10] and [10:14], yaw smoothing uses α = 0.5 and joint speed smoothing uses α = 0.4. The gravity complementary filter uses τ = 0.3 s, with accelerometer correction dropping when the norm deviates from 1 g by more than about 20%. Position control stops if commands are missing for 250 ms or if the IMU is missing for 100 ms; a host feedback older than 150 ms disarms it.

The Zephyr firmware, servo calibration and the web UI on port 9527

The firmware is a CLI app built with Arduino Zephyr core 1.0.0, on top of RouterBridge 0.4.3, RPClite 0.3.1 and MsgPack 0.4.2. A patch to RouterBridge 0.4.3 raises the RPC thread stack from 500 to 4096 bytes, and the serial router is set to 2 Mbps. Calibration and servo setup use a 2 s heartbeat. The temporary gains for the centring movement are KP = 6 and KD = 20, with a temporary KP = 10 for the servo with ID 34. During calibration the gains become KP = 3 and KD = 0, and every servo is commanded to 2047.

The servo setup page starts with default values KP = 5 and KD = 20. Writing the ID unlocks register 0x37 and then writes 0x05; writing KP/KD unlocks 0x37 and stores both bytes at 0x15. The duck_command sent by the host is 80 bytes. Closing the page or leaving it in the background for more than 1 s disables position control, so the web UI is not just a convenience panel.

The Luwu Dynamics repository collects the project code: sketch, configurations, ONNX models and support scripts. Among the tools are tools/prepare-bridge.py, tools/router-2m.sh, tools/reuse-toolchain.py, tools/verify-elf.py and tools/measure.py, which measures for 60 seconds. There are also python/rl_core.py, python/requirements.txt, sketch/sketch.yaml, app.yaml, data/zero_pos.json and sketch/duck_config.h. Anyone who wants to rebuild it will find everything needed to get started there.

The host needs a Linux environment with ONNX Runtime and Python, while the MCU runs on Zephyr. The UNO Q loader error in case of a tail-call is ENOEXEC (−8), a detail familiar to anyone who compiles firmware. The default rate of Bridge.begin() in another app is 115200, so it has to be raised to 2 Mbps to run the bus as needed. If you want to start with the right hardware, an Arduino UNO Q with a complete accessory kit covers the host and MCU side on a single board.

Source: https://github.com/LuwuDynamics/xgoduck_runtime_arduino

Related products

• Arduino UNO Q 4GB – Complete kit with accessories

The post XGO Duck: the open source robot duck that walks with neural policies appeared first on Open Electronics.

Driving a 6-colour e-paper display is not like driving a monochrome panel. Seeed Studio’s reTerminal E1002 carries a 7.3-inch ACeP with 800×480 resolution, and a XIAO ESP32-S3 runs underneath it. Mariusz Jurgielewicz has put together a set of Arduino examples tested on exactly this combination, so newcomers don’t have to reinvent pinout, polarity and refresh sequences.

The practical value of the collection lies in the details the official drivers don’t tell you. The GDEP073E01 panel uses the ED2208 controller and is wired to the carrier through an internal FPC. So the pins are not the ones you’d expect from a breakout module: SCK is on GPIO 7, MOSI on GPIO 9, CS on GPIO 10, DC on GPIO 11, RST on GPIO 12 and BUSY on GPIO 13. Logging is also duplicated across two serials, Serial1 on GPIO 43 and GPIO 44 through the USB-UART bridge, plus the XIAO ESP32-S3’s native USB CDC Serial.

BUSY active-low and SPI clock at 2 MHz

Trap number one is the BUSY polarity. On the ED2208 the signal is active-low: 0 means refresh in progress, 1 means ready. Inverting it locks up the driver or corrupts subsequent writes, and the symptom isn’t a clear error but a panel that stays half-drawn.

The second trap is the clock. The SPI bus runs reliably at 2 MHz, and this also applies to the upload speed set in the Arduino IDE, fixed at 115200. The log serial runs at 115200 baud. Higher frequencies on the internal flex risk clock distortion, with pixel dropouts or corrupted command bytes. Finally there’s the watchdog: during a cold refresh the 40-second timeout can fire, so the sequence has to be handled accordingly.

• SCK on GPIO 7, MOSI on GPIO 9, CS on GPIO 10
• DC on GPIO 11, RST on GPIO 12, BUSY on GPIO 13
• BUSY active-low: 0 refresh in progress, 1 ready
• Reliable SPI clock at 2 MHz
• Serial1 on GPIO 43 (TX) and GPIO 44 (RX), plus native USB CDC
• 192,000 bytes of frame buffer in OPI PSRAM

A full frame buffer of 800×480 pixels at 4 bits per pixel, two pixels per byte, requires 192,000 bytes. It doesn’t fit in the ESP32-S3’s internal RAM, so it has to be buffered in OPI PSRAM. The panel exposes 6 native solid colour fields: black, white, red, green, blue and yellow. So each pixel is not a grey value but a colour index, and dithering has to be planned accordingly.

On the software side the collection covers three driver stacks. The first is Jean-Marc Zingg’s GxEPD2, the upstream one you get from the Library Manager. The second is the Good Display vendor driver. The third is Waveshare’s GUI_Paint graphics framework, sitting on top of Adafruit_GFX. Watch out for one detail: the Seeed_GxEPD2 fork should not be installed, because it conflicts with the upstream GxEPD2.

Besides the display, the examples cover the carrier board’s onboard peripherals. There’s the PCF8563 real time clock and the SHT4x environmental sensor, so a complete project can show the time plus temperature and humidity data without adding external modules. Anyone who wants to rebuild everything from scratch will find Mariusz Jurgielewicz’s repository with the sketches ready to upload.

To work on it you need the Arduino IDE with XIAO ESP32-S3 support, the GxEPD2 library from the Library Manager, and the panel connected to the carrier.

Source: https://github.com/melastmohican/reTerminal-E1002-arduino-examples

The post Arduino examples for the 6-colour e-paper display on the reTerminal E1002 appeared first on Open Electronics.

When you’re developing systems that support air navigation services, the margin for compromise is essentially zero. Reliability isn’t a “nice to have,” it’s the baseline. That’s the world in which Techno Sky operates, and it’s what makes their decision to build around the Arduino® Opta RS485 microPLC responsive to the project’s identified requirements.

Techno Sky is an ENAV Group company that manages and maintains hardware and software systems supporting air navigation services, and develops innovative technologies for the Air Traffic Management (ATM) sector. Their R&D department works on solutions for air navigation service providers (ANSPs), airports, aviation authorities, and organizations worldwide – systems designed for use under demanding operational conditions.

The challenge: a compact, reliable visual emergency signaling system

The project that brought Techno Sky to Arduino was the development of a visual emergency signaling system for integration within ENAV’s Digital Tower environment. The requirements were unambiguous: industrial-grade reliability, compact form factor, continuous operating capability, Ethernet and industrial communication interfaces, integrated I/O, and the ability to develop and maintain the system without building dedicated custom electronics from scratch.

A fully custom hardware design was on the table, but it would have added significant time and complexity – hardware design, integration, and validation cycles that would delay the project without necessarily improving the outcome. The team needed a platform that would let them focus on application logic and system integration, not on reinventing the controller underneath it.

Opta: a non-conventional, but versatile and effective path to innovation

The R&D team evaluated conventional PLCs, custom embedded electronics, and single-board computers before landing on Opta. It selected Opta based on its combination of industrial characteristics and software flexibility in a single package. The team determined that the conventional PLCs it evaluated offered less development agility for this project. Custom electronics would have added hardware design overhead. The single-board computers evaluated by the team did not meet the project’s identified specifications.

The Opta RS485 offered integrated Ethernet and RS485 communications, relay outputs, and the flexibility of the Arduino programming environment and library ecosystem – all in a compact, DIN rail-mountable form factor designed for industrial applications. Critically, it allowed new functionality to be implemented through software without adding dedicated hardware, a quality that would prove important as the system evolved.

An architecture for in-house deployment within the year

In the deployed system, Opta acts as the main embedded controller, managing signaling outputs, Ethernet communication, RS485 communication with external equipment, operating modes and timing, supervision functions, and communication integrity and security. The system currently implements eight signaling modes on a single controller – functions that the Techno Sky team determined could otherwise have required additional hardware or a more complex architecture.

The main engineering challenge during development was coordinating communications, physical outputs, signaling sequences, and supervision in parallel. The team addressed this through a modular software architecture and the use of watchdog and communication-validation mechanisms – approaches intended to support a manageable codebase and consistent system behavior. Development was carried out internally by Techno Sky’s R&D team using Arduino documentation, libraries, and development resources.

According to Techno Sky, the project started in October and reached operational deployment in under 12 months. One Opta controller integrating more than ten main control functions, designed for continuous operation, with the same architecture carried through from R&D prototype to operational system.

From prototype to production on the same platform

That last point deserves emphasis. R&D teams may prototype on one platform and later transition hardware when moving toward deployment. Techno Sky didn’t need to make that transition. The architecture based on Opta developed during R&D was the architecture retained for operational use – a decision that they report was based on its assessment of the platform for this application.

Techno Sky summarized their experience: “Opta enabled us to move rapidly from an R&D concept to an operational solution. Its industrial hardware, combined with the Arduino programming environment and library ecosystem, allowed us to integrate and expand multiple functions without increasing hardware complexity. The fact that we are retaining Opta in the operational system reflects our positive assessment of its effectiveness and reliability for this application.”

More ideas, more innovation

The Techno Sky team has been working with Arduino platforms across their R&D activities for several years, and this project showcases their reinforced confidence in their chosen Arduino product line. Future applications under consideration include monitoring systems, remote control, sensor integration, robotics, automated test equipment, and ATM infrastructure – a range of potential uses that Techno Sky is evaluating.

For teams facing similar integration challenges – multiple control and communication functions, demanding reliability requirements, and pressure to move quickly from concept to deployment – Techno Sky’s assessment is direct: Opta is well suited, in Techno Sky’s assessment, when those functions need to come together in a compact system, without the overhead of custom hardware design.

Ready to explore options for your industrial application? Find out more about the Opta family and Arduino’s industrial-grade range at arduino.cc/pro.

Arduino, Opta, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

The post How Techno Sky and Arduino Opta brought an industrial visual emergency signaling solution to air traffic management appeared first on Arduino Blog.

It’s almost that time of year again! No chance to 3D print your Arduino®-powered pumpkin project? Didn’t get around to animating the LEDs on your costume? There’s still time, and here’s a half-dozen Hallowuino-themed projects to get you inspired.

Spooky, Sassy Pumpkin

You’ve heard of Spooky, Scary Skeletons, well here’s a Spooky, Sassy Pumpkin that is built to use a USB webcam to identify visitors as they approach, then answer their questions about what it sees using the Arduino App Lab Vision-Language Model (VLM) Brick. This jack-o’-lantern packs a whole lot more smarts than your average fruit thanks to the dual-brain VENTUNO Q concealed underneath it. All processing is designed to be handled offline, on-device without sending users’ faces and voices  across networks or to the cloud.

Arduino-Powered Animatronic Supergroup

Bands break up for all kinds of reasons, so we were pleased to see Arduino Project Hub member nerdabilly figure out a way to sync the Costco Skeleton Punk Rocker animatronic with the Lowe’s Reaper Band. The band members are centered around a Bluetooth speaker, while the rocker is triggered by a timer or motion sensor. Not wanting to permanently alter these expensive displays, nerdabilly used the existing analog signal from the band leader to trigger the pink in place of its motion-sensing trigger, so the whole crew can rock out with their skulls out. Nerdabilly, we salute you for keeping this spooky symphony in sync!

Simple Spookiness with Modulinos and MP3s

Here’s some simple steps to sprinkle some spookiness into your season from our own team. Using the UNO R4-based Plug and Make Kit, plus a DFRobot DFPlayer MP3 player module, we show you how to trigger spooky lights and sounds when the Modulino® Distance sensor detects a presence. You can even connect to the Arduino Cloud to activate, customize, and monitor your project remotely. And that’s just the start – the seven included modules and built-in Wi-Fi give you plenty of options for creating your own frightful projects!

Ultrasonic Spider

Everyone has to start their Arduino journey somewhere, and for Project Hub member ParzivalUK, that place was a half-decade old project video demonstrating a fake spider dropping on unsuspecting passers-by. Unfortunately, ParzivalUK found that the accompanying code no longer worked for their project, and there weren’t detailed steps on how to recreate it. Driven by a desire to delight their son with a fun Halloween prank, ParzivalUK pushed on, combining a servo with an ultrasonic sensor to drop a toy spider on anyone who comes within approximately 40cm of the trap, with a continuous rotation servo to wind it back up, ready for the next victim!

Portal Sentry Turret

We love seeing projects shared on the unofficial Arduino Discord server. User jaysicks’ Aperture Science Sentry Turret costume really caught our eye, and we asked for a little more detail. The resulting Instructable is a detailed step-by-step guide for recreating the iconic tripod robot from one of the most beloved puzzle platformers of all time. With no 3D printer at hand, the costume relies on cardboard construction but comes out looking great. A red LED in the eye responds to the audio output from the incorporated GD380D-M audio playback module when a button is pressed, and the whole thing is controlled by an ATtiny85V microcontroller, programmed using the Arduino IDE. We think jaysicks’ son will be the envy of the neighborhood this Halloween, or at least among those with a solid appreciation of classic video games!

Cyber Research Systems T-1-7 Warrior Robot

The T-800 and T-1000 may get most of the screen time, but Redditor u/parsupo recreated the more niche T-1-7 Warrior Robot for their annual Halloween project. Built around an electric wheelchair base, the bot uses an Arduino Mega 2560 to receive and process commands from a remote control, and the same ATmega328 chips found in the UNO to control lights, gun movement, and the head. It may not be made of mimetic polyalloy, but we wouldn’t want to run into it in a dark alley!

What will you make?

Got a spooky Arduino-based project to share? Or need help realizing your creation? Head over to the Arduino subreddit and let us know!

The post How about a Hallowuino half-dozen? appeared first on Arduino Blog.

An 8-key piano on a breadboard with an Arduino Uno R3, eight 6×6 mm tactile buttons and a passive piezo buzzer. Each key you press plays a note of the C major scale, from C4 at 262 Hz up to C5 at 523 Hz. That is enough to play tunes like Twinkle Twinkle Little Star. No shield, no external library and no soldering are needed: just a breadboard, jumpers and a USB cable.

Assembly is the quickest part. The tactile buttons go into the breadboard straddling the centre channel, one next to the other. Each button has one side connected to an Arduino digital pin and the other side to GND. The passive buzzer has its positive leg on pin D10 and its negative leg on GND. A jumper connects the breadboard’s GND rail to the board’s ground.

The keys occupy pins D2 to D9, eight consecutive digital pins. The Arduino Uno has 14 digital pins (D0-D13) and 6 analog pins usable as digital inputs, so there is plenty of room to add keys in a later version. For the keys, the catalogue has a 6×6 mm PCB mini pushbutton, the same format used in the project.

INPUT_PULLUP and the tone() function in the firmware

The code uses no library: it relies on the tone() function built into the Arduino IDE. Each button is connected between a pin and GND, so the firmware enables the internal pull-up resistor with INPUT_PULLUP. As a result the pin reads HIGH when the key is at rest and LOW when it is pressed. The code scans the eight pins, stores the first key pressed and calls tone() with the associated frequency.

The comparison if (pressedKey != lastKey) makes tone() fire only once per press, instead of repeating the call on every pass of the loop. When no key is pressed, the code calls noTone() and the sound stops. The serial monitor opens at 9600 baud and is used to check which keys are being read during testing.

• Key 1: C4 at 262 Hz
• Key 2: D4 at 294 Hz
• Key 3: E4 at 330 Hz
• Key 4: F4 at 349 Hz
• Key 5: G4 at 392 Hz
• Key 6: A4 at 440 Hz
• Key 7: B4 at 494 Hz
• Key 8: C5 at 523 Hz

The piano is monophonic, and that is a limitation of the tone() function: it generates only one frequency at a time. So if you press two keys together, the one with the lower number wins, that is, the first one the loop encounters. Anyone who wants real chords has to change approach, for example generating the waveforms by hand with a timer.

Passive buzzer, current draw and an alternative speaker

The passive piezo buzzer works from 3.3V to 5V and draws less than 30 mA, so you can drive it straight from an Arduino pin without a transistor. Its best output is around 2-4 kHz, while the notes of this piano run from 262 Hz to 523 Hz. The sound comes out, but don’t expect concert volume: to raise the sound pressure, a speaker is a better bet.

Instead of the buzzer you can use an 8 ohm speaker with a 100 ohm resistor in series. The resistor limits the current and protects the pin. On top of that, the sound is fuller on the low notes of the scale. The rest of the circuit does not change: positive on D10, negative on GND.

Rebuilding the project takes only a few parts: an Arduino Uno R3, eight 6×6 mm tactile buttons, a passive piezo buzzer, a breadboard, jumpers and a USB cable. The cost is low and so is the difficulty. In fact it is an ideal first project for learning about digital inputs, INPUT_PULLUP and the tone() function, and you can finish it in an evening.

If you want to see the build in action, on the maker’s site you will find the video with the piano played key by key. There you can see how the buzzer behaves on the different notes before soldering or buying anything.

Source: https://www.circuitschools.com/arduino-piano-project-with-8-keys-build-a-simple-piano/

Related products

• PCB Mini Pushbutton – 6x6x7 mm

The post Build an 8-Key Piano on a Breadboard with Arduino appeared first on Open Electronics.

Arduino, Qualcomm Technologies, and Edge Impulse recently teamed up with Hackster to host the Invent the Future competition. The competition attracted 4,028 registrants and 1,202 hardware applications, culminating in 153 final project submissions across a wide range of real-world applications.

There were several categories in the competition, all unified by the UNO Q board and Arduino® App Lab. The judging is officially complete and the winners have been announced, which means we get to show you the top projects that most impressed the judges and took home the awards!

These winning creations illustrate a range of uses for the UNO Q – and stay tuned, because we’ll also be shining the spotlight on many other fantastic contest submissions in the coming days.

Best Social Impact

While sustainability was a consideration for every category, the Best Social Impact award went to a project built explicitly to make the world a better place. The winning project was the Smart Water Guardian AI, built by KOCHONI Biaou David Barthélémy.

This project puts the edge AI capabilities demonstrated by UNO Q to good use, by monitoring water-quality indicators in real time. Through a host of sensors, it is designed to measure everything from temperature and pH to turbidity and dissolved solids content, allowing for detection of anomalies that correlate with poor water quality – detection that could save lives.

Best in Home Automation

Home automation is a thriving industry, and there are all kinds of tech products you can use to build the smart house of your dreams. But what about your chickens’ house? That’s what Coders Cafe’s Smart Coop 2.0 is for.

Smart Coop 2.0 is a system design, driven by an UNO Q, for intended to support routine chicken care. It is built to handle the basics, like dispensing feed on a schedule and heating the space, using local AI models designed to detect eggs and potential predators. The creator designed Smart Coop 2.0 to make certain chicken-care tasks more convenient and to detect potential predators, including coyotes and foxes.

Best in Gaming

RollerCoaster Tycoon was a popular video game generally among two types of people: those who enjoy creative building and those who like maximizing metrics. Kevin Loeffler is the latter type, and he wondered how real-life roller coasters might stack up. The result is RCT IRL, which is a wearable sensor system for classifying and quantifying roller coaster rides.

“Wearable” here means an UNO Q, a SparkFun 9DoF IMU (inertial measurement unit), and a battery stuffed into a fanny pack. During a coaster ride, the dual-brain board from Arduino is structured to collect movement data through the IMU. Afterwards, three Edge Impulse models are designed to process the data and generate model-based scores labeled Excitement, Intensity, and Nausea. Together with interesting stats like ride time and maximum g-forces, those values populate a report card for the roller coaster, just like in the game.

Best in Industrial IoT

HaloSense V1 is pasquale887’s attempt to give humans new senses via neuroplasticity. In short, neuroplasticity is your brain’s ability to accommodate new functions. Of course, there isn’t anything supernatural or superhuman about that, and your brain can only work with the sensory input it receives. HaloSense V1 provides new information through the senses you already have.

Or, to put it another way, HaloSense V1 is a haptic feedback headset. Through an array of 13 haptic feedback motors, it pulses and buzzes to convey information gathered through sensors connected to an UNO Q. The project is intended to explore whether, over time, a wearer can learn to interpret the haptic patterns as information.

Best in Robotics

We’re in the midst of a shift in robotics towards human-friendly designs. Mohammed Akramuddin’s Curie is engineered to be as friendly as it gets. This little desktop robot is cute, with facial expressions displayed on an OLED screen. The creator designed it to help users, including those with ADHD, manage tasks. 

Like all of the other projects in this competition, Curie contains an UNO Q board. It connects to various APIs, including Groq (a cloud interface that is built to let developers run open-source artificial intelligence models at high speeds), to help its owner manage their workload. It is designed to do that in the usual digital assistant ways, by taking notes and setting reminders, but also by providing more tailored assistance. It can, for example, break a complex task up into small pieces that are more approachable. It is also designed to identify potential distraction and provide a nudge to help users return to their task.

Best in Show

The Best in Show award went to the overall competition winner, regardless of category. The winner was Jorge Eldis González for his work on the Edge-AI Spectrophotometer, which is, as its name indicates, a spectrophotometer that integrates AI on the edge.

A spectrophotometer measures the wavelength of light, in order to detect the properties of sampled materials. That is a non-destructive analysis and can, for instance, tell you if a sample contains contaminants.

The Edge-AI Spectrophotometer is built using commercially available components, using an UNO Q and a SparkFun Electronics AS7343 Triad Spectroscopy Sensor. It then runs a machine learning inference model on the edge, which detects deviations from known baselines. The creator designed the project to make its testing workflow more accessible to less-experienced operators and to explore additional spectrophotometry applications.

Congratulations to all the winners! 

Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. Arduino, UNO, and the Arduino logo are trademarks or registered trademarks of Arduino S.r.l.

The post Inside the winning Arduino® UNO™ Q projects from Hackster’s Invent the Future competition appeared first on Arduino Blog.

There are plenty of “robot” projects out there that are really just a small remote control platform of some sort. We often like to think of robots of having some sort of autonomy though. [Luca Fagioli] demonstrates a great example of this with his explorer robot that uses Simultaneous Localization and Mapping (SLAM) to navigate its environment.

The robot is a built on a small plastic chassis, with one gear motor per drive wheel. Running the show is an Arduino Uno R4 Wi-Fi, paired with the Sensor Shield 5.0 and an L298N motor driver board. There’s also an HC-SR04 ultrasonic sensor module onboard, mounted atop an SG-90 servo motor so it can be panned around. The ultrasonic sensor determines the range between the robot and surrounding walls, and a map is constructed at the same time as the robot is localizing itself within it. There are also infrared sensors on the bottom of the robot for detecting tape marks on the floor for checkpointing purposes.

Often, SLAM mapping is done with advanced laser rangefinders or time of flight sensors, but there are many ways to go about it as this project demonstrates. We’ve even seen it done in a distributed manner with coordinated drones combining their efforts. Overall, it’s a highly useful technique for robot navigation and wayfinding.

• Read more about Pac-Man, Space Invaders and Manic Miner Run on a Plain Arduino Uno at 50 fps, With Two Resistors for Video and No Framebuffer
• Add new comment

• Read more about Arduino's 16 GB VENTUNO Q Runs a 744-Billion-Parameter AI Model From an SSD, and It Took 7 Minutes to Name Three Planets
• Add new comment

JBR-001 is an open source desktop robot that sees and recognizes the objects in front of it, then reacts with movements, sounds and animations. It was created by syntheticAIdata and built around the Arduino UNO Q 2GB. Inside there are three servos, a camera, a distance sensor, a buzzer and an animated display. So it is not yet another blinking ornament: it is a platform for experimenting with robotics, computer vision and edge AI on a workbench.

Assembly starts from a body of 3D-printable parts that house the board and the rest of the electronics. The head contains the camera, mounted so that it looks straight ahead of the robot. On the back of the same head sits a Modulino Distance, which continuously measures the distance to nearby objects. The arms and the rotation of the head, on the other hand, come from three servos. The mechanics are therefore easy to replicate for anyone who already has a 3D printer at home.

Servo pins and distance thresholds in the code

The three servos split the tasks: one rotates the head, the other two control the arms. In the code the pins are HEAD_SERVO_PIN = 9, LEFT_ARM_SERVO_PIN = 10 and RIGHT_ARM_SERVO_PIN = 11. The rest positions are all at 90 degrees, so HEAD_CENTER = 90, LEFT_ARM_CENTER = 90 and RIGHT_ARM_CENTER = 90. The servos also use a separate external power supply instead of drawing power from the UNO Q: a forced choice when three motors start at the same time.

The distance sensor decides when the robot should notice someone. In the code the detection threshold is DETECTION_DISTANCE = 200.0, while the reset one is RESET_DISTANCE = 250.0. The units are not specified in the project material, so they should be checked on the bench before trusting them. The margin between the two thresholds prevents the robot from switching on and off continuously when someone stays right on the boundary.

Heartbeat on the display, a greeting in notes and the vision model

The robot’s responses go through three different channels. The LED matrix display is driven with bitmaps of 8 rows by 13 columns, the two used for the small and large heart. In the heartbeat animation the delays are 120, 100, 160 and 700 milliseconds, and the last long gap gives the sense of the pause between one beat and the next. The sound greeting playHello instead uses the notes 523 Hz (C5), 659 Hz (E5), 784 Hz (G5) and 1047 Hz (C6), that is a C major arpeggio rising by one octave.

The most interesting part comes from the camera mounted in the head. It connects through a USB-C hub and gives the robot a front view of its surroundings. The captured images can be processed on the UNO Q with a trained computer vision model: this way JBR-001 does not just understand that something is nearby, but identifies the object and uses the result to decide how to react. Consequently the same hardware can turn its head, move its arms, change the image on the display or play a short sequence.

• Arduino UNO Q 2GB as the robot’s brain
• Modulino Distance for continuous distance measurement
• Modulino Motors for motion control
• Modulino Buzzer for sound sequences
• Arduino USB-C Hub (8 in 1) to connect the camera
• Three servos for head and arms
• Camera mounted in the head
• 3D printer for the body parts

On the software side you need Arduino App Lab and the JBR-001 source code, plus a trained computer vision model for object recognition. The project has 1805 views and 2 respects. Anyone who wants to rebuild it starts here: the maker syntheticAIdata’s site, where the code and the instructions to replicate the build are. For the servos, an RC servo control module simplifies the wiring when the channels to drive grow. The project’s distance sensor is a Modulino, and as an alternative you can consider a ToF laser sensor for close-range measurement. The board everything runs on is the 2GB version, while the catalogue also lists the Arduino UNO Q 4GB in a complete kit: same family, more memory for vision models.

Source: https://projecthub.arduino.cc/syntheticaidata/jbr-001-a-desktop-companion-robot-powered-by-arduino-uno-q-b11c96

Related products

• Arduino shield for RC servo control
• ToF Laser Distance Sensor with VL53L3CX
• Arduino UNO Q 4GB – Complete kit with accessories

The post JBR-001: the open source desktop robot that recognizes objects appeared first on Open Electronics.