Read sensor data and control actuators
Communicate with other devices via Wi-Fi, Ethernet, or serial interfaces
Control motors, LEDs, and other peripherals
Run advanced algorithms and data analytics
Interface with external devices, such as LCD displays, keyboards, and cameras
Key Features
Atmel SAM3X8E ARM Cortex-M3 CPU
84 MHz
512 KB
96 KB
16 KB
| Digital I/O Pins | 54 (12 of which are PWM outputs) |
12 (2 of which can be used as digital pins)
4
2
| I2Cs | 2 |
1
1
1
3.3 V
200-400 mA
Additional Features
| DAC (Digital-to-Analog Converter) | 2 channels, 12-bit resolution |
| DMA (Direct Memory Access) | Supported |
| RTC (Real-Time Clock) | Integrated |
| TWI (Two-Wire Interface) | Supported |
Advantages
High-performance Cortex-M3 CPU
Large memory and storage capacity
Multiple communication interfaces (Ethernet, USB, UART, SPI, I2C, CAN)
Advanced peripherals (DAC, DMA, RTC)
Compatible with a wide range of shields and modules
Open-source and community-supported
Limitations
Higher power consumption compared to other Arduino boards
Requires an external power supply (cannot be powered via USB)
Limited compatibility with some Arduino shields and libraries (due to its ARM architecture)
Target Applications
IoT projects requiring high-performance processing and advanced peripherals
Robotics and automation projects
Industrial control and monitoring systems
Advanced hobbyist and prototyping projects
Conclusion
The Arduino Due Original is a powerful and feature-rich microcontroller board that offers a high degree of flexibility and customization. Its advanced peripherals, high-performance CPU, and multiple communication interfaces make it an ideal choice for complex IoT projects and applications.
Arduino Due Original Component DocumentationOverviewThe Arduino Due Original is a microcontroller board based on the Atmel SAM3X8E ARM Cortex-M3 CPU. It is an advanced board that offers a significant increase in performance and functionality compared to other Arduino boards.Technical SpecificationsMicrocontroller: Atmel SAM3X8E ARM Cortex-M3 CPU
Operating Voltage: 3.3V
Input Voltage: 7-12V
Digital I/O Pins: 54
Analog Input Pins: 12
Analog Output Pins: 2
Flash Memory: 512 KB
SRAM: 96 KB
Clock Speed: 84 MHzCode Examples### Example 1: Blinking an LED using Digital PinsThis example demonstrates how to use the Arduino Due Original's digital pins to control an LED.```c++
const int ledPin = 13; // Pin 13 for the LEDvoid setup() {
pinMode(ledPin, OUTPUT); // Set the pin as an output
}void loop() {
digitalWrite(ledPin, HIGH); // Turn the LED on
delay(1000); // Wait for 1 second
digitalWrite(ledPin, LOW); // Turn the LED off
delay(1000); // Wait for 1 second
}
```In this example, we define a constant `ledPin` to represent the digital pin 13, which is connected to an LED. In the `setup()` function, we set the pin as an output using `pinMode()`. In the `loop()` function, we use `digitalWrite()` to turn the LED on and off by setting the pin high and low, respectively.### Example 2: Reading Analog Input from a SensorThis example demonstrates how to use the Arduino Due Original's analog input pins to read data from a sensor.```c++
const int sensorPin = A0; // Pin A0 for the sensor
int sensorValue = 0; // Variable to store the sensor readingvoid setup() {
Serial.begin(9600); // Initialize serial communication at 9600 bps
}void loop() {
sensorValue = analogRead(sensorPin); // Read the sensor value
Serial.print("Sensor Value: ");
Serial.println(sensorValue); // Print the sensor value to the serial monitor
delay(100); // Wait for 100 ms before taking the next reading
}
```In this example, we define a constant `sensorPin` to represent the analog input pin A0, which is connected to a sensor. We also define a variable `sensorValue` to store the sensor reading. In the `setup()` function, we initialize serial communication at 9600 bps using `Serial.begin()`. In the `loop()` function, we use `analogRead()` to read the sensor value, and then print the value to the serial monitor using `Serial.print()` and `Serial.println()`.### Example 3: Using the Due's Built-in Real-Time Clock (RTC)This example demonstrates how to use the Arduino Due Original's built-in RTC to keep track of time.```c++
#include <RTClib.h> // Include the RTC libraryRTC_DS1307 rtc; // Create an instance of the RTC classvoid setup() {
rtc.begin(); // Initialize the RTC
}void loop() {
DateTime now = rtc.now(); // Get the current timeSerial.print(now.year(), DEC);
Serial.print('/');
Serial.print(now.month(), DEC);
Serial.print('/');
Serial.print(now.day(), DEC);
Serial.print(' ');
Serial.print(now.hour(), DEC);
Serial.print(':');
Serial.print(now.minute(), DEC);
Serial.print(':');
Serial.print(now.second(), DEC);
Serial.println();delay(1000); // Wait for 1 second before displaying the time again
}
```In this example, we include the `RTClib` library and create an instance of the `RTC_DS1307` class to interact with the RTC. In the `setup()` function, we initialize the RTC using `rtc.begin()`. In the `loop()` function, we use `rtc.now()` to get the current time, and then print it to the serial monitor in the format `YYYY/MM/DD HH:MM:SS`.