Arduino Nano 33 IoT Motion Monitoring with OLED Display

The Arduino Nano 33 IoT is a versatile IoT development board that contains a powerful built-in IMU sensor, making it ideal for the Arduino Nano 33 IoT IMU project. This guide will focus on creating an Arduino Nano 33 IoT Motion Monitoring, where we use the internal LSM6DS3 accelerometer gyroscope to capture motion data and display it immediately. By pairing the board with an OLED SSD1306 Arduino display, we can create a self-contained unit for real-time motion data display. This setup is a fantastic way to learn about Arduino motion sensor visualization and the capabilities of this tiny but powerful IoT development board.

Overview Arduino Nano 33 IoT Motion Monitoring

Our goal is to create a complete embedded systems project that effectively uses the onboard LSM6DS3 IMU for real-time visualization. The Arduino Nano 33 IoT acts as the central processor, reading the raw acceleration values and angular velocity from the LSM6DS3 accelerometer gyroscope. This motion data is then sent via the I2C communication protocol to the compact OLED SSD1306 display, resulting in the OLED display real-time motion data. This demonstration of IMU data visualization Arduino is highly relevant for applications like wearable motion tracking and robotics motion analysis, providing instant visual feedback on axis movement and orientation change.

What You Will Learn. 

By completing this project, you will gain practical knowledge in:

• Interfacing the built-in IMU sensor of the Arduino Nano 33 IoT sensor interfacing.
• Utilizing the LSM6DS3 library to read accelerometer and gyroscope data.
• Implementing I2C OLED display Arduino I2C communication for the SSD1306 OLED.
• Creating sensor data visualization techniques for real-time display of motion data.
• The fundamental process of motion tracking using Arduino Nano 33 IoT for various embedded motion sensing projects.

Components Required 

Arduino Nano 33 IoT

This board is a compact, 3.3V-operating IoT development board that includes the LSM6DS3 accelerometer gyroscope directly on the PCB. This eliminates the need for external wiring for the IMU itself. It’s perfect for low-power motion sensing and handling the I2C communication required for the OLED display, forming a complete Arduino-based motion system. [Learn more]

SSD1306 OLED Display 128×64

 The OLED SSD1306 is a small, high-contrast, self-illuminating display that uses minimal power. Its simple I2C interface makes it ideal for projects where power and size are critical. It acts as the output screen for the IMU data visualization Arduino and the OLED SSD1306 motion display, making the motion data instantly understandable. [Learn more]

Circuit Diagram 

The main connections are between the Arduino Nano 33 IoT and the external OLED SSD1306 display. The LSM6DS3 is already connected internally via the Arduino‘s internal I2C communication.

Build Guide Step-by-Step 🛠️

Step 1: Wiring Connections

The SSD1306 OLED Display 128×64 uses the standard I2C communication pins on the Arduino Nano 33 IoT. The I2C protocol requires only two data wires: SDA (Serial Data) and SCL (Serial Clock).

This simple I2C OLED display Arduino connection forms the real-time visualization output for your project.

Step 2: Arduino IDE Configuration and Library Setup

To successfully compile and run the code for the LSM6DS3 accelerometer gyroscope project, you need two essential libraries:

1. Arduino_LSM6DS3: This library handles the communication and data retrieval from the built-in IMU sensor. Install it via the Library Manager.
2. Adafruit SSD1306: This library is used to control the OLED SSD1306 display. Install both the Adafruit SSD1306 and the required Adafruit GFX library.

Arduino Code 💻

The Arduino sketch initializes the LSM6DS3 IMU and the OLED display. In the main loop, it continuously reads the acceleration values and angular velocity (motion data). This raw data is then formatted and written to the OLED SSD1306 motion display, creating the Arduino IMU data visualization. Crucially, the code handles the sensor calibration offsets and updates the display quickly for effective real-time visualization of the axis movement and orientation change.

1. #include <Wire.h>
2. #include <Arduino_LSM6DS3.h>
3. #include <Adafruit_GFX.h>
4. #include <Adafruit_SSD1306.h>
5. #include <math.h>
7. #define SCREEN_WIDTH 128
8. #define SCREEN_HEIGHT 64
9. Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
11. float angle = 0; // Radar sweep angle
12. const int radarRadius = 30;
13. const int centerX = SCREEN_WIDTH/2;
14. const int centerY = SCREEN_HEIGHT/2;
16. // Motion detection threshold
17. const float motionThreshold = 0.15;
19. void setup() {
20. Serial.begin(9600);
22. // Initialize IMU
23. if (!IMU.begin()) {
24. Serial.println("Failed to initialize IMU!");
25. while(1);
26. }
28. // Initialize OLED
29. if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
30. Serial.println("SSD1306 allocation failed");
31. for (;;);
32. }
34. display.clearDisplay();
35. display.setTextSize(1);
36. display.setTextColor(SSD1306_WHITE);
37. display.setCursor(10, 0);
38. display.println("Motion Visualizer");
39. display.display();
40. delay(800);
41. }
43. void loop() {
44. float xAcc, yAcc, zAcc;
45. bool motionDetected = false;
47. if (IMU.accelerationAvailable()) {
48. IMU.readAcceleration(xAcc, yAcc, zAcc);
50. // Calculate overall acceleration magnitude
51. float magnitude = sqrt(xAcc*xAcc + yAcc*yAcc + zAcc*zAcc);
53. // Detect motion
54. motionDetected = magnitude > motionThreshold;
56. display.clearDisplay();
58. if(motionDetected){
59. // Display motion detected text
60. display.setTextSize(2);
61. display.setCursor(10, SCREEN_HEIGHT/2 - 10);
62. display.println("Motion Detected!");
63. } else {
64. // Radar animation
65. display.drawCircle(centerX, centerY, radarRadius, SSD1306_WHITE);
66. display.drawCircle(centerX, centerY, radarRadius-5, SSD1306_WHITE);
68. int x = centerX + radarRadius * cos(angle);
69. int y = centerY + radarRadius * sin(angle);
70. display.drawLine(centerX, centerY, x, y, SSD1306_WHITE);
72. angle += 0.1;
73. if(angle > 2*3.14159) angle = 0;
75. // Draw radar center
76. display.fillCircle(centerX, centerY, 2, SSD1306_WHITE);
77. }
79. display.display();
80. }
82. delay(30);
83. }

Applications 

The Arduino Nano 33 IoT motion visualizer can be applied in various fields:

• Wearable Motion Tracking: Monitoring physical activity, steps, and posture in wearable motion tracking devices.
• Robotics Motion Analysis: Measuring the tilt and rotation of robot joints for precise robotics motion analysis.
• Simple Tilt/Shock Logger: Detecting motion detection and recording the magnitude of impacts.
• Gaming Controller: Using the IMU data to control characters or actions in video games.
• Low-power motion sensing applications for long-term battery-powered monitoring.

FAQs ❓

• Can Arduino Nano run an OLED display?
  

  Yes, the Arduino Nano (including the Arduino Nano 33 IoT) can easily run an OLED SSD1306 display using the I2C communication protocol.

• How to connect an OLED display to Arduino?
  

  The OLED display is connected to the Arduino via the I2C communication pins: SDA to A4 and SCL to A5 on the Arduino Nano 33 IoT.

• Do Arduino Nano 33 IoT have gyrometers in them?
  

  Yes, the Arduino Nano 33 IoT has a built-in IMU sensor (LSM6DS3) which contains both an accelerometer and a gyroscope.

• What is the difference between Nano 33 IoT and ble?
  The Nano 33 IoT focuses on Wi-Fi and IoT capabilities, while the Nano 33 BLE focuses on Bluetooth Low Energy Wireless communication for simple sensor interfacing.

• What are the disadvantages of Arduino Nano?
  

  The older Arduino Nano has limited processing power; however, the Arduino Nano 33 IoT addresses this with a more powerful Microcontroller and built-in IMU sensor.

• Is Arduino Nano better than ESP32?
  

  The Arduino Nano 33 IoT is better for simplicity and seamless integration into the Arduino ecosystem and has a built-in IMU sensor, while the ESP32 often offers more processing power.

Conclusion 

This project provides a comprehensive guide to utilizing the powerful LSM6DS3 accelerometer gyroscope embedded in the Arduino Nano 33 IoT. By successfully implementing the I2C OLED display Arduino connection, we created a functional Motion visualization using Arduino Nano 33 IoT system. This Arduino IMU data visualization project is a valuable step for anyone interested in low-power motion sensing and sensor data visualization within an IoT context.

Related Posts 🔗

• Arduino Nano 33 IoT Sensor Projects

• IMU Basics for Embedded Systems

• OLED Display Projects with Arduino