Opta™ User Manual

Copy
1void setup() {
2  // Initialize LED_BUILTIN as an output 
3  pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7  // Turn the user LED (RESET) off
8  digitalWrite(LED_BUILTIN, HIGH);
9  delay(1000);
10  // Turn the user LED (RESET) on
11  digitalWrite(LED_BUILTIN, LOW);
12  delay(1000);
13}

Copy
1/**
2  Opta's Analog Input Terminals
3  Name: opta_analog_inputs_example.ino
4  Purpose: This sketch demonstrates the use of I1, I2, and I3 input 
5  terminals as analog inputs on Opta.
6
7  @author Arduino PRO Content Team
8  @version 2.0 22/07/23
9*/
10
11// Define constants for voltage, resolution, and divider.
12const float VOLTAGE_MAX   = 3.0;      // Maximum voltage that can be read
13const float RESOLUTION    = 4095.0;   // 12-bit resolution
14const float DIVIDER       = 0.3;      // Voltage divider
15
16// Array of terminals.
17const int TERMINALS[] = {A0, A1, A2};
18
19// Number of terminals.
20const int NUM_PINS = 3;
21
22void setup() {
23  // Initialize serial communication at 9600 bits per second.
24  Serial.begin(9600);
25
26  // Enable analog inputs on Opta
27  // Set the resolution of the ADC to 12 bits.
28  analogReadResolution(12);
29}
30
31void loop() {
32  // Loop through each of the terminal, read the terminal analog value, convert it to voltage, and print the result.
33  for (int i = 0; i < NUM_PINS; i++) {
34    readAndPrint(TERMINALS[i], i + 1);
35  }
36
37  // Delay for a second before reading the terminals again.
38  delay(1000);
39}
40
41// This function reads the value from the specified pin, converts it to voltage, and prints the result.
42void readAndPrint(int terminal, int terminalNumber) {
43  // Read the input value from the analog pin.
44  int terminalValue = analogRead(terminal);
45
46  // Convert the terminal value to its corresponding voltage. 
47  float voltage = terminalValue * (VOLTAGE_MAX / RESOLUTION) / DIVIDER;
48
49  // Print the terminal value and its corresponding voltage.
50  Serial.print("I");
51  Serial.print(terminalNumber);
52  Serial.print(" value: ");
53  Serial.print(terminalValue);
54  Serial.print(" corresponding to ");
55  Serial.print(voltage, 5);
56  Serial.println(" VDC");
57}

Copy
1/**
2  Opta's Digital Input Terminals
3  Name: opta_digital_inputs_example.ino
4  Purpose: This sketch demonstrates the use of I1, I2, and I3 input
5  terminals as digital inputs on Opta.
6
7  @author Arduino PRO Content Team
8  @version 2.0 23/07/23
9*/
10
11// Array of terminals.
12const int TERMINALS[] = {A0, A1, A2};
13
14// Number of terminals.
15const int NUM_PINS = 3;
16
17void setup() {
18  // Initialize serial communication at 9600 bits per second.
19  Serial.begin(9600);
20
21  // Set the mode of the pins as digital inputs.
22  for (int i = 0; i < NUM_PINS; i++) {
23    pinMode(TERMINALS[i], INPUT);
24  }
25}
26
27void loop() {
28  // Loop through each of the terminal, read the terminal digital value, and print the result.
29  for (int i = 0; i < NUM_PINS; i++) {
30    readAndPrint(TERMINALS[i], i + 1);
31  }
32
33  // Delay for a second before reading the terminals again.
34  delay(1000);
35}
36
37// This function reads the digital value from the specified pin and prints the result.
38void readAndPrint(int terminal, int terminalNumber) {
39  // Read the input value from the digital pin.
40  int terminalValue = digitalRead(terminal);
41  
42  // Print the terminal value.
43  Serial.print("I");
44  Serial.print(terminalNumber);
45  Serial.print(" value: ");
46  Serial.println(terminalValue);
47}

Copy
1/**
2  Opta's Knight Rider Scanning Effect
3  Name: opta_knight_rider_example.ino
4  Purpose: This sketch demonstrates a Knight Rider scanning effect using 
5  the user LEDs of Opta devices.
6
7
8  @author Arduino PRO Content Team
9  @version 2.0 22/07/23
10*/
11
12// Define an array to hold the pin numbers for Opta's user LEDs.
13const int USER_LEDS[] = {LED_D0, LED_D1, LED_D2, LED_D3};
14
15// Number of Opta's user LEDs
16const int NUM_LEDS = 4;
17
18void setup() {
19  // Set the mode for each user LED to OUTPUT.
20  for (int i = 0; i < NUM_LEDS; i++) {
21    pinMode(USER_LEDS[i], OUTPUT);
22  }
23}
24
25void loop() {
26  // Scan from the first LED to the last.
27  for (int i = 0; i < NUM_LEDS; i++) {
28    // Turn on the LED.
29    // Wait for 50 milliseconds.
30    digitalWrite(USER_LEDS[i], HIGH); 
31    delay(50); 
32    // Turn off the LED.
33    // Wait for 50 milliseconds.
34    digitalWrite(USER_LEDS[i], LOW); 
35    delay(50); 
36  }
37  
38  // Scan back from the last LED to the first.
39  for (int i = NUM_LEDS - 1; i >= 0; i--) {
40    // Turn on the LED.
41    // Wait for 50 milliseconds.
42    digitalWrite(USER_LEDS[i], HIGH); 
43    delay(50); 
44    // Turn off the LED.
45    // Wait for 50 milliseconds.
46    digitalWrite(USER_LEDS[i], LOW); 
47    delay(50); 
48  }
49}

Copy
1void setup() {
2  // Initialize LED_USER as an output 
3  pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7  // Turn the USER LED off
8  digitalWrite(LED_BUILTIN, HIGH);
9  delay(1000);
10  // Turn the USER LED on
11  digitalWrite(LED_BUILTIN, LOW);
12  delay(1000);
13}

Copy
1/**
2  Opta's User Button Example
3  Name: opta_user_button_example.ino
4  Purpose: Configures Opta's user-programmable button to control the user LEDs.
5  This example includes debouncing for the user button.
6
7  @author Arduino PRO Content Team
8  @version 2.0 23/07/23
9*/
10
11// Current and previous state of the button.
12int buttonState     = 0;
13int lastButtonState = 0;
14
15// Counter to keep track of the LED sequence.
16int counter = 0;
17
18// Variables to implement button debouncing.
19unsigned long lastDebounceTime  = 0;
20unsigned long debounceDelay     = 50; // In ms
21
22// Array to store LED pins.
23int LEDS[] = {LED_D0, LED_D1, LED_D2, LED_D3};
24int NUM_LEDS = 4;
25
26void setup() {
27  // Initialize Opta user LEDs.
28  for(int i = 0; i < NUM_LEDS; i++) {
29    pinMode(LEDS[i], OUTPUT);
30  }
31  pinMode(BTN_USER, INPUT);
32}
33
34void loop() {
35  int reading = digitalRead(BTN_USER);
36  
37  // Check if button state has changed.
38  if (reading != lastButtonState) {
39    lastDebounceTime = millis();
40  }
41
42  // Debouncing routine.
43  if ((millis() - lastDebounceTime) > debounceDelay) {
44    if (reading != buttonState) {
45      buttonState = reading;
46
47      // Only increment the counter if the new button state is HIGH.
48      if (buttonState == HIGH) {
49        if(counter < NUM_LEDS){
50          counter++;
51        }
52        else{
53          counter = 0;
54        }
55      }
56    }
57  }
58
59  // Save the current state as the last state, for next time through the loop.
60  lastButtonState = reading;
61  
62  // Control LED states.
63  changeLights();
64}
65
66/**
67  Control the status LEDs based on a counter value.
68  Turns off all LEDs first, then turns on the LED 
69  corresponding to the current counter value.
70
71  @param None.
72*/
73void changeLights() {
74  // Turn off all user LEDs.
75  for(int i = 0; i < NUM_LEDS; i++) {
76    digitalWrite(LEDS[i], LOW);
77  }
78
79  // Turn on the selected user LED.
80  if(counter > 0) {
81    digitalWrite(LEDS[counter - 1], HIGH);
82  }
83}

Copy
1/*
2  Opta's Output Relays 
3  Name: opta_outputs_relays_example.ino
4  Purpose: This sketch tests the output relays of Opta devices.
5
6
7  @author Arduino PRO Content Team
8  @version 2.0 22/07/23
9*/
10
11// Arrays of relays and user LEDs
12int relayOutputs[] = {D0, D1, D2, D3};
13int userLeds[] = {LED_D0, LED_D1, LED_D2, LED_D3};
14
15// Compute the number of relays/LEDs based on the size of the relayPins array
16int numRelays = 4;
17
18void setup() {
19  for(int i = 0; i < numRelays; i++) {
20    // Sets the mode of the relays and user LEDs as outputs
21    pinMode(relayOutputs[i], OUTPUT); 
22    pinMode(userLeds[i], OUTPUT); 
23  }
24}
25
26void loop() {
27  // For each relay/user LED: turn it on, wait for a second, turn it off, wait for another second
28  for(int i = 0; i < numRelays; i++) {
29    digitalWrite(relayOutputs[i], HIGH); 
30    digitalWrite(userLeds[i], HIGH);
31    delay(1000);
32    digitalWrite(relayOutputs[i], LOW);
33    digitalWrite(userLeds[i], LOW);
34    delay(1000);
35  }
36}

Copy
1/**
2  Web Client (Ethernet version)
3  Name: opta_ethernet_web_client.ino
4  Purpose: This sketch connects an Opta device to ip-api.com via Ethernet
5  and fetches IP details for the device.
6
7  @author Arduino PRO Content Team
8  @version 2.0 15/08/23
9*/
10
11// Include the necessary libraries.
12#include <Ethernet.h>
13#include <Arduino_JSON.h>
14
15// Server address for ip-api.com.
16const char* server = "ip-api.com";
17
18// API endpoint path to get IP details in JSON format.
19String path = "/json/";
20
21// Static IP configuration for the Opta device.
22IPAddress ip(10, 130, 22, 84);
23
24// Ethernet client instance for the communication.
25EthernetClient client;
26
27// JSON variable to store and process the fetched data.
28JSONVar doc;
29
30// Variable to ensure we fetch data only once.
31bool dataFetched = false;
32
33void setup() {
34  // Begin serial communication at a baud rate of 115200.
35  Serial.begin(115200);
36
37  // Wait for the serial port to connect,
38  // This is necessary for boards that have native USB.
39  while (!Serial);
40
41  // Attempt to start Ethernet connection via DHCP,
42  // If DHCP failed, print a diagnostic message.
43  if (Ethernet.begin() == 0) {
44    Serial.println("- Failed to configure Ethernet using DHCP!");
45
46    // Try to configure Ethernet with the predefined static IP address.
47    Ethernet.begin(ip);
48  }
49  delay(2000);
50}
51
52void loop() {
53  // Ensure we haven't fetched data already,
54  // ensure the Ethernet link is active,
55  // establish a connection to the server,
56  // compose and send the HTTP GET request.
57  if (!dataFetched) {
58    if (Ethernet.linkStatus() == LinkON) {
59      if (client.connect(server, 80)) {
60        client.print("GET ");
61        client.print(path);
62        client.println(" HTTP/1.1");
63        client.print("Host: ");
64        client.println(server);
65        client.println("Connection: close");
66        client.println();
67
68        // Wait and skip the HTTP headers to get to the JSON data.
69        char endOfHeaders[] = "\r\n\r\n";
70        client.find(endOfHeaders);
71
72        // Read and parse the JSON response.
73        String payload = client.readString();
74        doc = JSON.parse(payload);
75
76        // Check if the parsing was successful.
77        if (JSON.typeof(doc) == "undefined") {
78          Serial.println("- Parsing failed!");
79          return;
80        }
81
82        // Extract and print the IP details.
83        Serial.println("*** IP Details:");
84        Serial.print("- IP Address: ");
85        Serial.println((const char*)doc["query"]);
86        Serial.print("- City: ");
87        Serial.println((const char*)doc["city"]);
88        Serial.print("- Region: ");
89        Serial.println((const char*)doc["regionName"]);
90        Serial.print("- Country: ");
91        Serial.println((const char*)doc["country"]);
92        Serial.println("");
93
94        // Mark data as fetched.
95        dataFetched = true;
96      }
97      // Close the client connection once done.
98      client.stop();
99    } else {
100      Serial.println("- Ethernet link disconnected!");
101    }
102  }
103}

Copy
1/*
2  Opta's Basic RS-485 Communication
3
4  Name: opta_basic_rs485_example.ino
5  Purpose: This sketch tests the RS-485 interface of 
6  Opta RS485 and Opta WiFi devices.
7
8  @author Arduino PRO Content Team
9  @version 2.0 22/07/23
10*/
11#include <ArduinoRS485.h>
12
13// Set the baudrate to be used by the RS-485 interface.
14constexpr auto baudrate { 115200 };
15
16/**
17  Configure the RS-485 interface. It initializes the
18  interface with the specified baud rate and explicitly 
19  disables data reception to avoid potential data 
20  collision in this half-duplex communication standard.
21
22  @param baudrate (int)
23*/
24void configureRS485(const int baudrate) {
25    const auto bitduration { 1.f / baudrate };
26    const auto wordlen { 9.6f }; // Or 10.0f depending on the channel configuration
27    const auto preDelayBR { bitduration * wordlen * 3.5f * 1e6 };
28    const auto postDelayBR { bitduration * wordlen * 3.5f * 1e6 }
29
30    RS485.begin(baudrate);
31    RS485.setDelays(preDelayBR, postDelayBR);
32    RS485.noReceive();
33}
34
35/**
36  Send a text message through the RS485 interface. Writes 
37  the intended message to the transmission buffer, appends
38  carriage return and newline characters for message 
39  termination, and finally ends the transmission. 
40
41  @param message (char)
42*/
43size_t printlnRS485(char* message) {
44    RS485.beginTransmission();
45    auto len = strlen(message);
46    RS485.write(message, len);
47    RS485.write('\r');
48    RS485.write('\n');
49    RS485.endTransmission();
50}
51
52void setup() {
53    configureRS485(baudrate);
54    printlnRS485("- RS-485 interface configured!");
55}
56
57void loop() {
58    delay(2000);
59    // Wait for two seconds and then sends a test message via the RS485 interface.
60    printlnRS485("- This is a message transmitted via RS-485!");
61}

Copy
1char ssid[] = "SECRET_SSID"; // Your network SSID (name)
2char password[] = "SECRET_PASS"; // Your network password (use for WPA, or use as key for WEP)

Copy
1/**
2  WiFi Web Client
3  Name: opta_wifi_web_client.ino
4  Purpose: This sketch connects an Opta device to ip-api.com via WiFi
5  and fetches IP details.
6
7  @author Arduino PRO Content Team
8  @version 2.2 16/08/23
9*/
10
11#include <WiFi.h>
12#include <Arduino_JSON.h>
13
14// Wi-Fi network details.
15const char* ssid     = "YOUR_SSID";
16const char* password = "YOUR_PASSWORD";
17
18// Server address for ip-api.com.
19const char* server = "ip-api.com";
20
21// API endpoint path to get IP details in JSON format.
22String path = "/json";
23
24// Wi-Fi client instance for the communication.
25WiFiClient client;
26
27// JSON variable to store and process the fetched data.
28JSONVar doc;
29
30// Variable to ensure we fetch data only once.
31bool dataFetched = false;
32
33void setup() {
34  // Begin serial communication at a baud rate of 115200.
35  Serial.begin(115200);
36
37  // Wait for the serial port to connect,
38  // This is necessary for boards that have native USB.
39  while (!Serial);
40
41  // Start the Wi-Fi connection using the provided SSID and password.
42  Serial.print("- Connecting to ");
43  Serial.println(ssid);
44  WiFi.begin(ssid, password);
45
46  while (WiFi.status() != WL_CONNECTED) {
47    delay(1000);
48    Serial.print(".");
49  }
50
51  Serial.println();
52  Serial.println("- Wi-Fi connected!");
53  Serial.print("- IP address: ");
54  Serial.println(WiFi.localIP());
55}
56
57void loop() {
58  // Check if the IP details have been fetched.
59  // If not, call the function to fetch IP details,
60  // Set the flag to true after fetching.
61  if (!dataFetched) {
62    fetchIPDetails();
63    dataFetched = true;
64  }
65}
66
67/**
68  Fetch IP details from defined server
69
70  @param none
71  @return IP details
72*/
73void fetchIPDetails() {
74  if (client.connect(server, 80)) {
75    // Compose and send the HTTP GET request.
76    client.print("GET ");
77    client.print(path);
78    client.println(" HTTP/1.1");
79    client.print("Host: ");
80    client.println(server);
81    client.println("Connection: close");
82    client.println();
83
84    // Wait and skip the HTTP headers to get to the JSON data.
85    char endOfHeaders[] = "\r\n\r\n";
86    client.find(endOfHeaders);
87
88    // Read and parse the JSON response.
89    String payload = client.readStringUntil('\n');
90    doc = JSON.parse(payload);
91
92    // Check if the parsing was successful. 
93    if (JSON.typeof(doc) == "undefined") {
94      Serial.println("- Parsing failed!");
95      return;
96    }
97
98    // Extract and print the IP details.
99    Serial.println("*** IP Details:");
100    String query = doc["query"];
101    Serial.print("- IP Address: ");
102    Serial.println(query);
103    String city = doc["city"];
104    Serial.print("- City: ");
105    Serial.println(city);
106    String region = doc["regionName"];
107    Serial.print("- Region: ");
108    Serial.println(region);
109    String country = doc["country"];
110    Serial.print("- Country: ");
111    Serial.println(country);
112    Serial.println("");
113  } else {
114    Serial.println("- Failed to connect to server!");
115  }
116
117  // Close the client connection once done. 
118  client.stop();
119}

Copy
1/**
2  Opta's Bluetooth Example
3  Name: opta_bluetooth_example.ino
4  Purpose: Read voltage level from an analog input terminal of an Opta device,
5  then maps the voltage reading to a percentage value ranging from 0 to 100.
6
7  @author Arduino PRO Content Team
8  @version 1.1 23/07/23
9*/
10
11#include <ArduinoBLE.h>
12
13// Define the voltage service and its characteristic.
14BLEService voltageService("1101");
15BLEUnsignedCharCharacteristic voltageLevelChar("2101", BLERead | BLENotify);
16
17const int TERMINAL = A0;
18const long interval = 200; // Delay interval in ms for voltage reading and LED blinking
19
20BLEDevice central;
21
22/**
23  Read voltage level from an analog input terminal of an Opta device,
24  then maps the voltage reading to a voltage value ranging from 0 to 10 VDC.
25
26  @param none
27  @return the voltage value (int).
28*/
29int readVoltageLevel() {
30  int voltage = analogRead(TERMINAL);
31  int voltageLevel = map(voltage, 0, 4095, 0, 10);
32  return voltageLevel;
33}
34
35void setup() {
36  // Initialize LED_USER as an output.
37  pinMode(LED_USER, OUTPUT);
38  digitalWrite(LED_USER, HIGH);
39
40  // Initialize serial communication at 9600 bits per second.
41  Serial.begin(9600);
42
43  // Enable analog inputs on Opta.
44  // Set the resolution of the ADC to 12 bits.
45  analogReadResolution(12); 
46
47  // Initialize the BLE module.
48  if (!BLE.begin()) {
49    Serial.println("- Starting BLE failed!");
50    while (1); // In case of failure, loop indefinitely.
51  }
52
53  // Set the local name and advertised service for the BLE module.
54  BLE.setLocalName("VoltageMonitor");
55  BLE.setAdvertisedService(voltageService);
56  voltageService.addCharacteristic(voltageLevelChar);
57  BLE.addService(voltageService);
58
59  // Start advertising the BLE service.
60  BLE.advertise();
61  Serial.println("- Bluetooth device active, waiting for connections...");
62}
63
64void loop() {
65  // Get the current time since the Arduino started.
66  unsigned long currentMillis = millis();
67  
68  // Static variables to hold the last time the tasks were performed.
69  static unsigned long previousVoltageMillis = 0; // Last time the voltage was read
70  static unsigned long previousLEDMillis = 0; // Last time the LED state changed
71
72  // If the interval has passed, update the LED.
73  if (currentMillis - previousLEDMillis >= interval) {
74    // Save the current time to check against in the next loop iteration.
75    previousLEDMillis = currentMillis;
76
77    // Toggle the state of the LED.
78    digitalWrite(LED_USER, !digitalRead(LED_USER));
79  }
80
81  // If a central device is connected.
82  if (central) {
83    if (central.connected()) {
84      // Set the LED color to solid blue when connected.
85      digitalWrite(LED_USER, HIGH);
86
87      // If the interval has passed, update the voltage level.
88      if (currentMillis - previousVoltageMillis >= interval) {
89        // Save the current time to check against in the next loop iteration.
90        previousVoltageMillis = currentMillis;
91
92        // Read the voltage level and update the BLE characteristic with the voltage level value.
93        int voltageLevel = readVoltageLevel();
94
95        Serial.print("- Voltage level is: ");
96        Serial.println(voltageLevel);
97        voltageLevelChar.writeValue(voltageLevel);
98      }
99    }
100    else {
101      central = BLE.central();
102      if (central) {
103        Serial.print("- Connected to device: ");
104        Serial.println(central.address());
105      }
106      else {
107        Serial.print("- BLE not connected: ");
108        Serial.println(central.address());
109      }
110    }
111  }
112  else {
113    central = BLE.central();
114    if (central) {
115      Serial.print("- Connected to device: ");
116      Serial.println(central.address());
117    }
118  }
119}

Copy
1/**
2  Opta's User Button Example (Interrupt)
3  Name: opta_user_button_interrupt_example.ino
4  Purpose: Configures Opta's user-programmable button to control the user LEDs
5  using interrupts rather than polling the button's state. This example includes
6  debouncing for the user button.
7  
8  @author Arduino PRO Content Team
9  @version 2.0 23/07/23
10*/
11
12// Current and previous state of the button.
13volatile bool buttonPressed = false;
14
15// Counter to keep track of the LED sequence.
16int counter = 0;
17
18// Variables to implement button debouncing.
19unsigned long lastDebounceTime  = 0;
20unsigned long debounceDelay     = 150;
21
22// Array to store LED pins.
23int LEDS[] = {LED_D0, LED_D1, LED_D2, LED_D3};
24int NUM_LEDS = 4;
25
26void setup() {
27  // Initialize Opta user LEDs.
28  for(int i = 0; i < NUM_LEDS; i++) {
29    pinMode(LEDS[i], OUTPUT);
30  }
31  
32  // Set up the interrupt on USER_BTN to trigger on a rising edge (when the button is pressed)
33  attachInterrupt(digitalPinToInterrupt(BTN_USER), buttonISR, FALLING);
34}
35
36/**
37  Interrupt service routine (ISR)
38  Set the variable buttonPressed to true
39
40  @param None.
41*/
42void buttonISR() {
43  buttonPressed = true;
44}
45
46void loop() {
47  // If the button was pressed
48  if (buttonPressed) {
49    // Debouncing routine.
50    if ((millis() - lastDebounceTime) > debounceDelay) {
51      lastDebounceTime = millis();
52
53      // Only increment the counter if the new button state is HIGH.
54      if(counter < NUM_LEDS){
55        counter++;
56      }
57      else{
58        counter = 0;
59      }
60      
61      // Reset the button pressed flag
62      buttonPressed = false;
63    }
64  }
65
66  // Control LED states.
67  changeLights();
68}
69
70/**
71  Control the status LEDs based on a counter value.
72  Turns off all LEDs first, then turns on the LED 
73  corresponding to the current counter value.
74
75  @param None.
76*/
77void changeLights() {
78  // Turn off all user LEDs.
79  for(int i = 0; i < NUM_LEDS; i++) {
80    digitalWrite(LEDS[i], LOW);
81  }
82
83  // Turn on the selected user LED.
84  if(counter > 0) {
85    digitalWrite(LEDS[counter - 1], HIGH);
86  }
87}