Posts | Comments

Planet Arduino

Archive for the ‘New’ Category

The Nano 33 BLE is one of our most popular boards, and for good reason. It’s small and 3.3-V-compatible; it comes with an embedded nine-axis IMU featuring accelerometer, gyroscope and magnetometer; it has a powerful processor; it offers a powerful Bluetooth® Low Energy module with an internal antenna that can be used to transmit data between different devices using the ArduinoBLE library; and it can be programmed with MicroPython. 

It’s basically everything you need for projects that span from wearable to advanced robotics. 

So, why work on making it better?

Because we listen to our community, that’s why. And based on your requests, we’ve come up with improvements to enhance your experience with a revised iteration of the Arduino Nano 33 BLE with a newly integrated IMU to expand experimentation possibilities, and a streamlined PCB design to grant easy access to essential features.

And here is exactly what you can find in the new Rev2, compared to its predecessor:

  • It has a combination of two IMUs (BMI270 six-axis IMU plus BMM150 three-axis IMU) instead of a single, nine-axis one.
  • While retaining the compact form factor, the new Nano 33 BLE Rev2 incorporates new pads and test points for USB, SWDIO, and SWCLK, making it easier to access these crucial points on the board.
  • We introduced a new VUSB soldering jumper on the top side, allowing you to conveniently enable the VUSB pin while using the castellated pins.
  • In addition, the Nano 33 BLE Rev2 transitions the power supply component to the MP2322 to guarantee increased performance. 

These updates collectively contribute to a more streamlined and robust device, ready for you to test and build just about any IoT project – and more. For example, the Nano 33 BLE Rev2 is still ideal to control RGB LEDs over Bluetooth®, using an app on your phone, and supports OpenMV’s fork of MicroPython

If you already know the Nano 33 BLE from its first revision, you can easily migrate your sketches to use them with the new and improved version: if you need help, just follow our dedicated tutorial.

After the launch of the Nano ESP32 earlier this year, it’s the perfect addition to the “tiny footprint, mighty features” family that has proven time and time again that we can ramp up features and performance while scaling down size. Don’t believe us? Check out the classic Arduino Nano or upgrade to the Nano 33 BLE Sense Rev2 if you want to include a complete set of sensors, too. 

For full tech specs, tutorials and inspiration on the Nano 33 BLE Rev2, head to the dedicated Arduino Docs page. Ready to get your own? The Nano 33 BLE with headers and without headers are now available on our Store.

The post Not bigger, just better: Introducing the Nano 33 BLE Rev2 appeared first on Arduino Blog.

Single-board computers (SBCs) are amazing mini powerhouses capable of nearly anything. The undisputed royalty of SBC form factors is our friend, the Raspberry Pi® Model B. An entire ecosystem of expansions, properly called HATs, has formed around its iconic 40-pin double-row header. Today, we are introducing the ultimate mash-up, combining the worlds of SBC and MCU with the newest addition to our Portenta range: Portenta Hat Carrier.

Now available from distributors (Mouser, DigiKey, RS Components) and our online Store, Portenta Hat Carrier is a reliable and robust carrier that transforms your Portenta system-on-module into an industrial platform compatible with Raspberry Pi® Hats, ready for a variety of solutions from workbench prototyping to field applications in the most demanding industrial settings. The Portenta Hat Carrier is specifically designed for the requirements of professionals using Raspberry Pi® technology in commercial solutions.

With Portenta Hat Carrier’s modular interface, you can take any Arduino Pro Portenta X8, Portenta H7 or Portenta C33 and add easy access to multiple peripherals – including any Raspberry Pi® HAT compatible with the Model B 40-pin header, Ethernet, microSD, and USB. To further simplify commercial applications, Portenta Hat Carrier features an onboard CAN transceiver, an additional 8x analog I/Os and a PWM fan connector. This ease of use will not come at the expense of your solutions’ reliability, thanks to debugging capabilities courtesy of dedicated JTAG pins.

“Portenta Hat Carrier provides a unique bridge between the Arduino and Raspberry Pi® ecosystems, offering professionals a modular platform for prototyping to full-fledged industrial applications,” said Massimo Banzi, Arduino’s co-founder, chairman and CMO. “We are excited to offer a product that answers our customers’ requests and supports an ecosystem we admire.”

Massimo Banzi, co-founder

Indeed, Portenta Hat Carrier is great for prototyping and ready for scaling up – in applications ranging from robot arm controllers to smart video surveillance systems. So, what are you waiting for? Check out the full specs on our dedicated product page.

The post Tip your hat hello to our latest expansion. Introducing Portenta Hat Carrier appeared first on Arduino Blog.

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.

We’re excited to announce the release of two new widgets to the Arduino IoT Cloud: the Value Selector and Value Dropdown Widgets.

In this blog post, we’ll be exploring the benefits of the new widgets, how to use them, and how you can take advantage of this latest feature.

The Arduino IoT Cloud dashboards

The Arduino Cloud is an all-in-one platform that streamlines the development, deployment, and management of IoT devices. The platform supports various hardware, such as Arduino boards, ESP32, and ESP8266-based boards, which makes it easy for makers, IoT enthusiasts, and professionals to build connected projects without much hassle.

What makes Arduino Cloud stand out is its user-friendly and intuitive interface. This simplifies complex tasks and ensures that even those with little coding experience can use the platform. Moreover, the platform offers a low-code approach and a comprehensive catalogue of templates and examples that enable users to get started quickly.

The IoT Cloud application of the Arduino Cloud platform allows easy management and monitoring of connected devices via customizable dashboards. This feature provides real-time data visualizations of the device’s data, making it easy for users to monitor and keep track of their devices. Plus, with the mobile app Arduino IoT Cloud Remote — available for Android and iOS — users can manage their devices remotely from anywhere.

The Arduino Cloud platform also offers a range of widgets, including switches, buttons, color selectors, status, gauges, maps, and a chart widget that allows users to plot the temporal evolution of one variable of one device. This rich palette of widgets makes it easy for users to build dashboards that suit their needs.

The new widgets

The new Value Selector and Value Dropdown Widgets simplify the task of creating a map between variable values and their real-world representations, providing users with greater flexibility and ease of use. With them, you can decouple the internal values of the variables in the sketch from the representation on the dashboard. This simplifies the code and prevents developers from updating the code if a change on the visible value is needed.

The Value Selector Widget offers a more visual way of representing values and choices, making it easier for users to understand and work with their data. This feature simplifies the code and allows for greater flexibility in representing data.

The value selector widget can be used to switch between predetermined values through available buttons. Supported variable types are int and String.

The Value Dropdown Widget is a compact and organized way of presenting a list of options to users. This feature is particularly useful when designing for smaller screens or when there are many options to choose from. Dropdown menus allow for clear categorization and organization of options, making it easier for users to find what they are looking for.

The value dropdown widget works similarly to value selector, and is be used to switch between predetermined values through a dropdown menu. Supported variable types are int and String.

Both of these new features are incredibly convenient for predefining a list of values that the user can choose from. The meaningful names and values assigned to each option simplify the process of selecting data, making it more intuitive and accessible to users.

In summary, the Value Selector and Dropdown Widgets are powerful new features that provide users with greater flexibility, ease of use, and clarity when working with their data. We are excited to see how these new tools will enhance the user experience and improve the way users work with their data. These new widgets add up to the recently announced improvement of the percentage widget and the new advance chart widget. You can read the full story in the blog post

Try the now widgets today

Ready to take your IoT projects to the next level? Check out the official Arduino Cloud website for more information on the Arduino IoT Cloud and all the resources available to you. You can also explore the documentation to learn more about the exciting new widgets that are available.Dive in and try out the new Arduino IoT Cloud widgets for yourself!  We’d love to hear your feedback, so don’t forget to share your thoughts and experiences with us on the forum.

The post Introducing the new Value Selector and Dropdown Widgets for Arduino IoT Cloud dashboards appeared first on Arduino Blog.

Remote monitoring with a mobile app is a must for all the IoT device management platforms. In general, having a mobile app offers a more complete and convenient user experience for IoT device management platform users, which can improve their satisfaction and loyalty. So expanding the mobile app capabilities in order to help users interact better with the platform is one of the key goals. 

The Arduino IoT Remote app (available for Android and iOS) was designed with the aim to control and monitor your devices using the Arduino Cloud dashboards and offer full control in your hands from anywhere in the world. Arduino has gone a BIG step further and enabled you to use the app as an IoT device, collecting information from the mobile phone sensors and sending them to the Arduino Cloud, where they can be monitored and recorded. This feature automatically creates in the Arduino Cloud everything needed to monitor the sensors (the Device, the Thing, and a dashboard).

Starting to play with real hardware can be tricky for non-experienced users, so this feature enables users to get familiar with the Arduino Cloud device management environment using their own phone. Easy, right?

This feature was limited to having the app open at all times. But, what if you wanted to use your mobile phone’s sensors to be monitored continuously thereby enabling them to be used for real projects? For that, you’d need to run the app in background mode.

Voilà… the new background mode!

Now, you have the possibility to run the Arduino IoT Remote app in the background on demand. With this feature, your phone sensors are polled continuously and the data is sent to the Arduino Cloud in real-time. The polling periodicity and the thresholds have been smartly defined in order to optimize the battery consumption, and the feature can be enabled or disabled as desired.

The key benefits of the original “Use data from your phone” feature are still available, in that you can automatically see your phone as a usable device in the IoT cloud, along with a number of variables automatically created and associated with it. Those variables are associated with some of the sensors in your phone such as accelerometer, GPS, microphone, compass, or barometer. Additionally, a dashboard is also automatically created so that all those variables can be monitored.

Do you need some inspiration?

Unleash your creativity with the new feature! With it, a whole new world of possibilities opens up. You can now develop applications that merge data from your phone with real-world actions. Here are some examples:

  • Geofencing: Use virtual geographic boundaries to trigger actions based on your location.
  • Home automation: Automate tasks at home based on your location. For example, turn lights off when you leave and on when you return, lock doors, and adjust home climate control.
  • Child/elder care: Keep track of loved ones with geofencing. Get instant notifications if they leave designated areas.
  • Accident detection: Use your phone’s accelerometer to detect sharp decelerations and detect accidents or falls.
  • Gaming: Use your phone as a remote control for a robot or a game. The sky’s the limit!

Only your imagination sets the boundaries of what you can do with this new feature.

Fall detection project

Fall detection using your phone and Arduino Cloud

Short of ideas? No worries! Check out this project out if you want to see a real use case and give it a try. This project demonstrates how to use your mobile phone as an IoT device using the phone device feature. By streaming data from your phone’s accelerometer to the Cloud and using an Arduino Nano RP240 Connect, a fall detection system is formed. If sudden acceleration is detected above a certain threshold, an LED on the board is switched on to alert anyone nearby

How do I get started?

Working with the Phone as a background device is a simple process. However, before you begin, ensure that you have the latest version of the app installed on your device. It’s worth noting that the app is compatible with both Android and iOS. platforms.

Enable the “Phone as Device” feature

To proceed, navigate to the “Phone as Device” option on the app’s navigation bar, then follow the instructions to grant the app access to your phone’s sensors.

Enable the Phone as Device feature on the Arduino IoT Cloud remote app

Enable the background mode

Once you’ve completed the previous step, you’ll receive a prompt to enable the “Background mode” feature. You can either activate it immediately or do so manually at a later time. You can also select how your device will stream data to the IoT Cloud:

  • Periodically: Data will be streamed to the cloud at regular intervals that you specify.
  • On change: Data will be streamed to the cloud whenever there is a change in the value being measured.
Enable the background mode of the Phone as Device feature on the Arduino IoT Cloud remote app

Start playing with your dashboards

You now can go to your automatically created dashboard and check how your phone sensors are monitored according to the rules you have configured.

Enable the background mode of the Phone as Device feature on the Arduino IoT Cloud remote app

Arduino IoT Cloud Remote dashboards

Learn more

If you want to learn more about the “Phone as Device”  feature and the background mode, we recommend reviewing the article on the documentation. Kindly note that the Background mode is a feature that comes with the Maker plan or higher. However, we strongly recommend it to anyone seeking anyone looking to enhance their projects using their phone data. Upgrading to a paid subscription is a straightforward process, and you’ll receive extra features to maximise our platform’s capabilities.

To learn more about the Arduino IoT Cloud, please visit the official documentation and resources available on the Arduino Cloud web site.

The post Get more out of your phone: Integrate it with your Arduino Cloud projects appeared first on Arduino Blog.

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 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.

MKR-IoT-Carrier-rev2

If you’re looking for an ever faster, smoother, and more rewarding way to build your own IoT projects at home, the new MKR IoT Carrier Rev2 could be perfect for you.

The new carrier can work with any board from the MKR family, giving you a wide choice of connectivity options to match the needs of your next IoT project. With the MKR IoT Carrier Rev2 you don’t need any additional components to get started, and you can build impressive and complete hassle free projects this way.

What does the carrier include? You’ll get all the sensors and actuators you need to build IoT projects and connect them to the internet, taking your home automation journey to the next level.

Let’s take a quick look at what you can build with the MKR IoT Carrier Rev2 and any board from the MKR family.

  • Environment monitoring stations. The new carrier comes with sensors that allow you to map and measure various things in the world around you — temperature, humidity, air quality, barometric pressure, and more. You can also track the movement of the board. For even more sensory awareness, you can connect analog or I2C grove compatible modules to the grove connectors. You can store the data you collect in the SD card or send it directly to the Arduino IoT Cloud.
  • GUI IoT interface. Visualizing your data is incredibly important — and the Rev2 comes with its own OLED color display, allowing you to create your own navigation menus. You can also use the included LEDs and buzzer for feedback.
  • Connect to and control external devices. The IoT is all about networks, and with the Rev2 you can control electronic devices up to 24 Volts using the two on-board relays. You can do this manually — like switching your reading lamp on or off via the Arduino IoT Cloud Remote app, or you can set the lamp to behave according to sensor data like the light levels in the room.

The MKR IoT Carrier vs the MKR IoT Carrier Rev2 — what’s the difference?

There are a few key differences between the Rev2 and the previous version of the MKR IoT Carrier. Here are the main ones.

Some sensors have changed:

  • The humidity sensor (HTS221) and barometric pressure sensor (LP22HB)  has been replaced with the BME6688 sensor.
  • The IMU (LSM6DS3) was replaced with LSM6DSOX.

Following customer feedback some other components have been repositioned:

  • Addition of a handy reset button
  • 90° rotation of the relay connectors
  • Repositioning of the light sensor (APDS-9960)
  • Change of pins assigned to control the relays to pins 1 and 2
  • Change grove connector assignment from pin A5 to A6 

Do I have to change my sketch if I have been using the first revision of the MKR IoT Carrier?

No — the MKR IoT Carrier library works with both revisions of the carrier. Just make sure to use the latest version of the library to ensure everything goes smoothly.

Have more fun with the IoT

The new MKR IoT Carrier Rev2 is the perfect tool to get started having fun with your own IoT projects, or to take your IoT tinkering to the next level. You don’t need a ton of experience, a bucket of expensive components, or endless hours of free time to build your own satisfying, useful IoT gadgets at home.

The post Introducing the new MKR IoT Carrier Rev2: Time to start your next IoT project appeared first on Arduino Blog.

Introducing Arduino’s IoT Bundle and What it Means for You

We’re excited to announce the launch of the new Arduino IoT Bundle. This is built to help you dive into the complex and fascinating world of the Internet of Things with even more confidence and possibility — giving you the hardware, software, and components you need to build your own connected IoT projects.

So how does it all work? Let’s find out more.

What is the Arduino IoT Bundle?

Getting started with the IoT can be a daunting process. It requires a certain set of tools and a level of knowledge to take those first steps, but building your own connected IoT devices can be an incredibly rewarding process once you figure out the basics.

Arduino IoT Bundle unbox

The Arduino IoT Bundle is designed to bring together all the tools and knowledge you’ll need to get started with your first connected IoT devices. It’s built around the Arduino Nano RP2040 Connect, and the bundle also contains electronic components and a series of step-by-step tutorials to help you get started quickly and confidently.

How it works — some examples

The IoT is an incredibly rich area when it comes to building your own connected projects. There are a ton of exciting opportunities here that don’t require an enormous amount of knowledge or resources to get started with.

Let’s take a look at some examples of IoT projects, you’ll find more in the bundle:

Pavlov’s Cat

Training a cat is a tricky business, as any feline owner will know all too well. However, you can now use technology to make this task easier, using an IoT-enabled device you build at home to keep your cats in line.

This project — using only components found in the Arduino IoT Bundle and some cardboard — allows you to build a device that plays a certain melody whenever it dispenses food for your cat. At other times, it will play a different tune and your furry friend gets nothing. 

Just like Pavlov and his famous dogs, you’ll be able to train your cat to associate certain sounds with a reward — teaching your cat when it’s time for dinner.

The Nerd

Remember the days of the Tamagotchi? Caring for a digital pet was something millions of people devoted large chunks of their day to (or not, in the case of the many deceased Tamagotchis).

Now, with Arduino’s IoT Bundle, you can make your own digital pet. The Nerd lives on your desktop and survives by eating food and absorbing sunlight. Your task is easy: just make sure it’s adequately fed and has enough light to bask in. The Nerd will even help you by sending you an SOS in Morse code through a built-in speaker when it’s getting hungry.

You can feed The Nerd by pressing a button which is connected to the Arduino Cloud. Just don’t forget to keep on top of things — these creatures don’t die quietly.

Puzzle Box

This puzzle box is designed to keep your belongings safe(ish) in a cardboard container which is controlled by a fun combination lock. All you need is a few pieces of cardboard and the components from the Arduino IoT Bundle.

The box is kept closed with a servo motor, and will only open up if you turn all the potentiometers to get the right combination for access. You can set the combination in the Arduino IoT Cloud dashboard. To make things more fun, an LED on the box gives you feedback in the form of different coloured lights, letting you know how close you are to guessing the correct combination and gaining access to the box.

The puzzle box works best as a fun game to entertain others, rather than an actual security feature — but it’s still well worth giving a try.

Tap into the IoT with Arduino

Arduino’s IoT Bundle is the perfect introduction to tinkering around with your very own IoT devices at home. It gives you everything you need to get started with some simple projects, and requires very few pre-existing components and not much prior experience at all.

The post Introducing Arduino’s IoT Bundle and what it means for you appeared first on Arduino Blog.

This week we are launching our  Arduino Explore IoT Kit, which allows high school and college students to take their first steps in building connected devices. Educators can make a complex subject simple – explore the Internet of Things right now with Arduino Education. 

Aimed at the beginner,  there is a complete set of easy to follow online projects providing students with a  gateway into the digital world of connected objects and how people work together.

The kit comes complete with a complimentary 12 months subscription to the Arduino Create Maker plan, meaning it’s quicker and easier than ever to learn how to monitor, manage and control devices using the cloud – with the new Arduino IoT Cloud Remote app you can now do this ‘on the go’ via your mobile.

We recently spoke to Sara Willner-Giwerc, (a PhD candidate at Tufts University in Boston, Massachusetts, US) about her amazing work using the Internet of Things in education – helping to show just how useful the new Explore IoT Kit will be.

“By leveraging the Internet of Things, students are able to build more powerful systems that are no longer limited to only the resources they physically possess. This technological capability presents a cool opportunity for students to experience how they can be more powerful when they connect and collaborate with others than they can be on their own. “

“Especially now, in this time of social distancing and remote learning, the ability to communicate with devices that aren’t physically near us has become even more essential than it was previously. I’m really excited about the idea of using IoT to help students think about designing for more global systems.” 

Read the full article about Sara here

Here’s what a student had to say about the new Explore IoT Kit, when he got the chance to try out an advanced version:

“I would describe it as a very beginner-friendly way to get started with the Internet of Things, and a kit that you will be able to expand upon with your own ideas and components.”

“…the getting started section got me really excited to actually get started because it inspired all these thought streams of what I could potentially create with the kit.” Oliver Kempel – Danish High School Student 

The kit features 10 activities for students to develop a complete understanding of IoT:

  • Using the IoT Cloud and connected devices: Control physical objects, such as a displays or lights, remotely with the Arduino IoT Cloud
  • Collecting, processing, and storing data: Store data locally, wirelessly, and remotely for analysis and backup
  • Graphing and visualizing data and understanding its meaning: Use different tools and techniques to graph data and interpret the information collected
  • Serial communication, APIs, JSON, and web servers: Learn the essentials of how APIs (application programming interfaces) work, how to access remote web servers, and how to store the incoming data in JSON objects to create devices that can access all sorts of data from all over the world, and display it locally
  • Network security considerations: Understand how software developers protect devices and information from unauthorized access
  • Different sensors and how to use them: Investigate the environment using temperature, humidity, and light sensors, collect data about movement using an accelerometer, pressure, and motion sensors, take care of your plants by following the data from moisture and light sensors
  • Actuators and how to use them: Use lights, sound, display, and relays: electronic components used to activate high power devices, to visualize data, and control external devices

The Explore IoT Kit is available to buy now from our Education Partners locally or from the Arduino Store for only €99 / $114.

N.B. In addition to the Explore IoT Kit,  a second kit the “Oplà IoT Kit” will also be coming soon, targeting makers and professionals alike who are after an out-of-the-box IoT experience. The Oplà IoT Kit will enable users to instantly add connectivity to devices for the home and workplace – available to buy from early October onwards.

Arduino SIM: 10MB Free Data for Up to 90 Days!

The new Arduino SIM offers the simplest path to cellular IoT device development in an environment familiar to millions. The cellular service, provided by Arm Pelion Connectivity Management, has a global roaming profile; meaning a single Arduino SIM can be used in over 100 countries worldwide with one simple data plan.

The Plan

  • Arduino SIM comes with 10 MB of data free for the first days 90 days,
  • One simple subscription at 5 MB for $1.50 USD per month*.
  • Global roaming profile – enjoy the same amount of data traffic for the same price wherever you are operating the device around the world.
  • Cellular connectivity to the Arduino IoT Cloud – monitor and control your devices anytime, anywhere.
  • Ideal for connected devices on the go or in areas without reliable WiFi.

*The monthly Arduino SIM plan is currently only available to U.S. residents

By partnering with Arm Pelion Connectivity Management, the cellular service has a solid foundation for users needing to scale form a single to large numbers of devices in the future.

At launch, the Arduino SIM will allow users to send data into the Arduino IoT Cloud, while later in the year they will also be able to use the Arduino SIM to connect to the Internet via a combination of webhooks and APIs.

Arduino SIM is initially rolling out with support for the Arduino MKR GSM 1400 (3G with 2G fallback) – a 32-bit Arduino board supporting TLS and X.509 certificate-based authentication through an on-board secure element and crypto-accelerator. Arduino IoT Cloud makes it possible for anyone to connect to these boards securely without any coding required, but they are still programmable using open-source libraries and the traditional Arduino IDE.  

Now available to pre-order from the Arduino U.S. Store!



  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook