How does a flat sheet of material, like plastic or an airtight textile, become an inflatable structure with a three-dimensional shape? The traditional process involves creful design with a lot of trial and error in order to place seams between two or more sheets. That involves a lot of labor, so a team of engineers from the Hasso Plattner Institute developed a new machine called AirTied which can automatically fabricate inflatable structures.
AirTied structures consist of tubular inflatable trusses, which are just flat sheets folded over with the edges welded. Without the machine’s intervention, that material would produce one very long cylinder when inflated. But the AirTied machine can form those tubes into 3D structures by placing knot-like nodes in specific locations, like a clown making balloon animals for kids at a party.
The material comes from a single spool, but AirTied can produce up to five parallel trusses at any time. It accomplishes that by rotating the spool to one of five slots that can either fold the tube or crimp it with a wire tie to create a node. It can, for example, crimp two trusses together in their middles to create an X-shaped structure. The machine controls the lengths of the trusses between nodes by folding each truss over until they’re all ready for crimping.
An Arduino UNO Rev3 board manages that process and the coordination of the motors using a modified version the popular GRBL CNC firmware. That lets it run G-code generated by the AirTied software, which helps users easily and quickly design structures by specifying the lengths of trusses and positions of nodes. The software even estimates the total cost of materials required for a particular structure.
That cost is quite low and the demonstrates the primary advantage of AirTied: its ability to automatically fabricate affordable structures at speed unmatched by other techniques.
A good mural can really capture the identity of a community and it is typically up to an artist to figure out how to accomplish that. But what if every individual in a community could contribute a design that would become a piece of the larger mural? Niklas Roy was able to make that reality with the “Mosaikmaschine.”
To create collaborative pieces of permanent artwork, Roy had to do two things. First, he needed a way to get a small design from every person that wanted to be part of the project. Second, he needed a way to physically paint those designs onto walls.
For the sake of simplicity, Roy decided that each user design would be a single square image with a resolution of 32 by 32 pixels. He then built a portable machine designed to look like an arcade cabinet. That machine has an arcade-style joystick and buttons that residents used to move a cursor and fill in the pixels of their designs. The controls connect through an Arduino board to a laptop that runs the drawing software.
Roy wheeled that machine around the community, letting everyone draw their designs. Once he had a big enough collection, he used a Silhouette Cameo Pro large-format craft cutting machine to fabricate pixelated stencils of the designs. With a stack of stencils in hand, Roy and a team of volunteers were able to spray paint hundreds of designs onto walls around the neighborhood.
Percussion instruments are likely the first kind that humanity invented, because they’re quite simple: hit a thing and a noise happens. Different things produce different frequencies with different timbres, and glass bottles have a nice xylophonic sound to them. Because glass bottles are easy to find among discarded garbage, Jens of the Jens Maker Adventures YouTube channel took advantage of them to build this awesome robotic instrument.
Jens started by collecting a bunch of different bottles. He tapped each to while searching to get a sense of the notes they produced, which he could then lower by adding some water to fine tune the pitch. Once he had enough bottles to cover a range of notes, he set out to construct a robot to play them.
Solenoid actuators tap each bottle and an Arduino UNO Rev3 board controls that tapping. It does so according to MIDI files created in the popular Ableton software. Jens matched the available notes in Ableton to those produced by the glass bottles, so he could simply compose melodies using those notes knowing that the robot could play them. The Arduino reads the MIDI files output by Ableton and strikes the corresponding bottles.
Finally, Jens laser-cut a plywood frame and enclosure that holds the bottles, the Arduino, and the solenoids. It works with seven bottles, which is the number of notes this machine can play.
Jens demonstrated that by playing a guitar along with the robotic instrument and the result sounds very pleasant — especially for something made with garbage.
Integrating electronic components into textiles is usually a challenge, as they are rigid and most textile applications require flexibility. But new materials and fabrication processes are changing that dynamic. FashionTech designer Anouk Wipprecht and Chromatic 3D Materials were able to take advantage of those to develop this futuristic, motion-activated dress illuminated by embedded LEDs and circuitry.
75 soft, flexible domes cover the body of the dress. Those contain LEDs and light up in response to people around it. And unlike similar designs, this garment is able to conform to the wearer thanks to the use of innovative new materials.
The most notable of those materials is Chromatic’s ChromaFlow 70, which is a type of polyurethane resin meant for Reactive Deposition Modeling (RDM) 3D printing. The RDM process combines the benefits of conventional resin 3D printing with Fused Deposition Modeling (FDM) by extruding layers of viscous resin that are immediately cured. ChromaFlow 70 is very strong and flexible, making it perfect for this application. And RDM is the ideal process, as it is possible to print directly onto the underlying textile while pausing to allow for placement of the electronic components.
The illumination comes from Adafruit Flora RGB NeoPixel V2 LEDs, controlled by an Arduino UNO R4 and Nano board. Those are able to detect movement via a proximity sensor.
Wipprecht and Chromatic 3D created this stunning dress for the Formnext convention in Frankfurt, Germany, where it will be on display from November 7th to November 10th in Hall 12.1.
Hospitality professionals are constantly looking for ways to offer guests an enhanced experience while improving operational efficiency and optimizing energy management. To achieve this, they require cost-effective solutions that are easy to install and maintain while also providing the scalability of future-ready systems – such as automating hotel rooms or B&B rentals to increase safety, comfort, and energy savings.
Indeed, automation can be integrated seamlessly in various aspects including climate control, lighting, security, and entertainment. Upgrading these functions allows guests to enjoy customization and convenience throughout their stay, and staff to efficiently manage room settings remotely. Moreover, hoteliers can achieve substantial energy savings through optimized control and scheduling, contributing to sustainability goals.
Long-term scalability and future-proofing of automation systems, however, can be an issue. As hotels and rental properties undergo renovations or expansions, the ideal solution should accommodate changes without requiring substantial modifications or replacements. Adopting open and standardized protocols, as well as selecting flexible and modular automation projects, can help mitigate these challenges and provide a foundation for future enhancements.
Our solution
A comprehensive IoT automation solution can address these challenges effectively by aggregating sensor and user data and then intelligently managing lighting, cooling/heating and more – for a smart, connected experience. The elements required to achieve this kind of outcome are environmental sensors, a programmable logic controller (PLC), a human-machine interface (HMI), and cloud connectivity.
Programmable logic controller (PLC)
PLC-based automation systems are widely used due to their reliability, flexibility, and ability to handle complex tasks. Arduino Pro’s Opta microPLC can serve as the central control unit for hotel room automation by connecting and monitoring various devices and subsystems such as HVAC (heating, ventilation, and air conditioning), lighting, and door locks. The microPLC receives data from sensors and users and processes them to trigger appropriate actions or adjustments in the room.
Human-machine interface (HMI)
A touchscreen panel through which guests and staff can control various room parameters – such as lighting status, fan status, and door lock status – provides a user-friendly and intuitive interface to interact with the automation system. This HMI also communicates data to the microPLC for execution.
The Modbus communication protocol
The HMI and Opta PLC communicate via Modbus RTU over RS-485. Modbus RTU communication protocol is widely adopted in industrial applications due to its reliability, provided by the physical layer strength and by the cyclic redundancy check included in the data packets. It allows for multiple devices to be connected to the same bus, forming a multidrop network where each device has a unique address, used to identify the recipient of the transmitted data. The Arduino Opta can communicate with other Modbus devices, such as sensors, actuators, or traditional PLCs, by addressing them individually.
IoT Cloud solution
Cloud connectivity enables seamless communication between the hotel room or rental property’s automation system and the central management system. The Opta and HMI connect to the cloud infrastructure, allowing remote access, monitoring, and control of multiple locations. The solution also enables data logging and analytics for better energy management, predictive maintenance, and guest experience personalization.
Solving it with Arduino Pro
Let’s get into the details of how this solution can be put into action, and identify the hardware and software resources needed for deployment. Arduino Opta is a great option for deploying building automation solutions, as it offers simple integration with current systems, real-time control capabilities, support for Over-The-Air (OTA) firmware updates, and hardware-to-cloud data security. The Arduino Pro ecosystem allows users to benefit from easy integration, along with a range of scalable, secure, and professionally supported services.
The Arduino IDE 2.0 can be used to program Opta using C/C++. Opta acts as the main controller, communicating with the HMI via the Modbus RTU protocol. The HMI gathers data from various sensors – including light, temperature and humidity, and PIR (movement sensor) – as well as user inputs from its interface buttons related to room climate, lights, and door lock status. It then forwards this data to Opta, which controls the relay outputs that will activate the lights, thermostat or door lock.
Opta also sends this data via Wi-Fi® to the Arduino IoT Cloud. After connecting it to the Arduino Cloud using the Arduino Create Agent, cloud variables corresponding to the sensor data being monitored can be defined.
Arduino Pro’s Opta microPLC offers an ideal solution for the automation of hotel rooms and B&Bs or rental properties. By leveraging standard communication protocols, easy integration, real-time control capabilities, secure hardware-to-cloud data exchange, and remote access to multiple rooms from a centralized location, Opta provides the cornerstone of a comprehensive platform for smart hospitality.
You don’t need to go back more than a century to find people who carried the job title “scientist” without any qualifiers. But as STEM fields advanced, people had to become increasingly specialized in more niche disciplines. In recent years, however, we’ve seen a bit of a reversal in that trend and modern occupations often require interdisciplinary knowledge. To foster such knowledge, the open-source SPEERLoom encourages interdisciplinary learning.
Created by a team of researchers from Carnegie Mellon University and UC Irvine, the SPEERLoom is an open-source robotic Jacquard loom kit that, after assembly, can produce complex textile weaves. Looms like this certainly have practical applications in the textile industry, but SPEERLoom’s true purpose is educational. By building a SPEERLoom and learning the skills to operate it, students can develop ingrained knowledge and experience that crosses the boundaries of traditional disciplines to yield a well-rounded STEM base.
To encourage that education, SPEERLoom’s designers wanted the machine to be accessible and affordable for classroom environments. Most of the machine’s parts are available off-the-shelf and the custom parts can be fabricated using basic tools and 3D-printing.
Jacquard looms are complex machines with many moving parts, but the accessible design extends to the electronic components and actuators. SPEERLoom requires 40 linear actuators and an Arduino Mega 2560 board controls those through MCP23017 I2C port expanders and 40 EasyDriver modules. A custom GUI written in Python lets users send weave patterns, stored as CSV files, to the Arduino to get the process started.
For well over one hundred years, people have been constructing machines that dispense fortunes to those who ask at the insertion of a coin and the push of a button. In modern days, this has taken the form of mobile apps that can be far more expansive, albeit with a lack of physical interaction. Seeing an opportunity to use an embedded speech recognition model in this kind of application, the Electronic Cats team built the aptly named Fortune Cat just in time for some Halloween fun.
This small device, based on the Arduino Nano 33 BLE Sense, takes advantage of the onboard microphone to listen for words being spoken at the small cube. Performing the language processing is Cyberon’s Arduino Speech Recognition Engine, which was configured to listen for the wake phrase “Fortune Cat” and then later respond to “tell me my future” as its command phrase. After generating the model online, it was incorporated into the code via the DSpotter software development kit that lets the program check if either the wake or action phrase has been said and then act accordingly.
In this case, asking Fortune Cat for your future will present one of 20 random phrases that get displayed on the OLED mounted to the top of the 3D-printed enclosure. To read more about how the Electronic Cats crew created and configured Fortune Cat, you can check out their write-up here on Hackster.io or watch their video below!
The large, bubbling cauldron is a classic mainstay in our Halloween decorations as it evokes imagery of devious witches and their mysterious concoctions. Fed up with this being a mere display piece, element14 Presents’ Katie Dumont created an enchanted cauldron that allows visitors to brew their own digital potions from an array of distinct ingredients using a whimsical “wand” and NFC-tagged bottles.
To test her idea of mixing ingredients, Dumont began by connecting an Adafruit NFC reader to an Arduino UNO Rev3 along with a strip of RGB LEDs. The code she wrote checks which NFC tag is present every second, and depending on the color, will either add another color or increase/decrease the overall brightness. After the special wand tag has been detected, each pixel along the strip is mixed into a shared, uniform color across all of them.
Upon the heels of this successful experiment, Dumont included another layer of interactivity in the form of a small game where players are presented with a certain color and must try to use the potion bottles to replicate it as close as possible with only red, green, and blue inputs. After selecting a sequence of three colors, tapping the wand will display the result and either flash red or white to indicate failure or success, respectively.
To see more about how Dumont designed her cauldron, you can read the build log here and watch her demo video below!
We recently showed you Becky Stern’s recreation of the “computer book” carried by Penny in the Inspector Gadget cartoon, but Stern didn’t stop there. She also built a replica of Penny’s most iconic gadget: her watch. Penny was a trendsetter and rocked that decades before the Apple Watch hit the market. Stern’s replica looks just like the cartoon version and even has some of the same features.
The centerpiece of this project is an Arduino Nicla Voice board. The Arduino team designed that board specifically for speech recognition on the edge, which made it perfect for recognizing Penny’s signature “come in, Brain!” voice command. Stern used Edge Impulse to train an AI to recognize that phrase as a wake word. When the Nicla Voice board hears that, it changes the image on the smart watch screen to a new picture of Brain the dog.
The Nicla Vision board and an Adafruit 1.69″ color IPS TFT screen fit inside a 3D-printed enclosure modeled on Penny’s watch from the cartoon. That even has a clever 3D-printed watch band with links connected by lengths of fresh filament. Power comes from a small lithium battery that also fits inside the enclosure.
This watch and Stern’s computer book will both be part of an Inspector Gadget display put on by Digi-Key at Maker Faire Rome, so you can see it in person if you attend.
As one of YouTube’s most prolific makers, GreatScott! has a lab full of equipment that we love. But a lot of that equipment represents a potential hazard to children and GreatScott! has a newborn at home. Before that baby becomes a curious and ambulatory toddler, he decided to restrict access to his lab with this DIY fingerprint-reading smart lock.
Smart locks are actually trickier than they seem. Some require apps, others run on batteries that need frequent replacement or recharging, and none of them will work with every type of door. GreatScott! wanted something that didn’t require an internet connection, that was easy to open, and that used mains power so that he’d never have to worry about batteries. The only way to get that was by building it.
This relies on a similar electronic catch, which uses an electromagnetic solenoid to pull a pin that disengages the lock. With it, the door can open when the catch has power. For safety reasons, a lock like this may not be suitable for all situations.
GreatScott! had to modify his door and door frame to fit that catch. He then designed a simple control board based on an Arduino Nano board. It toggles a MOSFET to allow power to reach the catch, unlocking it. The Arduino does so when it reads an authorized fingerprint through a small fingerprint scanner.
The final challenge, which GreatScott! is still sorting out, was running power. There isn’t an available outlet nearby, so he is searching for a solution. His partner vetoed a long wire channel, which means that GreatScott! may need to run power wires through the wall. Once he does, he’ll have a smart lock that meets all of his requirements.
Despite overconfident proclamations from high-profile players in the tech and automotive industries, we’re still a long way from fully autonomous self-driving cars. Current prototypes work well under ideal conditions, but are easily thwarted by everyday real world anomalies. Lane keeping, however, is a much more approachable challenge and Computerphile was able add such functionality to an older vehicle.
Many of today’s cars have lane keeping capability and that usually works by looking at the lane lines on the road. Because drive-by-wire is now the norm, the vehicle can steer itself to remain within the lines. That works well on interstates and highways, because it only needs to perform small adjustments without any turns. This DIY lane keeping system works in a slightly different way. It looks at the entire scene in front of the car and uses an AI to determine if it should adjust the steering.
Before continuing, it is worth noting that Computerphile wanted to emphasis that this is not safe for use in the real world. There are too many potential safety issues and it would require extensive testing before it would be responsible to even try it on a public road.
With that in mind, this system’s performance was only simulated. It uses a trained convolutional neural network (CNN) to indicate how the car would steer itself if it had actual control over the steering. Computerphile trained that CNN using a laptop, a webcam, and an Arduino Nano 33 IoT. The computer records video frames while also recording the orientation of the Arduino through its built-in six-axis IMU. With the board attached to the steering wheel, that orientation corresponds to the angle of the steering wheel.
Through the magic of machine learning, the CNN was able to associate types of imagery with steering angles. So it might see a bend in the road and know that that means the steering wheel needs to turn.
As Computerphile shows, this works fairly well. But it is also easily confused. It would take a lot more training data in a larger variety of conditions to produce a reliable system. In theory, however, such a system would be more robust than standard lane keeping systems that look at road lines.
The Inspector Gadget cartoon was, naturally, full of fun gadgets. Even the eponymous inspector’s niece, Penny, got some nifty gizmos. One notable example was her computer book, which was exactly what it sounds like. To pay homage to the classic cartoon, Becky Stern recreated Penny’s computer book using a pair of Arduino boards.
It isn’t clear exactly which functions Penny’s computer book possesses within the canon of the Inspector Gadget cartoon, so Stern got a chance to exercise her own creativity. She referenced the cartoon to get a sense of the device’s aesthetics, design, and some of its capability. That helped her define the look of the replica device and how it should act. She determined that it should have several buttons (including a grid of illuminated buttons), a small screen on one side, and a big screen on the other side — all inside of a book.
Stern used two different boards to bring the device to life: an Arduino Nano ESP32 and a Mega 2560. The former monitors some of the buttons and controls the LCD panel on the left side. The latter monitors the green buttons and controls their LEDs. It also drives the LEDs behind the right “screen,” which is actually a static semi-transparent image. The LEDs light up in sequence to create an effect similar to what we see in the cartoon.
Most of the buttons lack actual functions, but Stern did add some interactivity by utilizing the Nano ESP32. The board hosts a web interface that users can access after connecting to the Wi-Fi network. That interface lets the user select images to show on the left screen, like a video call from Brain the dog, to really sell the visuals.
Today, we are excited to share that Avnet and Arduino announced a global partnership to support equipment manufacturers and machine builders in moving toward a more modular future. The new agreement combines the strength of Avnet’s worldwide embedded design services and distribution support with Arduino’s robust embedded technology ecosystem of hardware and software.
Many of you may already know Avnet as the parent company of Hackster and Element 14. Avnet also includes several significant global technology distributors and solution providers serving individuals and businesses worldwide. Both companies decided to partner after seeing a global trend of professional customers moving towards modular boards over custom chip-down designs to accelerate product development.
The use of Arduino products among professional engineers has grown significantly over the last few years since Arduino PRO was introduced. From workbench prototyping to volume production, business customers report development time drops between 20% and 50% from incorporating Arduino software, firmware libraries, and microcontroller modules. This efficiency increase is one reason we are seeing an encouraging trend among enterprises to adopt open-source embedded technology.
“Design engineers will be able to quickly move from initial prototype and preproduction to high volume designs through Arduino’s open-source software and open hardware design approach,” said Alex Iuorio, senior vice president of Supplier Development at Avnet. “Not every customer has the time, resources, or capability to perform a chip-down design, which often is a manual, hands-on process to design, engineer, prototype, source and produce. Using Arduino’s PRO product line offerings and Avnet’s support will greatly reduce time to market.”
To support the shift to open modular design in product development, Arduino will be offering several engineer evaluation kits exclusively through Avnet. The evaluation kits target use cases in Predictive Maintenance, Environmental Sensing, Robotics, Vision, and Industrial Gateways integrating AI on the edge. Each kit provides a path for businesses to experience the benefits of Arduino in product development for commercial applications.
While there is an emphasis on supporting businesses in adopting open hardware, both companies are committed to creators at every level. We are excited to see what will come as the partnership launches and the developer communities grow together.
Sometimes makers come across products that they’d love to buy, but which are too expensive to justify. When that happens, the natural inclination of the maker is to build a DIY version. Such projects often end up costing way more — in both time and literal currency — than the product would have. But when we get lucky, we can save some money. That’s the case with this spiral clock built by Kelton.
Kelton based this design on the Aspiral Clock. That product was quite expensive at $542 and the company that made it seems to be defunct now anyway. Kelton’s version looks similar and works in the same way, but only requires about $60 in materials.
This clock is a giant spiral and indicates the time with a ball that rolls along the spiral. The entire spiral rotates at a constant speed, causing the ball to move towards the center. Numbers marked along the path show the time. When the ball reaches the center, it drops through a chute that puts it back at the beginning of the spiral. That repeats endlessly in 12-hour cycles.
The electronics are very simple: an Arduino Nano ESP32 board tells a stepper motor to spin at the exact rate that Kelton calculated. That stepper motor turns the spiral, keeping the ball in motion. Because this development board has an ESP32, it would have been possible to connect it to a WiFi network to find the time and keep everything in sync. But Kelton didn’t think that was necessary, so the spiral just rotates at a constant rate.
The real trick with this clock was the woodworking. All of the parts are laser-cut plywood and Kelton made heavy use of kerf cuts. Those break up a length of wood into many segments, so the wood can easily bend. That technique was perfect for creating the smooth spiral path and the result looks fantastic.
We all know that a child’s love can be bought. But how can working class parents compete with the lavish gifts that wealthy parents can afford? The answer is simple: by building toys that aren’t purchasable. Not only will a DIY gift have far more meaning, but it will impart a sense of superiority that comes from the knowledge that other parents can’t simply outspend you. That motivated Firth Fabrications to construct this school bus ride for his toddler.
This resembles one of those coin-operated rides that we used to see in front of every grocery store. The bright yellow wood school bus is big enough for a toddler to sit comfortably inside. When powered on, it begins rocking around on linear actuators. A dashboard inside the school bus gives the “driver” buttons and switches to play with, but they don’t actually move the vehicle. Instead, the linear actuators move according to commands sent by a remote control unit.
The remote looks like a small version of the school bus, which hints at its operation. It monitors its own orientation, then tells the linear actuators to move so that the ride matches. The remote unit contains an Arduino Nano board and an IMU module. It communicates with the Arduino Mega 2560 in the school bus via RF modules. Another Nano handles the dashboard functions, including swinging out the stop sign with a servo motor.
If you live in a nice neighborhood that has a sense of community, you may have come across a Little Free Library. Those are small cabinets filled with books that anyone can take. Ideally, people will also leave books for others. They’re usually situated next to sidewalks where passersby can stumble across them. Hackster.io currently has a contest challenging participants to build such a library dedicated to STEM and this inspired Amitabh Shrivastava to create a payphone that provides speakeasy-like access to his library.
Payphones are rare these days, so its mere existence should garner some attention. Anyone who looks at the payphone will then notice a message imploring them to dial 7836 for “STEM.” If they do so, the payphone will pop open to reveal the library inside. That is, of course, filled with books that can help people expand their knowledge on science, technology, engineering, and math. It adds a fun, interactive layer to the standard Little Free Library, while also demonstrating what a person can achieve with the knowledge within.
Shrivastava started this project with a real payphone that came from a laundromat. He then cracked that open to access the electronics inside and a score of $3.25 in loose change. Shrivastava added an Arduino Nano board to monitor the phone’s keypad and look for the numbers “7836.” If it sees those, it disengages a solenoid lock and the library door can swing open.
A custom cabinet ties the whole project together, providing plenty of space for books and conveying the desired aesthetic. This payphone will make its debut at Maker Faire Bay Area 2023 so you can see it for yourself if you’re heading to Mare Island this weekend or next, and will then inhabit the Avnet HQ building.
Stephen Hawking once said, “No one undertakes research in physics with the intention of winning a prize. It is the joy of discovering something no one knew before.” That joy is exactly what we hope to ignite with Arduino’s Science Kit R3, bridging theory with practical exploration with a complete toolbox that science teachers can use to develop hands-on and engaging STEM experiments in the classroom.
From the relationship between color and temperature to the effects of electrical currents on magnetic fields, the kit provides a comprehensive learning experience that allows students to interact with the very core of scientific investigations – also through real-time data collection and analysis. By measuring, recording, and interpreting data with theArduino Science Journal app, the learning process becomes interactive and dynamic.
So, how does the Science Kit R3 make physics the coolest subject in school?
Enhanced understanding of physics: No more passive reading. Dive deep into physics, understanding complex concepts through hands-on experimentation.
Promotion of scientific literacy: The real-time data collection and analysis features nurture scientific inquiry skills, priming students to thrive in our data-driven world.
User-friendly design: No prior coding or electronics knowledge is required, ensuring educators and students can jump straight into experiments with minimal setup.
Designed for education: The kit has been designed with teachers, for teachers and students.
Critical thinking stimulation: The kit’s design encourages students to apply what they’ve learned to real-world situations, sharpening their problem-solving abilities.
Self-directed learning: Through open-ended investigations, we’re giving students the reins, allowing their curiosity to guide their learning process.
Comprehensive teaching support: The Science Kit R3 isn’t just for students. We’ve also equipped educators with an intuitive guide to streamline the teaching process.
The Eowave Persephone was an interesting ribbon synthesizer that let musicians control frequency by moving their fingers across a long touch sensor. Ben Glover used to own one, but sold it. During shipping to the buyer, it got lost in the mail and so Glover can’t even buy it back. He regretted losing his Eowave Persephone, so he decided to create his own ribbon synthesizer called the Screech Owl.
If you could even find one, buying a used Eowave Persephone today would likely set you back at least a thousand dollars. But the Screech Owl is affordable to build, operates in the same manner, and sounds very similar. Glover is a novice maker and was able to pull of this project by outsourcing much of the work to ChatGPT and vendors on Fiverr.
One part that Glover designed himself was the custom PCB that acts as a shield for an Arduino Leonardo board. The Arduino handles the synthesis according to the input coming from the ribbon. That ribbon is actually two sensors: a SoftPot 500mm-long membrane potentiometer for position and thin film pressure sensor to measure force for aftertouch. Those components fit into a simple but attractive, laser-cut MDF enclosure.
Our exclusive fall offer is here, and it’s packed with incredible savings.
With this promotion, you can enjoy a special 30% discount on the Arduino Cloud Maker yearly plan using the code “CLOUDNANO32.” Plus, when you select any other Arduino Cloud yearly plan (Entry, Maker, or Maker Plus), you can grab a Nano ESP32 for just $1!*
How to redeem the offer:
1. Select your yearly plan: Keep in mind that only the Yearly Maker plan is on sale. If you select the yearly Maker plan, be sure to apply the code “CLOUDNANO32” during checkout to unlock an amazing 30% discount.
2. Activate email notifications: To stay in the loop and receive your invitation for the Nano ESP32 at $1, activate your email notification.
3. Get your Nano ESP32 email invitation: Shortly after completing your Cloud subscription purchase, you will receive a special voucher via email, granting you access to the Nano ESP32 for just $1*.
Whether you’re an experienced IoT developer or a newcomer to the IoT world, this promotion offers something for everyone. Upgrade, save, and take your IoT projects to new heights. Act now before the offer expires on October 27th, 2023.
*To be eligible, you shall not have any active Arduino Cloud paid plan. Please note that the Nano ESP32 offer is exclusively available to the first 300 customers who purchase any Arduino Cloud yearly plan (Entry, Maker, or Maker Plus). Shipping fees and taxes apply. Please refer to our Terms & Conditions.
Xylophones are popular kids’ toys because they’re simple, affordable, and cheery. The name is also fun to say and gives us something to fill in the X spot in alphabet books. But while many of us banged on xylophones as children, few learned how to play them properly. To make such learning unnecessary, Rachad El Moutaouaffiq built this automatic xylophone.
If you listen to the melody in the video, you can hear that this sounds far more pleasant than any toddler smacking their toy xylophone while their parents pretend their ears don’t work. That’s because it is fully computer-controlled. Each bar has its own solenoid that acts as a mallet, for a perfect strike every time. Those operate according to MIDI files, so the automatic xylophone can play any tune.
To gain some experience with electromagnetism, El Moutaouaffiq constructed all of the solenoids himself. Each one consists of a nail, a short length of flexible tube, a couple of washers, and a hand-wound coil of wire.
An Arduino Mega 2560 controls all of the DIY solenoids through bipolar junction transistors (BJTs). It has a sketch that activates the solenoids according to incoming MIDI notes received via serial. Those come from a computer running LMMS MIDI software and are sent through serial by Hairless MIDI. El Moutaouaffiq simply had to define a pin for each MIDI note and connect the proper transistor to each pin.
El Moutaouaffiq hopes to add some AI functionality to send MIDI notes based on sheet music, but that isn’t working yet. For now, the automatic xylophone can play existing MIDI files.
Named Visionary by Gartner for the third year in a row, Elastic is the world’s leading platform for search-powered solutions – and a company we are proud to partner with.
Recently, we collaborated with this data powerhouse on a Portenta H7-based R&D project to provide a simple Elasticsearch client library (written in C++) that runs on Arduino modules. That’s right: you can now communicate with an Elasticsearch server directly from an Arduino board!
Among the many ways we immediately tested this new opportunity, we tried developing an IoT device that sends temperature data captured by sensors every five minutes to Elastic Cloud. This, combined with Elasticsearch’s geo features, could be the first step in building a solution that provides the current average temperature from all sensors 5 km away upon request.
Want to find out more? Here is a simple tutorial with all the details.
Portenta C33
Portenta H7
What’s more, Arduino Pro’s industrial-grade offerings fit in with the entire Arduino ecosystem, which includes Cloud services, countless software libraries and ready-to-use sketches shared by the community, and of course a wide variety of components to meet any need. These include popular products such as the MKR WiFi 1010 and Nano RP2040 boards – veritable cornerstones of the maker movement.
Use case: temperature feedback from multiple IoT devices
We designed a use case for a company that needed to manage multiple IoT devices located in Italy. Each device sends data coming from sensors (e.g. temperature) to Elastic Cloud. Using Elastic Cloud the company can manage any scale of IoT devices, without the need of managing a dedicated infrastructure. Moreover, the company needs to adjust some internal parameters of each device from the average temperature of neighboring devices, in a range of 100 km. This is a typical scenario in control engineering applications.
Using Kibana, the UI available in Elastic Cloud, we can easily create a dashboard to monitor the data coming from all the devices. Since we also have geo-data we can represent this information on a map.
This is a heat map created with different colors representing different temperatures (blue is cold and green, red are hot).
Setup of Elastic Cloud
The first step is to have an account for Elastic Cloud. If you don’t have one you can register for a trial here (no credit card required). Once you login you can create a new deployment, choosing the size of the Elasticsearch instances that you want to use.
Once you have created a deployment, you need to retrieve the endpoint URL and generate an API key of Elasticsearch. You can read this guideline for support on obtaining this information.
Preparing Elasticsearch index
We need to create an index to store the data coming from the Arduino boards. We want to store temperature values, position of the device using geo-location (latitude and longitude), a device identifier name, and a timestamp.
We can create an index “temperature” with the following HTTP request to Elasticsearch:
To send this HTTP request you can use the Dev Tools of Kibana in Elastic Cloud.
We want to store the timestamp of the operation each time a device sends data. This can be done using the ingest pipeline feature of Elasticsearch. An ingest pipeline is an action that Elasticsearch executes before indexing (storing) a document. For instance, a pipeline can assign the value of a specific document field, based on some calculation.
In our case, we just need to store the timestamp and we can create a “set-timestamp” pipeline:
PUT _ingest/pipeline/set-timestamp
{ "description": "sets the timestamp", "processors": [ { "set": { "field": "timestamp", "value": "{{{_ingest.timestamp}}}" } } ]
}
Using this pipeline we can then send data to Elasticsearch as follows:
Here the device-id H7-001 is the name of the Arduino board and location is the geographic point expressed with 12.4923 (longitude) and 41.8903 (latitude), that is the position of the Colosseum in Rome (Italy).
Notice that we did not specify the timestamp value because this is automatically generated using the “set-timestamp” pipeline (specified in the URL as query string).
Geo-distance query
To retrieve the average temperature of the devices distance up to 100 km we can use the following Elasticsearch query:
This query will return an “avg_temp” aggregation field containing the average temperature of all devices within a radius of 100 km.
Usage of the Elasticsearch client for Arduino
It’s finally time to show some Arduino code! Below is a simple sketch that sends a temperature value to Elastic Cloud, gets the average temperature performing a geo-distance query and waits for 30 seconds.
The code reported here is available online in the examples folder of the elastic/elasticsearch-arduino github repository. The sketch uses an elasticsearch_config.h file as follows:
In our example, we used Wi-Fi to connect the Arduino board to the internet.
The WIFI_SECRET_SSID and the WIFI_SECRET_PASS are the name of the SSID network to use and the Wi-Fi password.
The ELASTIC_ENDPOINT is the URL of the Elastic Cloud endpoint, the ELASTIC_PORT is 443 since Elastic Cloud uses TLS (https). The ELASTIC_CLOUD_API_KEY is the API key to be generated in the Elastic Cloud admin interface.
This file also contains other information related to the Arduino device. We have the longitude (DEVICE_GEO_LON) and latitude (DEVICE_GEO_LAT), the ID (DEVICE_ID) and the distance (DEVICE_GEO_DISTANCE) for the geo-query.
After filling all the previous information, we can have a look at the sketch, reported as follows:
#include <ArduinoJson.h>
#include <WiFi.h>
#include <WiFiSSLClient.h>
#include "ESClient.h" #include "elasticsearch_config.h" // WiFi settings
char ssid[] = WIFI_SECRET_SSID;
char pass[] = WIFI_SECRET_PASS; // Elastic settings
char serverAddress[] = ELASTIC_ENDPOINT;
int serverPort = ELASTIC_PORT; WiFiSSLClient wifi; ESClient client = ESClient(wifi, serverAddress, serverPort); int status = WL_IDLE_STATUS; void setup() { Serial.begin(9600); Serial.println("Started"); while (status != WL_CONNECTED) { Serial.print("Attempting to connect to Network named: "); Serial.println(ssid); // Connect to WPA/WPA2 network: status = WiFi.begin(ssid, pass); } // print the SSID of the network you're attached to: Serial.print("SSID: "); Serial.println(WiFi.SSID()); // print your WiFi shield's IP address: IPAddress ip = WiFi.localIP(); Serial.print("IP Address: "); Serial.println(ip); client.setElasticCloudApiKey(ELASTIC_CLOUD_API_KEY);
} void loop() { float temperature; // Set the temperature from a sensor (removing the randomness) temperature = random(10,30) + random(0,100)/100.00; // Prepare the JSON with temperature and geopoint for Elasticsearch StaticJsonDocument<200> doc; doc["temperature"] = temperature; doc["device-id"] = DEVICE_ID; doc["location"]["type"] = "Point"; doc["location"]["coordinates"][0] = DEVICE_GEO_LON; doc["location"]["coordinates"][1] = DEVICE_GEO_LAT; String temp; serializeJson(doc, temp); Serial.println("Sending to Elasticsearch:"); Serial.println(temp); ESResponse indexResult; // Send the temperature to Elastic Cloud indexResult = client.index("temperature", temp, "pipeline=set-timestamp"); DynamicJsonDocument result(1024); deserializeJson(result, indexResult.body); if (result["result"] == "created") { Serial.println("Created with _id: " + result["_id"].as<String>()); } else { Serial.println("Error sending data: " + indexResult.body); } StaticJsonDocument<512> query; query["query"]["bool"]["filter"]["geo_distance"]["distance"] = DEVICE_GEO_DISTANCE; query["query"]["bool"]["filter"]["geo_distance"]["location"][0] = DEVICE_GEO_LON; query["query"]["bool"]["filter"]["geo_distance"]["location"][1] = DEVICE_GEO_LAT; query["aggs"]["avg_temp"]["avg"]["field"] = "temperature"; query["size"] = 0; String search; serializeJson(query, search); Serial.println("Geo-location query:"); Serial.println(search); ESResponse searchResult; // Send the temperature to Elastic Cloud searchResult = client.search("temperature", search); DynamicJsonDocument avg(512); deserializeJson(avg, searchResult.body); float avgTemp = avg["aggregations"]["avg_temp"]["value"]; int numDevices = avg["hits"]["total"]["value"]; Serial.println("Average temperature of " + String(numDevices) + " devices in " + DEVICE_GEO_DISTANCE + ": " + String(avgTemp)); Serial.println("Wait 30 seconds"); delay(30000);
}
This sketch requires Wi-Fi, WiFiSSLClient (for connecting using TLS) for the internet connection, the EsClient for connecting to Elasticsearch and the ArduinoJson library for serializing and deserializing Json data structure.
In the setup() function we start the Wi-Fi connection and we set the API key of Elastic Cloud using client.setElasticCloudApiKey(ELASTIC_CLOUD_API_KEY) function call. The client object is initialized in the main area passing the Wi-Fi object, the server address (endpoint) and the HTTP port. In the loop() function we have the code that sends the temperature to Elastic Cloud. The temperature here is just a random float number between 10 and 30, typically coming from a sensor attached to the Arduino board. To prepare the document to send to Elasticsearch, we used the ArduinoJson library.
We used the following code to create a “doc” object:
This object is serialized in a JSON string as follows:
String temp;
serializeJson(doc, temp); Finally, the document, stored in the “temp” variable, can be sent to Elasticsearch using the index API, as follows: ESResponse indexResult;
indexResult = client.index("temperature", temp, "pipeline=set-timestamp"); This API adds the “temp” document in the index “temperature” using the “set-timestamp” pipeline. The result is stored in the “indexResult” variable that is a struct type as follows: struct ESResponse { int statusCode; String body;
};
The “statusCode” is the HTTP status code of the response and “body” is the response body. The index operation is successful if the response contains a “result” field with value “created”.
To get the average temperature of the devices within a radius of 100 km, we used the following geo-distance query, expressed using ArduinoJson.
The response of the search contains the average temperature, as an aggregation value. Moreover, we can retrieve the number of devices retrieved by the query using the [‘hits’][‘total’][‘value’] field in the JSON response from Elasticsearch.
Conclusion
Thanks to the collaboration with Arduino, we developed a very simple library that allows the usage of Elasticsearch directly from an Arduino board. In a few lines of code we can send data to Elasticsearch and execute complex elaborations, using geolocation and more.
We can’t wait to see what Arduino users will come up with, using Elasticsearch! For instance, if you are interested in generative AI you will certainly enjoy Elastic’s newest features. Give Elastic Cloud and the elasticsearch-arduino library a try!
One of the many realities of living with cerebral palsy is limited upper body dexterity, as almost every activity requires the help of a caregiver. That includes something that most of us take for granted: drinking water. To restore at least that little bit of independence, Rice University engineering students Thomas Kutcher and Rafe Neathery designed the RoboCup.
A typical solution for letting people with cerebral palsy drink without assistance is a “giraffe bottle.” That is a water bottle with a long gooseneck straw that extends in front of the user’s mouth. But while that does give them the ability to drink on their own, it is obtrusive and leaves a bulky straw in front of their face. RoboCup eliminates that issue by rotating the straw out of the way when it isn’t in use. To take a drink, the user just needs to push a button or move their finger over a sensor. The straw will then rotate back over to their mouth.
The best part is that RoboCup is open source, so anyone with a 3D printer and some basic skill with electronics can build one for around $100. The key component is an Arduino Nano board. It monitors the tactical button or distance sensor (whichever is appropriate for the user’s capability) and controls a servo motor that rotates the straw. Power comes from a small rechargeable battery and all of the components, aside from the 3D-printed parts, are off-the-shelf and readily available.
Um dir ein optimales Erlebnis zu bieten, verwenden wir Technologien wie Cookies, um Geräteinformationen zu speichern und/oder darauf zuzugreifen. Wenn du diesen Technologien zustimmst, können wir Daten wie das Surfverhalten oder eindeutige IDs auf dieser Website verarbeiten. Wenn du deine Einwillligung nicht erteilst oder zurückziehst, können bestimmte Merkmale und Funktionen beeinträchtigt werden.
Funktional
Immer aktiv
Die technische Speicherung oder der Zugang ist unbedingt erforderlich für den rechtmäßigen Zweck, die Nutzung eines bestimmten Dienstes zu ermöglichen, der vom Teilnehmer oder Nutzer ausdrücklich gewünscht wird, oder für den alleinigen Zweck, die Übertragung einer Nachricht über ein elektronisches Kommunikationsnetz durchzuführen.
Vorlieben
Die technische Speicherung oder der Zugriff ist für den rechtmäßigen Zweck der Speicherung von Präferenzen erforderlich, die nicht vom Abonnenten oder Benutzer angefordert wurden.
Statistiken
Die technische Speicherung oder der Zugriff, der ausschließlich zu statistischen Zwecken erfolgt.Die technische Speicherung oder der Zugriff, der ausschließlich zu anonymen statistischen Zwecken verwendet wird. Ohne eine Vorladung, die freiwillige Zustimmung deines Internetdienstanbieters oder zusätzliche Aufzeichnungen von Dritten können die zu diesem Zweck gespeicherten oder abgerufenen Informationen allein in der Regel nicht dazu verwendet werden, dich zu identifizieren.
Marketing
Die technische Speicherung oder der Zugriff ist erforderlich, um Nutzerprofile zu erstellen, um Werbung zu versenden oder um den Nutzer auf einer Website oder über mehrere Websites hinweg zu ähnlichen Marketingzwecken zu verfolgen.
