Schlagwort: Portenta

  • Prototype faster and smarter in 2025: Meet the Arduino Pro Portenta Proto Kit

    Prototype faster and smarter in 2025: Meet the Arduino Pro Portenta Proto Kit

    Reading Time: 3 minutes

    Launching today at CES 2025, the Arduino Pro Portenta Proto Kit is here to revolutionize how professionals approach prototyping. Designed to empower engineers, designers, and innovators from all walks of life, this kit provides everything you need to turn your ideas into functional prototypes quickly, efficiently, and without conventional limitations.

    Available in two variants – Portenta Proto Kit ME (Motion Environment) and VE (Vision Environment, available later this month) – the kit equips you with advanced tools to tackle any challenge, from environmental sensing to machine vision to vibration detection, accelerating the prototyping phase from weeks to days and days to hours. Whether you’re developing predictive maintenance systems or high-speed test rigs, the flexible and comprehensive Portenta Proto Kit has you covered.

    What’s inside the Portenta Proto Kit?

    At the heart of the kit is the powerful Portenta H7, paired with the versatile Portenta Mid Carrier. These components support advanced processing and edge machine learning, ensuring your prototypes are as future-ready as they are functional. 

    The kit also includes the full set of our innovative Modulino nodes for rapid sensing and actuation, 4G GNSS Module Global for connectivity, and an Arduino Cloud for Business Voucher for your first three months of seamless cloud integration – so you can store, display, and analyze data remotely. 

    Depending on your chosen configuration, you’ll also find everything you need for motion, vision, and environmental sensing in one kit:

    You’ll easily integrate all of these hardware tools with the new Proto Shield included, and leverage the Arduino IDE on the software side to develop quick, scalable, IoT-enabled prototypes.

    Go from concept to reality in a wide range of applications

    The Arduino Pro Portenta Proto Kit is suitable for many industries and countless applications: the kit’s modular design means you can tailor your prototypes to meet specific requirements, ensuring your projects are always on track. What’s more, you’ll often be able to transition from prototyping to production with no redesigns required.

    Here are some ideas you could explore:

    • Predictive maintenance: reduce downtime and monitor machinery health, using advanced Nicla sensors and cloud-based predictive algorithms.
    • Environmental monitoring: precisely track air quality, noise, and other parameters for real-time decision-making.
    • Machine vision: implement object recognition, motion detection, and people counting using Nicla Vision.
    • Logistics tracking: monitor goods in transit with environmental data and cloud-enabled location tracking.
    • Intruder detection: use motion and face recognition for security monitoring, with cloud-based real-time alerts.
    • EV charging station: create a prototype for efficient, remotely managed charging with data analytics.
    • High-speed test rigs: build scalable test benches for automated sensor calibration, load testing, and real-time data analysis.

    As always, we are curious to find out what the Arduino professional community will come up with next! 

    Learn and innovate with the ACE-220 course

    Ready to hit the ground running? Enroll in ACE-220: Portenta Proto Kit Certification Course on Arduino Academy. This 8-hour professional program is designed to provide embedded engineers, hardware designers, and firmware developers with hands-on modules that cover everything from hardware and software setup to cloud integration. By dedicating a few hours to the ACE-220 course, you’ll gain the expertise to leverage the kit’s capabilities fully, saving significant time and effort in your prototyping process and accelerating your path to innovation.

    Get started on your greatest idea now!

    Whether you’re building the next big thing in automation, smart cities, or IoT, the Arduino Pro Portenta Proto Kit offers the tools to make it happen. Explore the full kit online and take the first step toward redefining what’s possible in prototyping.

    The post Prototype faster and smarter in 2025: Meet the Arduino Pro Portenta Proto Kit appeared first on Arduino Blog.

    Website: LINK

  • Discover #Virgil: history comes to life with Arduino

    Discover #Virgil: history comes to life with Arduino

    Reading Time: 2 minutes

    We’re excited to introduce #Virgil, an innovative project that combines the power of Arduino technology with a passion for history, creating a groundbreaking interactive experience for museums

    Using Arduino’s versatile and scalable ecosystem, #Virgil operates completely offline, allowing visitors to interact with 3D avatars in a seamless and immersive way. The project brings the past to life, offering dialogue-driven encounters with key historical figures thanks to voice recognition and edge AI – with the option to choose among many different languages.

    “#Virgil is meant to celebrate the past and, more importantly, open new avenues for education and inspiration. We want to prove how technology, when guided by ethical values, can amplify and perpetuate our cultural heritage in ways that used to be unimaginable,” comments Enrico Benevenuta, coordinator of the Territori Svelati project and AI expert.

    [youtube https://www.youtube.com/watch?v=hQBPIePZDMs?feature=oembed&w=500&h=281]

    Matteo Olivetti, great-grandson of Olivetti’s founder Camillo, drew inspiration from the iconic Divisumma to design a dedicated hardware setup, Olivox. 

    Powered by the Portenta X8 and Max Carrier, the device connects via HDMI to any screen, engaging visitors in a rich, interactive experience without the need for smartphones or a stable internet connection. This approach allows the project to adapt easily to different exhibitions and contexts, while offering full control over the visitor experience.

    Internationally renowned 3D artist Elvis Morelli was entrusted with creating the first avatar of the project – and it’s no coincidence that Camillo Olivetti was chosen. 

    The story of Olivetti resonates deeply with Arduino’s own mission of pushing the boundaries of technology, and #Virgil represents a continuation of that legacy by bridging the gap between the past and future through cutting-edge tools.

    To find out more about the project and perhaps have a chat with your favorite pioneer of technology and innovation, visit #Virgil’s booth at the upcoming 2024 Maker Faire Rome, booth E.09. Don’t forget to stop by Arduino’s booth N.07 to find out more about our products, and let us know what you asked Camillo!

    The post Discover #Virgil: history comes to life with Arduino appeared first on Arduino Blog.

    Website: LINK

  • Reduce power consumption in IoT and wearable devices, with Arduino’s new power management library!

    Reduce power consumption in IoT and wearable devices, with Arduino’s new power management library!

    Reading Time: 7 minutes

    Developing energy-efficient IoT and wearable devices is complex and time-consuming, yet it is essential for creating high-quality products that stand out in today’s market. A key part in this process is optimizing power consumption without sacrificing performance or functionality. Fortunately, Arduino Pro modules help address this challenge by offering powerful chips and efficient regulators, enabling developers to fine-tune power settings and maximize efficiency for their specific needs.

    To further support these efforts, we’re excited to introduce a powerful new power management library designed specifically for Arduino Pro modules. The currently supported models are Arduino Portenta H7, Portenta C33, and Nicla Vision. With this library, you can easily monitor battery usage and health, fine-tune charging parameters, toggle components to reduce power consumption, and even enable sleep and standby modes on supported devices. In fact, when in deep sleep mode, some boards consume under 100 microamperes, enabling months or even years of continuous runtime on a single charge.

    Ready to optimize your IoT and wearable devices? Keep reading to learn how our new power management library for Arduino Pro modules can help you extend battery life and boost efficiency. Discover the tools to take control of your device’s power usage and try it for yourself!

    Watt’s in store: key features you’ll love

    Here are some of the standout features that will help you maximize efficiency and extend battery life:

    • Battery monitoring: Keep track of vital battery metrics, including voltage, current, percentage, and temperature, in real-time.
    • Battery health tracking: Monitor battery health with detailed insights into temperature, and reported capacity.
    • Charging control: Take charge of your device’s battery management by monitoring and adjusting charging parameters.
    • Sleep and Standby modes: Save significant power by putting Portenta C33 or Portenta H7 into low-power Sleep and Standby modes. Support for Nicla Vision will be added in an upcoming update.
    • Power rail control: Fine-tune power usage by toggling and setting voltages on various power rails of the board.

    Juice it up: monitor battery health like a pro

    Managing your device’s battery health has never been easier. With the dedicated battery management class, you gain real-time insights into your battery’s usage and health, empowering you to optimize energy efficiency and prolong battery life. This powerful tool lets you track essential metrics such as current and average voltage, battery percentage, current draw, temperature, and even provides estimates for time-to-full and time-to-empty, allowing you to predict charging and discharging times with accuracy. By keeping a close eye on these parameters, you can make informed decisions to maximize your device’s performance and longevity.

    Monitoring battery health is crucial for ensuring the long-term reliability and efficiency of your devices. Poor battery health can lead to reduced performance, shorter runtimes, and even unexpected shutdowns, which can negatively impact user experience. By proactively tracking battery metrics, you can identify potential issues before they become critical, extend the lifespan of your batteries, and maintain optimal energy usage – whether your device is in constant use or running intermittently over long periods. Staying on top of battery health means fewer disruptions, lower maintenance costs, and more sustainable, high-performing products.

    These features are fully supported on the Arduino Portenta H7, Portenta C33, and Nicla Vision. Ready to put them to the test? Dive into our example sketch.

    Full charge ahead! Optimize battery lifespan

    Charging your LiPo battery effectively is key to maintaining long-term health and maximizing runtime. The power management library gives you control over your battery’s charging process by monitoring each stage and allowing you to adjust crucial parameters to suit your specific needs. With this tool, you can confidently charge your devices, knowing you’re getting the most out of your batteries without risking damage or reduced lifespan.

    The three stages of charging

    LiPo batteries charge in three stages, each critical for ensuring the battery is properly and safely charged:

    Pre-Charge: The first phase begins by charging the battery at a low current, gradually increasing until it reaches the appropriate charging level. This gentle start ensures that the battery is brought up to full charge safely.

    Constant Current: In this stage, the battery charges at a consistent current until it reaches the designated “fully charged” voltage – typically 4.2 V for most LiPo batteries. This is where the bulk of the charging occurs.

    Constant Voltage: Once the battery hits its target voltage, it transitions to constant voltage mode, where the current is gradually reduced. This final stage ensures that the battery is topped off and ready to go without overcharging.

    Understanding these stages helps you manage your battery more effectively and ensures optimal charging every time.

    Why monitoring matters

    The library allows you to check what stage of charging your battery is in at any time. Knowing whether your battery is pre-charging, fast-charging, or maintaining its full charge can help you monitor its health and ensure it is not being overstressed. The ability to monitor charging status also alerts you to potential issues like overvoltage, overheating, or timer faults, so you can intervene and protect your system before any damage occurs.

    By giving you control over parameters such as charge voltage, charge current, and end-of-charge current, the library ensures that your battery is charged in the safest and most efficient manner possible. Whether you’re tweaking the current limit for a more gentle charge or adjusting the voltage for a custom battery, these settings help you get the best performance while extending battery life.

    With this level of control, you’ll be able to keep your batteries healthy, your devices powered, and your projects running smoothly.

    You can explore these advanced features on the Arduino Portenta H7, Portenta C33, and Nicla Vision. Try them out today with our example sketch.

    Powering down, saving up: discover power-saving modes for longer life

    With modern IoT devices, power efficiency is critical, especially when running on battery for extended periods. That’s where sleep modes come in. The Renesas and ST chips supported by this library feature two essential low-power states – Sleep and Standby – each optimized to help you manage power consumption without sacrificing functionality. 

    Whether you’re developing an energy-conscious wearable or a long-lasting sensor network, these modes help you strike the perfect balance between performance and efficiency.

    Sleep mode: ready when you are

    In Sleep mode, your module significantly reduces its power consumption to about half of its normal usage. The best part? When it wakes up, it resumes execution right where it left off. This makes Sleep mode ideal for applications that need to remain responsive while conserving energy. Wake-up triggers can vary depending on your specific board, allowing you to customize how and when your device springs back to life.

    Standby mode: for maximum power saving

    Standby mode takes energy conservation to the next level, dropping power consumption to as low as 50 uA to 300 uA when peripherals are turned off. This mode is perfect for long-term, battery-dependent applications where energy use is a major concern. Unlike Sleep mode, Standby resets the board upon waking, triggering the setup() function again. This full reset is well-suited for scenarios where occasional wake-ups are acceptable, such as data logging or remote monitoring.

    Fine-tuning your sleep strategy

    Both the Portenta H7 and Portenta C33 offer flexible wake-up options. You can use a real-time clock alarm for scheduled wake-ups or external stimuli such as sensor input to trigger activity. On the Portenta C33, multiple pins can be configured as wake-up sources, allowing you to seamlessly integrate peripherals like motion sensors or buttons to bring your board out of sleep.

    For even more control, toggle your peripherals on and off as needed, ensuring that features like the ADC, RGB LED, Secure Element, Wi-Fi®, and Bluetooth® are only active when required. This granular level of power management means you can tailor your device’s behavior to its environment, making sure energy isn’t wasted.

    In both sleep modes, managing your wake-up sources, peripherals, and configurations can significantly extend your device’s battery life, making it a key factor in creating sustainable, long-lasting IoT solutions.

    Mbed and Portenta H7: automated efficiency

    On Mbed-enabled STM32-based boards like the Portenta H7 and Nicla Vision, sleep management is automatic. The system enters a sleep-like state during idle periods, but you can enhance this by manually managing sleep locks – peripherals or processes that might prevent the module from sleeping. Unlocking these will ensure your board sleeps whenever possible, maximizing efficiency without compromising essential tasks. Check out this example from the underlying Arduino_LowPowerPortentaH7 library for more information about sleep locks. 

    Power consumption comparison

    To give you a clear idea of how power consumption varies across different Arduino Portenta modules, here is a breakdown of current usage with and without power optimizations. This table highlights how effectively sleep modes and peripheral management can reduce power draw, helping you extend battery life in your projects.

    Arduino Portenta C33 Arduino Portenta H7 Lite Arduino Portenta H7
    Without power optimizations 41.37 mA 123.86 mA 123.86 mA
    Standby consumption with peripherals off 58.99 uA 75.51 uA 379 uA
    Standby consumption with peripherals on 11.53 mA 4.89 mA 7.98 mA
    Sleep consumption with peripherals off 7.02 mA N/A N/A
    Sleep consumption with peripherals on 18.26 mA N/A N/A

    Note: Sleep measurements are not available on the Portenta H7 modules because they go to sleep automatically when idling.

    Note: These measurements have been taken using a Nordic Power Profiler Kit II through the JST power connector of the Portenta boards. The numbers might be higher when powering through the VIN or 5V pin because it involves more power regulators that are not as efficient as the PF1550’s integrated regulators.

    Conclusion

    Efficient power management is key to unlocking the full potential of your Arduino Pro projects! With advanced tools like customizable sleep modes, detailed battery monitoring, and flexible peripheral control, you can significantly extend battery life and optimize energy usage across your devices. Whether you’re working with the Portenta H7, Portenta C33, or Nicla Vision, these features allow you to create smarter, more sustainable IoT and wearable solutions that stand the test of time

    Now it’s your turn to put these powerful features to work: elevate your designs, reduce energy consumption, and build products that last longer and perform better. And don’t forget to share your results on Project Hub or the Arduino Forum!

    The post Reduce power consumption in IoT and wearable devices, with Arduino’s new power management library! appeared first on Arduino Blog.

    Website: LINK

  • Detecting rooftop ice buildup using an Arduino Portenta and synthetic data

    Detecting rooftop ice buildup using an Arduino Portenta and synthetic data

    Reading Time: 2 minutes

    In areas that experience plenty of cold weather, icicles and ice dams can present a very real danger to the people and property nearby. In response, Eivind Holt has developed a computer vision-based system that relies on an Arduino Portenta H7, a Portenta Vision Shield, and a slew of AI tools/models to recognize this ice buildup. Best of all, the board’s low power consumption and LoRaWAN connectivity means it can be deployed almost anywhere outdoors.

    Before a model can be created, it needs copious amounts of training, data which normally comes from manually-annotated, real images. But recent advancements have allowed for synthetic datasets to be used instead, such as with NVIDIA’s Omniverse Replicator. It was in here that Holt programmatically added a virtual house and randomized icicle models, as well as configured Omniverse to move the camera around a raytraced scene in order to snap virtual pictures and annotate them with the correct label.

    Once the realistic, synthetic data had been created, Holt exported everything to Edge Impulse and trained an object detection model for the Portenta H7, although it was also tested in NVIDIA’s Isaac Sim environment via the Edge Impulse extension prior to deployment. Alert generation was achieved by connecting the LoRaWAN radio to The Things Stack and sending a small, binary payload every ten seconds if any icicles were detected.

    More information about this project can be found in its Edge Impulse write-up.

    The post Detecting rooftop ice buildup using an Arduino Portenta and synthetic data appeared first on Arduino Blog.

    Website: LINK

  • The new Arduino Pro 4G Module and Portenta Mid Carrier expand our ecosystem, and your options!

    The new Arduino Pro 4G Module and Portenta Mid Carrier expand our ecosystem, and your options!

    Reading Time: 2 minutes

    Our team at Embedded World (April 9th-11th in Nuremberg) has announced not one, but two groundbreaking additions to the Arduino Pro range that are ready to elevate your prototyping and connectivity experiences. Say hello to the Arduino Portenta Mid Carrier and the Arduino Pro 4G Module!

    Portenta Mid Carrier: maximizing prototyping potential

    This ultimate companion to the Portenta boards family is your gateway to seamless prototyping and expanded connectivity, designed to grant you zero hassles and maximum efficiency.

    From CAN lines to Ethernet, microSD, USB, camera interfaces, and more, it allows you to effortlessly tap into high-density signals through dedicated headers. Plus, debug pins and the RTC battery backup will simplify your development journey even more.

    Compatible with Portenta C33, Portenta H7, and Portenta X8, it adapts to your evolving development needs with ease. Whether you’re delving into machine vision prototyping or testing cellular connectivity, this is the carrier for you. 

    Find out more from the dedicated page, or head straight to the store.

    Arduino Pro 4G Module: revolutionizing connectivity

    Are you ready to revolutionize your connectivity game? Engineered to seamlessly integrate with the Portenta family, the Arduino Pro 4G Module comes with a plethora of benefits, ensuring your projects thrive with lightning-fast data throughput and high bandwidths, powered by a robust Cat.4 modem from Quectel. 

    Enjoy secure data transfer, long-range global coverage even in the most isolated locations, and cost-efficient flexibility – all in the widely adopted Mini PCIe form factor: from remote maintenance to building safety inspection, the possibilities are endless. 

    The full details are available on our website, but you can also jump right to purchase from the Arduino Store!

    Embark on your journey of innovation with Arduino’s expanding ecosystem

    Our end-to-end ecosystem of hardware, software, and cloud solutions keeps expanding to meet your needs. The Portenta Mid Carrier and Arduino Pro 4G Module are only the latest additions that promise to unlock new realms of creativity and innovation for seasoned developers and passionate hobbyists alike.

    So, what are you waiting for? Dive into a world of seamless prototyping and unparalleled connectivity today, with the Portenta Mid Carrier and Arduino Pro 4G Module.

    The post The new Arduino Pro 4G Module and Portenta Mid Carrier expand our ecosystem, and your options! appeared first on Arduino Blog.

    Website: LINK

  • Empowering the transportation of the future, with the Ohio State Buckeye Solar Racing Team

    Empowering the transportation of the future, with the Ohio State Buckeye Solar Racing Team

    Reading Time: 3 minutes

    Arduino is ready to graduate its educational efforts in support of university-level STEM and R&D programs across the United States: this is where students come together to explore the solutions that will soon define their future, in terms of their personal careers and more importantly of their impact on the world.

    Case in point: the groundbreaking partnership with the Ohio State University Buckeye Solar Racing Team, a student organization at the forefront of solar vehicle technology, committed to promoting sustainable transportation by designing, building, and racing solar-powered vehicles in national and international competitions. This collaboration will see the integration of advanced Arduino hardware into the team’s cutting-edge solar vehicles, enhancing driver displays, data transmission, and cockpit metric monitoring.

    In particular, the team identified the Arduino Pro Portenta C33 as the best option for their car: “extremely low-powered, high-quality and reliable, it also has a CAN interface – which is how we will be getting data from our sensors,” team lead Vasilios Konstantacos shared.

    We have also provided Arduino Student Kits for prototyping and, most importantly, accelerating the learning curve for new members. “Our goal is to rapidly equip our newcomers with vital skills, enabling them to contribute meaningfully to our team’s progress. Arduino’s hardware is a game-changer in this regard,” Vasilios stated.
    In addition, the team received Nicla Vision, Nicla Sense ME, and Nicla Voice modules to integrate essential sensors in the car, and more Portenta components to make their R&D process run faster (pun intended!): Portenta Breakout to speed up development on the Portenta C33, Portenta H7 to experiment with AI models for vehicle driving and testing, and Portenta Cat. M1/NB IoT GNSS Shield to connect the H7 to the car wirelessly, replacing walkie-talkie communication, and track the vehicle’s location.

    Combining our beginner-friendly approach with the advanced features of the Arduino Pro range is the key to empower students like the members of the Buckeye Solar Racing Team to learn and develop truly innovative solutions with the support of a qualified industrial partner and high-performance technological products. In particular, the Arduino ecosystem offers a dual advantage in this case: components’ extreme ruggedness, essential for race vehicle operations, paired with the familiarity and ease of use of the Arduino IDE.

    The partnership will empower Ohio State University students to experiment with microcontrollers and sensors in a high-performance setting, fostering a seamless, hands-on learning experience and supporting the institution’s dedication to providing unparalleled opportunities for real-world application of engineering and technology studies. Arduino’s renowned reliability and intuitive interface make it an ideal platform for students to develop solutions that are not only effective in the demanding environment of solar racing but also transferable to their future professional pursuits.

    “We are thrilled to collaborate with the Ohio State University Buckeye Solar Racing Team,” commented Jason Strickland, Arduino’s Higher Education Sales Manager. “Our mission has always been to make technology accessible and foster innovation. Seeing our hardware contribute to advancing solar racing technology and education is a proud moment for Arduino.”

    The post Empowering the transportation of the future, with the Ohio State Buckeye Solar Racing Team appeared first on Arduino Blog.

    Website: LINK

  • Improve recycling with the Arduino Pro Portenta C33 and AI audio classification

    Improve recycling with the Arduino Pro Portenta C33 and AI audio classification

    Reading Time: 2 minutes

    In July 2023, Samuel Alexander set out to reduce the amount of trash that gets thrown out due to poor sorting practices at the recycling bin. His original design relied on an Arduino Nano 33 BLE Sense to capture audio through its onboard microphone and then perform edge audio classification with an embedded ML model to automatically separate materials based on the sound they make when tossed inside. But in this latest iteration, Alexander added several large improvements to help the concept scale much further.

    Perhaps the most substantial modification, the bin now uses an Arduino Pro Portenta C33 in combination with an external Nicla Voice or Nano 33 BLE Sense to not only perform inferences to sort trash, but also send real-time data to a cloud endpoint. By utilizing the Arduino Cloud through the Portanta C33, each AI-enabled recycling bin can now report its current capacity for each type of waste and then send an alert when collection must occur.

    While not as practical for household use, this integration could be incredibly effective for municipalities looking to create a network of bins that can be deployed in a city park environment or another public space.

    Thanks to these upgrades, Alexander was able to submit his prototype for consideration in the 2023 Hackaday Prize competition where he was awarded the Protolabs manufacturing grant. To see more about this innovative project, you can check out its write-up here and watch Alexander’s detailed explanation video below.

    [youtube https://www.youtube.com/watch?v=jqvCssm-7A4?feature=oembed&w=500&h=281]

    The post Improve recycling with the Arduino Pro Portenta C33 and AI audio classification appeared first on Arduino Blog.

    Website: LINK

  • Elasticsearch and Arduino: better together!

    Elasticsearch and Arduino: better together!

    Reading Time: 8 minutes

    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.

    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 Elasticsearch we can provide multiple feedback using search features, such as filtering, aggregation, multi-match, geospatial, vector search (kNN), semantic search, and machine learning.

    In this use case, we used the average aggregation and geo-distance to retrieve all the devices between 100 km.

    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:

    PUT /temperature
    { "mappings": { "properties": { "temperature": { "type": "float" }, "timestamp": { "type": "date" }, "location": { "type": "geo_point" }, "device-id": { "type": "keyword" } } }
    }
    

    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:

    POST /temperature/_doc?pipeline=set-timestamp
    { "temperature": 21.45, "device-id": "H7-001", "location": { "type": "Point", "coordinates": [12.4923, 41.8903] }
    }
    

    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:

    
    GET /temperature/_search
    { "query": { "bool": { "must": { "match_all": {} }, "filter": { "geo_distance": { "distance": "100km", "location": [12.4923, 41.8903] } } } }, "aggs": { "avg_temp": { "avg": { "field": "temperature" } } }
    }
    

    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:

    #define WIFI_SECRET_SSID ""
    #define WIFI_SECRET_PASS ""
    #define ELASTIC_ENDPOINT ""
    #define ELASTIC_PORT 443
    #define ELASTIC_CLOUD_API_KEY ""
    #define DEVICE_GEO_LON 12.4923
    #define DEVICE_GEO_LAT 41.8903
    #define DEVICE_ID "x"
    #define DEVICE_GEO_DISTANCE "50km"
    

    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:

    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;
    

    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.

    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); ESResponse searchResult;
    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"];
    

    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!

    The post Elasticsearch and Arduino: better together! appeared first on Arduino Blog.

    Website: LINK

  • Industry automation? There’s an app for that! With FLECS and Portenta X8

    Industry automation? There’s an app for that! With FLECS and Portenta X8

    Reading Time: 2 minutes

    FLECS and Arduino Pro are partnering to make Industry 4.0 easier for you. FLECS is the easy-to-configure and open-source platform that allows industrial users to work with automation solutions dedicated to their machinery just as easily as we all handle the apps on our phone: install, manage and configure via web interface, and let the system keep track of versions and ensure updates.

    All you need is a Portenta X8 – our powerful, industrial-grade SOM with Linux OS preloaded onboard: connect it to your computer via USB, install FLECS for free (with, literally, one line of code), and access the FLECS UI to pick the right solution for production control, communication, SCADA (Supervisory Control And Data Acquisition), data analysis, fleet management and more.

    Deploying Linux applications has never been more straightforward: we could say it’s as easy as 1-2-3 – except there are actually only 2 steps to the whole process.

    “We are excited to offer the huge Arduino user community immediate access to our automation applications, so anyone can build and boost a wide variety of solutions for industrial contexts. It’s all made possible by Portenta X8, a groundbreaking product bringing Linux into the Arduino ecosystem.”

    – Patric Scholz, Managing Director at FLECS

    Indeed, while on one side you can now leverage all FLECS solutions in a few commands and clicks, on the other you will be working with one of Arduino Pro’s highest-performance modules: Portenta X8 is basically two industrial products in one, with the power of no less than 9 cores (an NXP i.MX 8M Mini Arm® Cortex®-A53 quad-core, up to 1.8GHz per core + 1x Cortex-M4 up to 400MHz, plus the STMicroelectronics STM32H747 dual-core Cortex-M7 up to 480MHz +M4 32-bit MCU up to 240MHz). And of course, the “superpower” of all Arduino products: being part of a comprehensive ecosystem of open-source hardware, software solutions, Cloud services and amazing community-based support.

    To find out more, explore Portenta X8’s features or go directly to the Portenta X8 powered by FLECS page.

    The post Industry automation? There’s an app for that! With FLECS and Portenta X8 appeared first on Arduino Blog.

    Website: LINK

  • You have 3 ways to meet Massimo Banzi in the UK!

    You have 3 ways to meet Massimo Banzi in the UK!

    Reading Time: 3 minutes

    Massimo Banzi and the Arduino Pro team will be crossing the Channel soon for a short tour of Southern England, touching base with long-time partners and meeting many new Arduino fans! 

    On July 11th at 4PM BST, Massimo has been invited to give a Tech Talk at Arm’s headquarters in Cambridge, as part of the company’s ongoing series where “leading experts cover topics across the industry, including artificial intelligence, automotive, consumer technology, infrastructure, and IoT.” Register now to attend the talk remotely, anywhere in the world.

    Fancy a pint and a fireside chat? Come and meet us in London at the Cittie of Yorke, July 12th at 6PM in Holborn. You can learn about Arduino’s latest products and future vision, straight from the co-founder himself. The event is free and no registration is required, but admission will be regulated depending on the venue’s capacity – get there early to save your seat!

    Finally, on July 13th we are excited to announce Arduino Pro will debut with a booth at Hardware Pioneers Max. Come visit us at the Business Design Center in London, booth #48, to chat with our experts. Not sure where to begin? Our demos make great conversation starters! At the show, look for these:

    • An industrial-grade computer built with a Portenta X8 and Max Carrier. The X8’s hybrid combination of microprocessor and microcontroller yields unprecedented flexibility to simultaneously run Linux apps and perform real-time tasks. Pair that with the Max Carrier and an 8″ screen and you have a secure and powerful computer to deploy advanced AI algorithms and ML on the edge. The Portenta X8 can also act as a multi-protocol gateway: data from onsite sensors and controllers (e.g. temperature, operation time, warning codes) are collected and processed thanks to the module’s supported industrial protocols, then sent to the Cloud or ERP system via Wi-Fi, LoRa®, NB/IoT or LTE Cat.M1.
    • A vibration-based condition monitoring system to detect anomalies with Nicla Sense ME. Developed in collaboration with SensiML, this solution makes great use of Nicla’s self-learning AI smart sensor – with integrated accelerometer and gyroscope – to measure vibrations generated by a computer fan. With the intelligence of a trained ML model, the system monitors the fan’s conditions and can determine whether it is on or off, if there are any shocks, and even if the airflow is simply sub-optimal.
    • A solution to monitor vineyard pests, thanks to Nicla Vision and MKR WAN 1310. Smart farming leverages machine vision and valuable data on pest behavior, seasonality, and population size to optimize manual interventions against the dangerous Popillia japonica. Insects are attracted by pheromones inside the trap, where a low-power sensing solution leverages an ML model trained, tested and deployed with Edge Impulse to recognize and count insects, sending real-time data via LoRa® connectivity to the Cloud for remote monitoring.

    And don’t miss Massimo’s talk, “Everything you think you know about Arduino is WRONG” at 4PM (see the event agenda). It’s your chance to find out how the brand that made tech accessible for the first generation of makers is now evolving to support a new generation of innovators.

    We can’t wait to see you there!

    The post You have 3 ways to meet Massimo Banzi in the UK! appeared first on Arduino Blog.

    Website: LINK

  • This converted RC car uses a Portenta H7 to drive itself

    This converted RC car uses a Portenta H7 to drive itself

    Reading Time: 2 minutes

    Jeremy Ellis is a teacher, and as such, wanted a longer-term project that his students could do to learn more about microcontrollers and computer vision/machine learning, and what better way is there than a self-driving car. His idea was to take an off-the-shelf RC car which uses DC motors, add an Arduino Portenta H7 as the MCU, and train a model to recognize target objects that it should follow.

    After selecting the “RC Pro Shredder” as the platform, Ellis implemented a VNH5019 Motor Driver Carrier, a servo motor to steer, and a Portenta H7 + Vision Shield along with a 1.5” OLED module. After 3D printing a small custom frame to hold the components in the correct orientation, nearly 300 images were collected of double-ringed markers on the floor. These samples were then uploaded to Edge Impulse and labeled with bounding boxes before a FOMO-based object detection model was trained.

    Rather than creating a sketch from scratch, the Portenta community had already developed one that grabs new images, performs inferencing, and then steers the car’s servo accordingly while optionally displaying the processed image on the OLED screen. With some minor testing and adjustments, Ellis and his class had built a total of four autonomous cars that could drive all on their own by following a series of markers on the ground.

    For more details on the project, check out Ellis’ Edge Impulse tutorial here.

    The post This converted RC car uses a Portenta H7 to drive itself appeared first on Arduino Blog.

    Website: LINK

  • Arduino Pro at SPS Italy 2023

    Arduino Pro at SPS Italy 2023

    Reading Time: 3 minutes

    Mark your calendars: May 23rd-25th we’ll be at SPS Italia, one of the country’s leading fairs for smart, digital, sustainable industry and a great place to find out what’s new in automation worldwide. We expect a lot of buzz around AI for IoT applications – and, of course, we’ll come prepared to give our own, open-source perspective on the AIoT trend. 

    At Arduino Pro’s booth C012, pavilion 7, our experts will be presenting some of the latest additions to our ever-growing ecosystem, which includes everything companies need to fully embrace digital transformation with professional performance paired with Arduino’s ease of use and open-source philosophy. You can explore our complete digital brochure here, but let us point out some recent highlights.

    Meet the Arduino Pro ecosystem at SPS Italia 2023

    • Over the years, Arduino Pro has built quite the presence on the market with SOMs like the Portenta H7 and X8, recently joined by the Portenta C33: a cost-effective, high-performance option that makes automation accessible to more users than ever, based on the RA6M5, an Arm® Cortex®-M33 microcontroller from Renesas.
    • Our Nicla family of ultra-compact boards also expanded: after Nicla Sense ME and Nicla Vision, Nicla Voice packs all the sensors, intelligence and connectivity you need for speech recognition on the edge, leveraging AI and ML.
    • What’s more, the Arduino ecosystem also includes turnkey solutions like the Portenta Machine Control and the new Opta, our very first microPLC, designed in partnership with Finder to support the Arduino programming experience with the main PLC standard languages – and available in 3 variants with different connectivity features: Opta Lite, Opta RS485, and Opta WiFi. Both the Portenta Machine Control and Opta can be programmed via the new PLC IDE, designed to help you boost production and build automation with your own Industry 4.0 control system.
    • Finally, since SPS Italy’s last edition we have launched Arduino Cloud for Business: a dedicated Cloud plan for professional users requiring advanced features for secure device management including OTA updates, user-friendly fleet management, and RBAC to safely share dashboards among multiple users and organizations. Specific optional add-ons allow you to further customize your solution with Portenta X8 Manager, LoRaWAN Device Manager or Enterprise Machine Learning Tool – accelerating your IoT success, whatever the scale of your enterprise may be.

    If you are attending SPS Italia, don’t miss the conference by our own Head of Arduino Pro Customer Success Andrea Richetta, joined by Product Managers Marta Barbero and Francesca Gentile (in Italian): on May 24th at 2:30pm they will dive deep on the tools Arduino Pro makes available for all companies ready to take part in the IoT revolution, with a unique combination of performance and ease of use. This is your chance to discover how you too can integrate safe and professional Industry 4.0 solutions in new or existing applications, quickly growing from prototype to large-scale production with sensors, machine vision, embedded machine learning, edge computing, and more.

    Curious? Register to access the fair if you are an industry professional, and reach out to book a meeting with a member of our team.

    The post Arduino Pro at SPS Italy 2023 appeared first on Arduino Blog.

    Website: LINK

  • Portenta C33: The high-performance, low-price oxymoron

    Portenta C33: The high-performance, low-price oxymoron

    Reading Time: 2 minutes

    While democratizing professional solutions may seem like an oxymoron, that’s exactly what Arduino Pro is out to achieve. Our business-oriented unit stands at industrial clients’ side with a growing ecosystem of high-performance, reliable, secure products that aim to provide the right solution for every need big and small companies may have, in any field and at any stage of their growth. 

    Case in point: the Portenta C33. The module – which we are introducing at Embedded World 2023 – leverages the R&D carried out for previous Portenta modules, optimizing every aspect and streamlining features to offer a cost-effective option to users starting out with Industrial IoT or automation, or those who have more specific, targeted needs than the H7 or X8 cater to.

    Is the Portenta C33 right for you? Check out its main tech specs:

    • Arm® Cortex®-M33 microcontroller by Renesas
    • MicroPython and other high-level programming languages are supported
    • Onboard Wi-Fi® and Bluetooth® Low Energy connectivity
    • Secure element for industrial-grade security at the hardware level
    • Secure OTA firmware updates (connecting to Arduino IoT Cloud or third-party services)
    • Compatible with Portenta, MKR, and Nicla components
    • Castellated pins
    • Wide variety of peripheral interfaces, including CAN, SAI, SPI, and I2C

    What’s more, the Portenta C33 is born into an extensive ecosystem that comes not only with a variety of components that easily combine, but also with ready-to-use software libraries and Arduino sketches shared and perfected by our incredible community. 

    If that sounds like everything you need to prototype and develop your next project – or perhaps your first project – for industrial or building automation, you can find more details on the Arduino Pro website and join the waiting list

    If you are attending Embedded World in Nuremberg, Germany from March 14th to 16th, come visit Arduino Pro inside the tinyML Pavilion at booth 2-238. We will be presenting the Portenta C33 at the show and our experts will be happy to introduce you to our newest product.

    The post Portenta C33: The high-performance, low-price oxymoron appeared first on Arduino Blog.

    Website: LINK

  • Portenta X8 in Arduino IoT Cloud

    Portenta X8 in Arduino IoT Cloud

    Reading Time: 4 minutes

    You may have heard about Portenta X8 for its flexibility of usage of Linux combined with real-time applications through the Arduino environment.

    But now, a new set of features have been added to Portenta X8 thanks to its brand-new Arduino Python container. Update your board with the latest image (here is a tutorial showing how to do so) and start exploiting a wide range of unique functionalities:

    • Set up your Portenta X8 in just a couple of clicks with the full revised out-of-the-box experience
    • Self-provision your boards in the Arduino Cloud keeping security in mind
    • Gather real-time and historical data in one place and display them on widget-based dashboards
    • Manage and monitor your fleet of devices from anywhere together with all your team
    • Keep your X8 up-to-date with secure OTA updates with the Portenta X8 Board Manager add-on

    It is now time to learn more about the incredible number of projects Portenta X8 can help you build up.

    All Portenta X8 settings in one place

    Connect your Portenta X8 in the browser and start setting it up in no time through the dedicated out-of-the-box experience.

    Connect your X8 to the Wi-Fi® in just a couple of clicks and start leveraging all its multiple features:

    1. Shell. Communicate to your X8 through a dedicated Shell running in a Python-Alpine Container. Explore multiple examples and easily develop your Python applications.

    2. Arduino Cloud. Always thought about connecting your X8 to the Cloud? Wait no more. Create an Arduino Cloud account and enjoy this new feature. With the out-of-the-box experience, your Portenta X8 can be securely self-provisioned in the Arduino IoT Cloud, you just need to create API keys and the Python container running on X8 will do the rest. When provisioned, you can start directly interacting with an example Thing and Dashboard that will be automatically generated for you to guide you step-by-step in this new journey.

    3. Portenta X8 Manager. Securely monitor your fleets of Portenta X8 by purchasing the Portenta X8 Manager:

    • Securely maintain your Linux distribution
    • Deploy and update applications packaged into containers
    • Secure over-the-air updates to target Portenta X8 devices/fleets

    With the new out-of-the-box experience, the Portenta X8 now has a full suite of tools available for every kind of user.

    Create amazing dashboards with Portenta X8

    Making Portenta X8 compatible with the Arduino Cloud means opening a wide range of new applications.

    This compatibility is guaranteed by a brand-new Python container. Through Arduino Cloud APIs, the Python container ensures full interaction and simple porting of any Python-developed application in the Cloud.

    Thus, connect your Portenta X8 with external sensors or other peripheral devices and visualize their data in widget-based dashboards. Push button, Messenger, Scheduler, and Chart are just a few of the many widgets you can select to build your ultimate control center.

    Do you have multiple boards or sensors connected? It’s easy, the Arduino Cloud is able to manage data coming from different boards/things in just one dashboard.

    In addition, a preconfigured dashboard allows you to monitor the health and usage of your Portenta X8. The diagnostics of your fleets has never been easier.

    And remember, you can monitor your dashboards anywhere, anytime. Use your dashboards on the go, and control projects from your smartphone using the free IoT Remote app.

    Manage your Portenta X8 from anywhere

    You probably already know that you can use the Arduino Cloud to have full control over your fleets of compatible devices, including Arduino, ESP32, and ESP8266 boards.

    Filter and Group your devices according to multiple parameters, such as name, type, customizable tags, etc., and monitor their status whenever you like.

    Looking for the Portenta X8? Just search for it in the search bar and you will be able to check which Thing and dashboard are assigned to it.

    If you would like to be sure that your Portenta X8 is always up-to-date, start using it by subscribing to the dedicated tool called Portenta X8 Board Manager.

    This add-on enables any user to receive constant Linux OS updates from Arduino, not only for Linux image, but also for all the containers developed and updatable over time. So, if you would like to keep track of the status of your full Portenta X8 fleet and perform secure remote OTA updates, this is the perfect solution for you.

    Try it now!

    Update your Portenta X8 and get started with the Arduino Cloud and associated documentation.

    The post Portenta X8 in Arduino IoT Cloud appeared first on Arduino Blog.

    Website: LINK

  • Predicting when a fan fail by listening to it

    Predicting when a fan fail by listening to it

    Reading Time: 2 minutes

    Embedded audio classification is a very powerful tool when it comes to predictive maintenance, as a wide variety of sounds can be distinguished as either normal or harmful several times per second automatically and reliably. To demonstrate how this pattern recognition could be incorporated into a commercial setting, Kevin Richmond created the Listen Up project that aims to show the current status of a running fan based solely on its noise profile.

    Richmond started by collecting 15 minutes of data for each label, namely background noise, normal operation, soft failure, and severe failure. Once collected, the data was split into two-second samples and uploaded to the Edge Impulse Studio, after which an impulse was configured to use an MFE audio processing block and a Keras classification model. Once trained on the dataset, the model achieved an accuracy of almost 96% using real-world testing data.

    In order to utilize the classifier, Richmond deployed his Edge Impulse project as an Arduino library for use in an Arduino Portenta H7 sketch. In it, an accompanying Portenta Vision Shield’s microphone continuously gathers new audio data before passing it into the classification model to receive a result. The probability of each label is then used to set a corresponding LED color if the probability is greater than 80%, otherwise blue is shown to indicate a failed reading.

    To see the project in action, you can watch Richmond’s video below or read his write-up on Hackster.io.

    The post Predicting when a fan fail by listening to it appeared first on Arduino Blog.

    Website: LINK

  • Environmental monitoring of corporate offices with Arduino Pro

    Environmental monitoring of corporate offices with Arduino Pro

    Reading Time: 7 minutes

    The challenge

    The quality of the air we breathe has a direct impact on our health. Poor air quality can cause a variety of health problems, including respiratory infections, headaches, and fatigue. It can also aggravate existing conditions such as asthma and allergies. That’s why it’s so important to monitor the air quality in your office and take steps to improve it if necessary.

    Furthermore, the number of people in an office can have a significant impact on air quality. The more people there are, the greater the chance of contaminants being emitted into the air. This is why environmental monitoring is so important in corporate offices; it helps to ensure that the air quality is safe for all workers.

    The last few years added to this challenge yet another layer: The COVID-19 pandemic has forced many businesses to re-evaluate their workplace safety protocols. One of the most important considerations is air quality. Poor air quality can lead to a variety of health problems, including respiratory infections.

    Environmental monitoring in buildings refers to the security and privacy practices used to protect workers and office buildings from airborne contaminants. This includes collecting data on air quality, temperature, humidity, and other environmental factors. This data is then used to assess the risk of exposure to hazardous materials and take steps to mitigate or eliminate those risks.

    Our solution

    To address the challenge, we will devise an environmental monitoring system based on sensor nodes that monitor each room and send the collected data to a gateway that can either display it locally or push it toward a cloud solution where further computation can be done. Either at the gateway level or in the cloud, alerts can be set based on certain thresholds considered relevant. 

    Air quality monitoring

    For monitoring the environmental conditions we have chosen the Arduino Nicla Sense ME, which is designed to easily analyze motion and the surrounding environment – hence the “M” and “E” in the name. It measures rotation, acceleration, pressure, humidity, temperature, air quality, and CO2 levels by introducing completely new Bosch Sensortec sensors on the market.

    The sensor we are most interested in on the Nicla Sense ME is the BME688, the first gas sensor with artificial intelligence (AI) and integrated high-linearity and high-accuracy pressure, humidity, and temperature sensors. It is housed in a robust yet compact 3.0 x 3.0 x 0.9 mm³ package and specially developed for mobile and connected applications where size and low power consumption are critical requirements. The gas sensor can detect volatile organic compounds (VOCs), volatile sulfur compounds (VSCs), and other gasses such as carbon monoxide and hydrogen in the part per billion (ppb) range.

    The full datasheet is available here

    People counting

    For monitoring the number of people in each room we have chosen the Arduino Nicla Vision, which combines a powerful STM32H747AII6 dual Arm Cortex-M7/M4 processor with a 2MP color camera that supports tinyML, as well as a smart six-axis motion sensor, integrated microphone, and distance sensor.

    One thing that must be addressed when using cameras is privacy concerns and for good reasons! In our case, the cameras are used to execute an edge model to evaluate the number of persons in the view and no actual video stream or pictures are leaving the camera. Only the actual number makes it both safe and efficient. 

    For this purpose, we have chosen the Edge Impulse platform where we can easily train and deploy a model that will allow us to detect the number of persons in the view of the camera. After the deployment, no further need of internet connectivity is needed for the camera and only the number of persons will be relayed to the gateway.

    Both the Nicla Vision and Nicla Sense ME have the same size and PCB format, with the main difference being that one features a camera and the other one an array of sensors. For each, we have created a 3D-printed enclosure to accommodate mounting and fulfilling their primary functions easily.

    Edge computing

    For the gateway we have chosen the Portenta X8, which is a powerful, industrial-grade SOM with Linux OS preloaded onboard, capable of running device-independent software thanks to its modular container architecture. It features an NXP i.MX 8M Mini Cortex-A53 quad-core, up to 1.8GHz per core + 1x Cortex-M4 up to 400MHz, plus the STMicroelectronics STM32H747 dual-core Cortex-M7 up to 480Mhz and M4 32-bit Arm MCU up to 240MHz.

    Since space is not an issue when designing building management issues, we have chosen the Portenta Max Carrier, to host and power the Portenta X8 while enhancing its connectivity options and providing it with easy-to-mount options and power supply plugs. We hosted the devices inside an easy to mount on a wall enclosure according to the overall size of the hardware.

    The Portenta X8 can gather via BLE the data from quite a few sensor nodes as long as they are in range and not blocked by heavy walls or structures in between and either store the data locally for displaying it via the local server stack or relay it further to the cloud.

    IoT Cloud solution

    Although the Portenta X8 board is capable of storing data locally, there may be times when it is also desirable to send data to the cloud. This can be accomplished by forwarding data from the InfluxDB database on the Portenta X8 board to the Arduino IoT Cloud via MQTT. The arduino-iot-js NPM module makes it easy to set up this connection, and the steps to do so are not covered in this tutorial. For illustrative purposes, however, the diagram below offers a brief overview of our proposed architecture for one potential deployment scenario in a building with multiple rooms.

    Solving it with Arduino Pro

    Now let’s explore how we could put all of this together and what we would need for deployment both in terms of hardware and software stack. The Arduino Pro ecosystem is the latest generation of Arduino solutions bringing users the simplicity of integration and scalable, secure, professionally supported services.

    Hardware requirements

    • Arduino Nicla Vision
    • Arduino Nicla Sense Me
    • Arduino Portenta X8
    • Enclosures

    Software requirements

    • Arduino IDE
    • OpenMV IDE
    • Edge Impulse account

    The Nicla Vision has been programmed in Python since the Edge Impulse model was created/tested using the OpenMV IDE and thus we have also sent the data over BLE using the Python library.

    The Nicla Sense ME has been programmed in C/C++ using the Arduino IDE since reading the sensors and sending their data over the BLE can be done faster via the C/C++  programming language since the code is already compiled and we do not need any heavy computing like when dealing with video on the Nicla Vision.

    The Portenta X8 with its Linux OS preloaded onboard is fully capable of running Docker and thus containers with a vast array of functionalities. In our case, we found it most useful to use a time series database to store the data and display it locally. There is a pre-built container including InfluxDB, Grafana, and Node-Red that can be easily deployed to achieve this task.

    Here is a screenshot from a dashboard created directly in InfluxDB showcasing data received from the sensor nodes:

    The dashboard can be visualized by accessing the InfluxDB interface on the Portenta X8 IP on port 8086 in a browser on another computer connected to the same WiFi network (for example, http://192.168.1.199:8086/).

    Here is an overview of the software stack and how a minimum deployment with one of each hardware module communicates to fulfill the proposed solution:

    Conclusion

    Environmental monitoring is essential for corporate offices in order to ensure the safety and health of workers. The correlation between the number of people in an office and air quality means that more people can lead to more contaminants in the air. Additionally, data latency can be a challenge when it comes to environmental monitoring. This is why it is important to have systems in place that can collect data quickly and efficiently and make this data available to decision-makers in a timely manner.

    There are many benefits to using this solution. First, it enables building managers to monitor the environmental conditions in each room and take steps to mitigate any risks. Second, it provides a system for collecting data on occupancy, air quality, temperature, humidity, and other environmental factors. This data can be used to assess the risk of exposure to hazardous materials and take steps to mitigate or eliminate those risks. Finally, our solution is easy to use and can be installed in any office building.

    Website: LINK

  • Spotting defects in solar panels with machine learning

    Spotting defects in solar panels with machine learning

    Reading Time: 2 minutes

    Large solar panel installations are vital for our future of energy production without the massive carbon dioxide emissions we currently produce. However, microscopic fractures, hot spots, and other defects on the surface can expand over time, thus leading to reductions in output and even failures if left undetected. Manivannan Sivan’s solution for tackling this issue revolves around using computer vision and machine learning to find small defects at the surface before automatically reporting the information.

    Sivan compiled his dataset by first gathering images of solar panels that have visible cracks using an Arduino Portenta H7 and Vision Shield and then drawing bounding boxes around each one. From here, he trained a MobileNetV2 model with the addition of Edge Impulse’s recent FOMO object detection algorithm for better performance. He was able to improve the model’s accuracy even further by augmenting the dataset with images taken at different camera angles and lighting conditions in order to prevent mistaking the white boundary lines for cracks.

    After testing and deploying the model from the Edge Impulse Studio to his Portenta H7 board, it was able to successfully find cracks in a solar panel’s surface around 80% of the time. In the future, Sivan might add other features that take advantage of the onboard connectivity to communicate with outside services for faster response times. You can read more about the project here.

    Boards:Portenta
    Categories:Arduino

    Website: LINK

  • This tinyML-powered baby swing automatically starts when crying is detected

    This tinyML-powered baby swing automatically starts when crying is detected

    Reading Time: 2 minutes

    No one enjoys hearing their baby cry, especially when it occurs in the middle of the night or when the parents are preoccupied with another task. Unfortunately, switching on a motorized baby swing requires physically getting up and pressing a switch or button, which is why Manivannan Sivan developed one that can automatically trigger whenever a cry is detected using machine learning.

    Sivan began his project by first gathering real world samples of crying sounds and background noise from an Arduino Portenta H7 and Vision Shield before labeling them accordingly in the Edge Impulse Studio. From here, he created a simple impulse which takes in time-series audio data and generates a spectrogram which is then used to train a Keras neural network model. Once fully trained, the model could accurately distinguish between the two sounds about 98% of the time.

    Beyond merely classifying the sounds from the two onboard microphones, Sivan’s custom program also sets a relay to activate for 20 seconds if crying has been detected, after which it turns off until crying is recognized again. He hopes to use this project as a convenient way to assist busy parents with the difficult task of calming a crying baby without the need for constant manual intervention. You can read more about it here on the project’s Edge Impulse docs page.

    Boards:Portenta
    Categories:Arduino

    Website: LINK

  • The Things Conference 2022: catch up with us and all things LoRaWAN®

    The Things Conference 2022: catch up with us and all things LoRaWAN®

    Reading Time: 3 minutes

    Arduino TeamSeptember 16th, 2022

    We are excited to announce our team will be traveling to Amsterdam for The Things Conference on September 22nd-23rd, where Arduino will be among select exhibitors.

    The Things Conference is the world’s largest conference about LoRaWAN®, bringing together the industry’s major players contributing to this technology’s development in a two-day deep dive dedicated to making business operations smarter. This year’s edition will focus on the main topic of digital transformation – as seen through the lens of LoRaWAN®, of course!

    Don’t miss your chance to meet our experts in person at Amsterdam’s The Kromhouthal – a former marine engine factory now turned into a unique event venue. 

    We’ll be showcasing some of our best LoRaWAN® products and solutions: 

    • The Portenta Vision Shield LoRa®, designed to boost Arduino Pro’s H7 module with the capability to run embedded computer vision applications, connect wirelessly via LoRa® to the Arduino Cloud (or third-party infrastructure), and activate systems upon the detection of sound events; 
    • The Portenta Max Carrier, which can augment Portenta H7 or X8 with LoRa® connectivity and transform existing Arduino Pro modules into single-board computers or reference designs that enable edge AI for high-performance industrial, building automation and robotics applications;
    • The Arduino MKR WAN 1310, an entry-level option featuring the renowned versatility of the MKR family: a practical and cost-effective solution to add LoRa® connectivity to projects requiring low power;
    • Last but not least, the newly launched WisGate Edge Lite 2 and WisGate Edge Pro: ready-to-use, industrial-grade gateways for LoRaWAN® connectivity powered by RAKwireless™.

    On September 22nd, the packed schedule of The Things Conference also includes a keynote by Sebastian Romero, Lead Interaction Designer & Creative Technologist at Arduino: “Predictive Maintenance with an Arduino-based LoRa solution” will center on ways to implement predictive maintenance by measuring equipment vibration patterns, to prevent damage, mitigate the risk of downtime and improve profitability.

    Interested in something more specific? Sign up for “How to implement a smart, LoRa-connected insect trap with Arduino,” a dedicated workshop on September 23rd, also held by Romero.

    At The Things Conference, we strive to bring together all industry leaders who can contribute to LoRaWAN® development, in a two-day deep dive dedicated to making business operations smarter. We see strong signs that innovation in the market is not driven only by technologies becoming available, but by a true shift towards compatibility and a partnership mentality – which Arduino has always stood for,” adds Wienke Giezeman, CEO at The Things Industries in closing.

    You can browse the full schedule and purchase your tickets at The Things Conference website, entering promo code FRIEND-ARDUINO for a 20% discount.  

    Tot ziens in Amsterdam!

    Website: LINK

  • This system detects leaks by listening to water flowing through pipes

    This system detects leaks by listening to water flowing through pipes

    Reading Time: 2 minutes

    Arduino TeamJuly 27th, 2022

    Damaged, leaking pipes are not only a nuisance to clean up after, but they can also create major inefficiencies within water delivery systems, leading to a loss in both the water itself and the electricity required to disinfect and pump it. Over the past decade, water pipeline detection systems have been upgraded to include state-of-the-art sensors, which can precisely locate where a leak is. Due to their high price, Manivannan Sivan designed his own leak detection system that can be produced for far less cost.

    Sivan’s project involves the placement of two microphones next to a pipe and reading the acoustic signatures they pick up. For this task, he chose a single Arduino Portenta H7 and an accompanying Vision Shield due to its pair of onboard mics and fast processor. He then collected samples for no water flow, water flow without leaks, and water flow with leaks. The resulting machine learning model achieved an accuracy of 99.1% and a mere 0.02 loss.

    After deploying the model to his board and placing it near a pipe, the Portenta now had the ability to identify when the pipe started to leak — and potentially notify someone thanks to its wireless connectivity, if Sivan decided to add that feature.

    [youtube https://www.youtube.com/watch?v=EzDfbBDurm4?feature=oembed&w=500&h=281]

    For more details on this project, read its write-up here on the Edge Impulse blog.

    Website: LINK

  • Monitoring IV fluid bag levels with the Arduino Portenta H7 and Vision Shield

    Monitoring IV fluid bag levels with the Arduino Portenta H7 and Vision Shield

    Reading Time: 2 minutes

    Arduino TeamJune 22nd, 2022

    When a patient is receiving intravenous (IV) fluids, it is vital that air is not introduced into the line, as its presence can create issues such as excessive pressure or even embolisms that can be life-threatening. Normally, the level of fluids remaining within the bag is periodically checked by a nurse, but due to challenges related to staffing, this might not be enough. Therefore, Manivannan Sivan devised an automated monitoring system that uses computer vision along with machine learning to do this repetitive task instead of a person.

    To begin the project, Sivan gathered a series of images that spanned three categories with an Arduino Portenta H7 and Vision Shield. Within each picture, the IV fluid bag is 15cm away and contains either an adequate, less than 50%, or low level of fluid remaining. Once trained, his model was able to successfully recognize the correct level around 96% of the time, although additional images taken at different light levels would help improve the accuracy even more.

    From here, Sivan deployed his model back to the Portenta H7 to see how it performs in day-to-day conditions, with classification taking place once every two seconds. His plan is to take the resulting category and export it to an awaiting server over the network so that hospital staff can see the fluid bag’s status in real-time on a dashboard.

    For more details on this project, you can watch Sivan’s explainer video below or read his write-up on the Edge Impulse docs page.

    [youtube https://www.youtube.com/watch?v=4W37gOTlnjk?feature=oembed&w=500&h=281]

    Website: LINK

  • The new Portenta X8 (with Linux!) and Max Carrier redefine what’s possible

    The new Portenta X8 (with Linux!) and Max Carrier redefine what’s possible

    Reading Time: 3 minutes
    Portenta X8 Max Carrier

    Arduino’s mission has always been to give creators, makers and innovators the tools they need to turn their ideas into real projects. That will never change. What is changing, and at warp speed, is our definition of possible.

    Because every day our accessible, flexible and reliable open-source hardware grows more powerful, and our ecosystem more complete. As you may have heard during Arduino Week, Arduino Pro is launching two new products in the Portenta range: the revolutionary X8 module, which merges Arduino and Linux for the first time, and Max Carrier, which gives you super prototyping powers to make your ideas come to life easier and faster than ever

    [youtube https://www.youtube.com/watch?v=c2nz1wLIp5g?feature=oembed&w=500&h=281]

    Portenta X8 is a plug-and-play, industrial-grade SOM that comes with Linux OS preloaded onboard, making for a hybrid combination of microprocessor and microcontroller with the capability for AI and ML on the edge. It’s basically two products in one, with the power of no less than 9 cores. It features an NXP® i.MX 8M Mini Cortex®-A53 quad-core, up to 1.8GHz per core + 1x Cortex®-M4 up to 400MHz, plus the STM32H747XI dual-core Cortex®-M7 up to 480Mhz +M4 32 bit Arm® MCU up to 240Mhz, and is capable of running device-independent software thanks to its modular container architecture.

    With onboard WiFi/Bluetooth® connectivity you can carry out OS/application updates remotely, so the Linux kernel environment is always at top performance levels. Enhanced security is guaranteed by X8’s NXP SE050C2 Crypto element – keeping connections secure at the hardware level with PSA certification. The module has also achieved Arm SystemReady certification and integrated Parsec services, making it one of the first Cassini Products available to you on the market.

    It’s everything you need to develop your most ambitious projects for Industry 4.0, smart agriculture, connected buildings and smart cities: check out the full technical specs on the dedicated page and superpower your Linux applications with real-time execution.

    If that wasn’t enough, we are also introducing Portenta Max Carrier – which boosts X8 or H7 by adding connectivity options (Fieldbus, LoRa®,  Cat-M1 and NB-IoT), industrial connectors such as RS232/422/485, USB, mPCIe – plus three integrated audio jacks, a MicroSD card and more. 

    You can combine this Arduino Pro carrier with existing Portenta modules to turn them into single-board computers or reference designs for Industry 4.0 – bringing your deployment time virtually down to zero. This allows you to swiftly prototype and develop high-performance projects such as remote control of industrial machinery and equipment, smart digital kiosks that enhance users’ experience, and custom HMI dashboards to control the smart appliances, lights and systems in your home or office remotely.

    [youtube https://www.youtube.com/watch?v=GxN2-hs9288?feature=oembed&w=500&h=281]

    As excited as we are about these launches, it’s never just about a new product (or two!). It’s about how many new ideas we can spark, the innovation we can fuel, the new opportunities you can create, if you have the right tools.

    Portenta X8 is available on the Store and Max Carrier will arrive soon. We can’t wait to see the great innovations you will bring to life.

    Want to know more? Read all the details and judge for yourself.

    Website: LINK