Nano Matter User Manual

Copy
1// the setup function runs once when you press reset or power the board
2void setup() {
3  // initialize digital pin LED_BUILTIN as an output.
4  pinMode(LED_BUILTIN, OUTPUT);
5}
6
7// the loop function runs over and over again forever
8void loop() {
9  digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on (HIGH is the voltage level)
10  delay(1000);                      // wait for a second
11  digitalWrite(LED_BUILTIN, LOW);   // turn the LED off by making the voltage LOW
12  delay(1000);                      // wait for a second
13}

Copy
1#include <Matter.h>
2#include <MatterLightbulb.h>
3
4#define LED_R LED_BUILTIN
5#define LED_G LED_BUILTIN_1
6#define LED_B LED_BUILTIN_2
7
8MatterColorLightbulb matter_color_bulb;
9
10void update_led_color();
11void led_off();
12void handle_button_press();
13volatile bool button_pressed = false;
14
15void setup()
16{
17  Serial.begin(115200);
18  Matter.begin();
19  matter_color_bulb.begin();
20  matter_color_bulb.boost_saturation(51); // Boost saturation by 20 percent
21
22  // Set up the onboard button
23  pinMode(BTN_BUILTIN, INPUT_PULLUP);
24  attachInterrupt(BTN_BUILTIN, &handle_button_press, FALLING);
25
26  // Turn the LED off
27  led_off();
28
29  Serial.println("Arduino Nano Matter - color lightbulb");
30
31  if (!Matter.isDeviceCommissioned()) {
32    Serial.println("Matter device is not commissioned");
33    Serial.println("Commission it to your Matter hub with the manual pairing code or QR code");
34    Serial.printf("Manual pairing code: %s\n", Matter.getManualPairingCode().c_str());
35    Serial.printf("QR code URL: %s\n", Matter.getOnboardingQRCodeUrl().c_str());
36  }
37  while (!Matter.isDeviceCommissioned()) {
38    delay(200);
39  }
40
41  Serial.println("Waiting for Thread network...");
42  while (!Matter.isDeviceThreadConnected()) {
43    delay(200);
44  }
45  Serial.println("Connected to Thread network");
46
47  Serial.println("Waiting for Matter device discovery...");
48  while (!matter_color_bulb.is_online()) {
49    delay(200);
50  }
51  Serial.println("Matter device is now online");
52}
53
54void loop()
55{
56  // If the physical button state changes - update the lightbulb's on/off state
57  if (button_pressed) {
58    button_pressed = false;
59    // Toggle the on/off state of the lightbulb
60    matter_color_bulb.toggle();
61  }
62
63  // Get the current on/off state of the lightbulb
64  static bool matter_lightbulb_last_state = false;
65  bool matter_lightbulb_current_state = matter_color_bulb.get_onoff();
66
67  // If the current state is ON and the previous was OFF - turn on the LED
68  if (matter_lightbulb_current_state && !matter_lightbulb_last_state) {
69    matter_lightbulb_last_state = matter_lightbulb_current_state;
70    Serial.println("Bulb ON");
71    // Set the LEDs to the last received state
72    update_led_color();
73  }
74
75  // If the current state is OFF and the previous was ON - turn off the LED
76  if (!matter_lightbulb_current_state && matter_lightbulb_last_state) {
77    matter_lightbulb_last_state = matter_lightbulb_current_state;
78    Serial.println("Bulb OFF");
79    led_off();
80  }
81
82  static uint8_t hue_prev = 0;
83  static uint8_t saturation_prev = 0;
84  static uint8_t brightness_prev = 0;
85  uint8_t hue_curr = matter_color_bulb.get_hue();
86  uint8_t saturation_curr = matter_color_bulb.get_saturation_percent();
87  uint8_t brightness_curr = matter_color_bulb.get_brightness_percent();
88
89  // If either the hue, saturation or the brightness changes - update the LED to reflect the latest change
90  if (hue_prev != hue_curr || saturation_prev != saturation_curr || brightness_prev != brightness_curr) {
91    update_led_color();
92    hue_prev = hue_curr;
93    saturation_prev = saturation_curr;
94    brightness_prev = brightness_curr;
95  }
96}
97
98// Updates the color of the RGB LED to match the Matter lightbulb's color
99void update_led_color()
100{
101  if (!matter_color_bulb.get_onoff()) {
102    return;
103  }
104  uint8_t r, g, b;
105  matter_color_bulb.get_rgb(&r, &g, &b);
106  // If our built-in LED is active LOW, we need to invert the brightness values
107  if (LED_BUILTIN_ACTIVE == LOW) {
108    analogWrite(LED_R, 255 - r);
109    analogWrite(LED_G, 255 - g);
110    analogWrite(LED_B, 255 - b);
111  } else {
112    analogWrite(LED_R, r);
113    analogWrite(LED_G, g);
114    analogWrite(LED_B, b);
115  }
116  Serial.printf("Setting bulb color to > r: %u  g: %u  b: %u\n", r, g, b);
117}
118
119// Turns the RGB LED off
120void led_off()
121{
122  // If our built-in LED is active LOW, we need to invert the brightness values
123  if (LED_BUILTIN_ACTIVE == LOW) {
124    analogWrite(LED_R, 255);
125    analogWrite(LED_G, 255);
126    analogWrite(LED_B, 255);
127  } else {
128    analogWrite(LED_R, 0);
129    analogWrite(LED_G, 0);
130    analogWrite(LED_B, 0);
131  }
132}
133
134void handle_button_press()
135{
136  static uint32_t btn_last_press = 0;
137  if (millis() < btn_last_press + 200) {
138    return;
139  }
140  btn_last_press = millis();
141  button_pressed = true;
142}

Copy
1#include <Matter.h>
2
3void setup() {
4  // put your setup code here, to run once:
5  Serial.begin(115200);
6
7  Matter.begin();
8  pinMode(BTN_BUILTIN, INPUT_PULLUP);
9  pinMode(LEDR, OUTPUT);
10  digitalWrite(LEDR, HIGH);
11}
12
13void loop() {
14  // put your main code here, to run repeatedly:
15  decommission_handler();
16}
17
18
19void decommission_handler() {
20  if (digitalRead(BTN_BUILTIN) == LOW) {  //Push button pressed
21    // measures time pressed
22    int startTime = millis();
23    while (digitalRead(BTN_BUILTIN) == LOW) {
24
25      int elapsedTime = (millis() - startTime) / 1000.0;
26
27      if (elapsedTime > 10) {
28        Serial.printf("Decommissioning!\n");
29        for (int i = 0; i < 10; i++) {
30          digitalWrite(LEDR, !(digitalRead(LEDR)));
31          delay(100);
32        };
33
34        if (!Matter.isDeviceCommissioned()) {
35          Serial.println("Decommission done!");
36          digitalWrite(LEDR, LOW);
37        } else {
38          Serial.println("Matter device is commissioned-> Starting Decommission process");
39          nvm3_eraseAll(nvm3_defaultHandle);  // Decomission command
40          digitalWrite(LED_BUILTIN, LOW);
41          Serial.println("Decommission done!");
42        }
43        break;
44      }
45    }
46  }
47}

Copy
1#include <Matter.h>
2#include <MatterTemperature.h>
3
4MatterTemperature matter_temp_sensor;
5
6void setup()
7{
8  Serial.begin(115200);
9  Matter.begin();
10
11  pinMode(BTN_BUILTIN, INPUT_PULLUP);
12  pinMode(LEDR, OUTPUT);
13  digitalWrite(LEDR, HIGH);
14
15  matter_temp_sensor.begin();
16
17  Serial.println("Matter temperature sensor");
18
19  if (!Matter.isDeviceCommissioned()) {
20    Serial.println("Matter device is not commissioned");
21    Serial.println("Commission it to your Matter hub with the manual pairing code or QR code");
22    Serial.printf("Manual pairing code: %s\n", Matter.getManualPairingCode().c_str());
23    Serial.printf("QR code URL: %s\n", Matter.getOnboardingQRCodeUrl().c_str());
24  }
25  while (!Matter.isDeviceCommissioned()) {
26    delay(200);
27    decommission_handler();  // if the user button is pressed for 10 seconds
28  }
29
30  Serial.println("Waiting for Thread network...");
31  while (!Matter.isDeviceThreadConnected()) {
32    delay(200);
33    decommission_handler();
34  }
35  Serial.println("Connected to Thread network");
36
37  Serial.println("Waiting for Matter device discovery...");
38  while (!matter_temp_sensor.is_online()) {
39    delay(200);
40    decommission_handler();
41  }
42  Serial.println("Matter device is now online");
43}
44
45void loop()
46{
47  decommission_handler();  // if the user button is pressed for 10 seconds
48
49  float current_cpu_temp = getCPUTemp();
50  matter_temp_sensor.set_measured_value_celsius(current_cpu_temp);
51  Serial.printf("Current CPU temperature: %.02f C\n", current_cpu_temp);
52  delay(2000);
53}
54
55void decommission_handler() {
56  if (digitalRead(BTN_BUILTIN) == LOW) {  //Push button pressed
57    // measures time pressed
58    int startTime = millis();
59    while (digitalRead(BTN_BUILTIN) == LOW) {
60      //delay(50);
61
62      int elapsedTime = (millis() - startTime) / 1000.0;
63
64      if (elapsedTime > 10) {
65        Serial.printf("Decommissioning!\n");
66        for (int i = 0; i < 10; i++) {
67          digitalWrite(LEDR, !(digitalRead(LEDR)));
68          delay(100);
69        };
70
71        if (!Matter.isDeviceCommissioned()) {
72          Serial.println("Decommission done!");
73          digitalWrite(LEDR, LOW);
74        } else {
75          Serial.println("Matter device is commissioned-> Starting Decommission process");
76          nvm3_eraseAll(nvm3_defaultHandle);  // Decomission command
77          digitalWrite(LED_BUILTIN, LOW);
78          Serial.println("Decommission done!");
79        }
80        break;
81      }
82    }
83  }
84}

Copy
1arduino_organization: <Space ID>
2
3token_get_payload: '{"grant_type":"client_credentials","client_id":"<your client ID>","client_secret":"<your client secret>","audience":"https://api2.arduino.cc/iot"}'
4
5arduino_temp_url: https://api2.arduino.cc/iot/v2/things/<your Thing ID>/properties/<temperature variable ID>/publish

Copy
1rest:
2  - resource: "https://api2.arduino.cc/iot/v1/clients/token"
3    scan_interval: 240 #4 min
4    timeout: 60
5    method: "POST"
6    headers:
7      content_type:  'application/json,application/x-www-form-urlencoded'
8    payload: !secret token_get_payload
9    sensor:  
10      - name: "API_Token_Bearer"
11        value_template: "OK"
12        json_attributes_path: '$..'
13        json_attributes:
14          - 'access_token'

Copy
1rest_command:      
2    send_temperature:
3      method: PUT
4      headers:
5        Authorization: "Bearer {{ state_attr('sensor.api_token_bearer', 'access_token') }}"
6        accept: "application/vnd.arduino.property+json,application/vnd.goa.error+json"
7        content_type:  'application/json,application/x-www-form-urlencoded'
8        X-Organization: !secret arduino_organization
9      url: !secret arduino_temp_url
10      payload: "{\"value\":{{states('sensor.matter_device_temperature')}}}"

Copy
1alias: Nano Matter Temperature
2description: ""
3trigger:
4  - platform: state
5    entity_id:
6      - sensor.matter_device_temperature
7condition: []
8action:
9  - service: rest_command.send_temperature
10    data: {}
11mode: single

Copy
1/*
2   BLE blinky example
3*/
4
5bool btn_notification_enabled = false;
6bool btn_state_changed = false;
7uint8_t btn_state = LOW;
8static void btn_state_change_callback();
9static void send_button_state_notification();
10static void set_led_on(bool state);
11
12void setup()
13{
14  pinMode(LED_BUILTIN, OUTPUT);
15  digitalWrite(LED_BUILTIN, LED_BUILTIN_INACTIVE);
16  set_led_on(false);
17  Serial.begin(115200);
18  Serial.println("Silicon Labs BLE blinky example");
19
20  // If the board has a built-in button configure it for usage
21  #ifdef BTN_BUILTIN
22  pinMode(BTN_BUILTIN, INPUT_PULLUP);
23  attachInterrupt(BTN_BUILTIN, btn_state_change_callback, CHANGE);
24  #else // BTN_BUILTIN
25  // Avoid warning for unused function on boards without a button
26  (void)btn_state_change_callback;
27  #endif // BTN_BUILTIN
28}
29
30void loop()
31{
32  if (btn_state_changed) {
33    btn_state_changed = false;
34    send_button_state_notification();
35  }
36}
37
38static void ble_initialize_gatt_db();
39static void ble_start_advertising();
40
41static const uint8_t advertised_name[] = "Blinky Example";
42static uint16_t gattdb_session_id;
43static uint16_t generic_access_service_handle;
44static uint16_t name_characteristic_handle;
45static uint16_t blinky_service_handle;
46static uint16_t led_control_characteristic_handle;
47static uint16_t btn_report_characteristic_handle;
48
49/**************************************************************************//**
50 * Bluetooth stack event handler
51 * Called when an event happens on BLE the stack
52 *
53 * @param[in] evt Event coming from the Bluetooth stack
54 *****************************************************************************/
55void sl_bt_on_event(sl_bt_msg_t *evt)
56{
57  switch (SL_BT_MSG_ID(evt->header)) {
58    // -------------------------------
59    // This event indicates the device has started and the radio is ready.
60    // Do not call any stack command before receiving this boot event!
61    case sl_bt_evt_system_boot_id:
62    {
63      Serial.println("BLE stack booted");
64
65      // Initialize the application specific GATT table
66      ble_initialize_gatt_db();
67
68      // Start advertising
69      ble_start_advertising();
70      Serial.println("BLE advertisement started");
71    }
72    break;
73
74    // -------------------------------
75    // This event indicates that a new connection was opened
76    case sl_bt_evt_connection_opened_id:
77      Serial.println("BLE connection opened");
78      break;
79
80    // -------------------------------
81    // This event indicates that a connection was closed
82    case sl_bt_evt_connection_closed_id:
83      Serial.println("BLE connection closed");
84      // Restart the advertisement
85      ble_start_advertising();
86      Serial.println("BLE advertisement restarted");
87      break;
88
89    // -------------------------------
90    // This event indicates that the value of an attribute in the local GATT
91    // database was changed by a remote GATT client
92    case sl_bt_evt_gatt_server_attribute_value_id:
93      // Check if the changed characteristic is the LED control
94      if (led_control_characteristic_handle == evt->data.evt_gatt_server_attribute_value.attribute) {
95        Serial.println("LED control characteristic data received");
96        // Check the length of the received data
97        if (evt->data.evt_gatt_server_attribute_value.value.len == 0) {
98          break;
99        }
100        // Get the received byte
101        uint8_t received_data = evt->data.evt_gatt_server_attribute_value.value.data[0];
102        // Turn the LED on/off according to the received data
103        if (received_data == 0x00) {
104          set_led_on(false);
105          Serial.println("LED off");
106        } else if (received_data == 0x01) {
107          set_led_on(true);
108          Serial.println("LED on");
109        }
110      }
111      break;
112
113    // -------------------------------
114    // This event is received when a GATT characteristic status changes
115    case sl_bt_evt_gatt_server_characteristic_status_id:
116      // If the 'Button report' characteristic has been changed
117      if (evt->data.evt_gatt_server_characteristic_status.characteristic == btn_report_characteristic_handle) {
118        // The client just enabled the notification - send notification of the current button state
119        if (evt->data.evt_gatt_server_characteristic_status.client_config_flags & sl_bt_gatt_notification) {
120          Serial.println("Button state change notification enabled");
121          btn_notification_enabled = true;
122          btn_state_change_callback();
123        } else {
124          Serial.println("Button state change notification disabled");
125          btn_notification_enabled = false;
126        }
127      }
128      break;
129
130    // -------------------------------
131    // Default event handler
132    default:
133      break;
134  }
135}
136
137/**************************************************************************//**
138 * Called on button state change - stores the current button state and
139 * sets a flag that a button state change occurred.
140 * If the board doesn't have a button the function does nothing.
141 *****************************************************************************/
142static void btn_state_change_callback()
143{
144  // If the board has a built-in button
145  #ifdef BTN_BUILTIN
146  // The real button state is inverted - most boards have an active low button configuration
147  btn_state = !digitalRead(BTN_BUILTIN);
148  btn_state_changed = true;
149  #endif // BTN_BUILTIN
150}
151
152/**************************************************************************//**
153 * Sends a BLE notification the the client if notifications are enabled and
154 * the board has a built-in button.
155 *****************************************************************************/
156static void send_button_state_notification()
157{
158  if (!btn_notification_enabled) {
159    return;
160  }
161  sl_status_t sc = sl_bt_gatt_server_notify_all(btn_report_characteristic_handle,
162                                                sizeof(btn_state),
163                                                &btn_state);
164  if (sc == SL_STATUS_OK) {
165    Serial.print("Notification sent, button state: ");
166    Serial.println(btn_state);
167  }
168}
169
170/**************************************************************************//**
171 * Sets the built-in LED to the desired state accounting for the inverted LED
172 * logic on select boards.
173 *****************************************************************************/
174static void set_led_on(bool state)
175{
176  if (state) {
177    digitalWrite(LED_BUILTIN, LED_BUILTIN_ACTIVE);
178  } else {
179    digitalWrite(LED_BUILTIN, LED_BUILTIN_INACTIVE);
180  }
181}
182
183/**************************************************************************//**
184 * Starts BLE advertisement
185 * Initializes advertising if it's called for the first time
186 *****************************************************************************/
187static void ble_start_advertising()
188{
189  static uint8_t advertising_set_handle = 0xff;
190  static bool init = true;
191  sl_status_t sc;
192
193  if (init) {
194    // Create an advertising set
195    sc = sl_bt_advertiser_create_set(&advertising_set_handle);
196    app_assert_status(sc);
197
198    // Set advertising interval to 100ms
199    sc = sl_bt_advertiser_set_timing(
200      advertising_set_handle,
201      160,   // minimum advertisement interval (milliseconds * 1.6)
202      160,   // maximum advertisement interval (milliseconds * 1.6)
203      0,     // advertisement duration
204      0);    // maximum number of advertisement events
205    app_assert_status(sc);
206
207    init = false;
208  }
209
210  // Generate data for advertising
211  sc = sl_bt_legacy_advertiser_generate_data(advertising_set_handle, sl_bt_advertiser_general_discoverable);
212  app_assert_status(sc);
213
214  // Start advertising and enable connections
215  sc = sl_bt_legacy_advertiser_start(advertising_set_handle, sl_bt_advertiser_connectable_scannable);
216  app_assert_status(sc);
217}
218
219/**************************************************************************//**
220 * Initializes the GATT database
221 * Creates a new GATT session and adds certain services and characteristics
222 *****************************************************************************/
223static void ble_initialize_gatt_db()
224{
225  sl_status_t sc;
226  // Create a new GATT database
227  sc = sl_bt_gattdb_new_session(&gattdb_session_id);
228  app_assert_status(sc);
229
230  // Add the Generic Access service to the GATT DB
231  const uint8_t generic_access_service_uuid[] = { 0x00, 0x18 };
232  sc = sl_bt_gattdb_add_service(gattdb_session_id,
233                                sl_bt_gattdb_primary_service,
234                                SL_BT_GATTDB_ADVERTISED_SERVICE,
235                                sizeof(generic_access_service_uuid),
236                                generic_access_service_uuid,
237                                &generic_access_service_handle);
238  app_assert_status(sc);
239
240  // Add the Device Name characteristic to the Generic Access service
241  // The value of the Device Name characteristic will be advertised
242  const sl_bt_uuid_16_t device_name_characteristic_uuid = { .data = { 0x00, 0x2A } };
243  sc = sl_bt_gattdb_add_uuid16_characteristic(gattdb_session_id,
244                                              generic_access_service_handle,
245                                              SL_BT_GATTDB_CHARACTERISTIC_READ,
246                                              0x00,
247                                              0x00,
248                                              device_name_characteristic_uuid,
249                                              sl_bt_gattdb_fixed_length_value,
250                                              sizeof(advertised_name) - 1,
251                                              sizeof(advertised_name) - 1,
252                                              advertised_name,
253                                              &name_characteristic_handle);
254  app_assert_status(sc);
255
256  // Start the Generic Access service
257  sc = sl_bt_gattdb_start_service(gattdb_session_id, generic_access_service_handle);
258  app_assert_status(sc);
259
260  // Add the Blinky service to the GATT DB
261  // UUID: de8a5aac-a99b-c315-0c80-60d4cbb51224
262  const uuid_128 blinky_service_uuid = {
263    .data = { 0x24, 0x12, 0xb5, 0xcb, 0xd4, 0x60, 0x80, 0x0c, 0x15, 0xc3, 0x9b, 0xa9, 0xac, 0x5a, 0x8a, 0xde }
264  };
265  sc = sl_bt_gattdb_add_service(gattdb_session_id,
266                                sl_bt_gattdb_primary_service,
267                                SL_BT_GATTDB_ADVERTISED_SERVICE,
268                                sizeof(blinky_service_uuid),
269                                blinky_service_uuid.data,
270                                &blinky_service_handle);
271  app_assert_status(sc);
272
273  // Add the 'LED Control' characteristic to the Blinky service
274  // UUID: 5b026510-4088-c297-46d8-be6c736a087a
275  const uuid_128 led_control_characteristic_uuid = {
276    .data = { 0x7a, 0x08, 0x6a, 0x73, 0x6c, 0xbe, 0xd8, 0x46, 0x97, 0xc2, 0x88, 0x40, 0x10, 0x65, 0x02, 0x5b }
277  };
278  uint8_t led_char_init_value = 0;
279  sc = sl_bt_gattdb_add_uuid128_characteristic(gattdb_session_id,
280                                               blinky_service_handle,
281                                               SL_BT_GATTDB_CHARACTERISTIC_READ | SL_BT_GATTDB_CHARACTERISTIC_WRITE,
282                                               0x00,
283                                               0x00,
284                                               led_control_characteristic_uuid,
285                                               sl_bt_gattdb_fixed_length_value,
286                                               1,                               // max length
287                                               sizeof(led_char_init_value),     // initial value length
288                                               &led_char_init_value,            // initial value
289                                               &led_control_characteristic_handle);
290
291  // Add the 'Button report' characteristic to the Blinky service
292  // UUID: 61a885a4-41c3-60d0-9a53-6d652a70d29c
293  const uuid_128 btn_report_characteristic_uuid = {
294    .data = { 0x9c, 0xd2, 0x70, 0x2a, 0x65, 0x6d, 0x53, 0x9a, 0xd0, 0x60, 0xc3, 0x41, 0xa4, 0x85, 0xa8, 0x61 }
295  };
296  uint8_t btn_char_init_value = 0;
297  sc = sl_bt_gattdb_add_uuid128_characteristic(gattdb_session_id,
298                                               blinky_service_handle,
299                                               SL_BT_GATTDB_CHARACTERISTIC_READ | SL_BT_GATTDB_CHARACTERISTIC_NOTIFY,
300                                               0x00,
301                                               0x00,
302                                               btn_report_characteristic_uuid,
303                                               sl_bt_gattdb_fixed_length_value,
304                                               1,                               // max length
305                                               sizeof(btn_char_init_value),     // initial value length
306                                               &btn_char_init_value,            // initial value
307                                               &btn_report_characteristic_handle);
308
309  // Start the Blinky service
310  sc = sl_bt_gattdb_start_service(gattdb_session_id, blinky_service_handle);
311  app_assert_status(sc);
312
313  // Commit the GATT DB changes
314  sc = sl_bt_gattdb_commit(gattdb_session_id);
315  app_assert_status(sc);
316}

Copy
1volatile bool button_pressed = false;
2
3void handle_button_press();
4
5void setup() {
6  Serial.begin(115200);
7
8  pinMode(BTN_BUILTIN, INPUT_PULLUP);
9  attachInterrupt(BTN_BUILTIN, &handle_button_press, FALLING);
10}
11
12void loop() {
13  // If the physical button state changes - update the state
14  if (button_pressed) {
15    button_pressed = false;
16    Serial.println("Button Pressed!");
17  }
18}
19
20void handle_button_press()
21{
22  static uint32_t btn_last_press = 0;
23  if (millis() < btn_last_press + 200) {
24    return;
25  }
26  btn_last_press = millis();
27  button_pressed = true;
28}

Copy
1void setup() {
2  // initialize LED digital pins as outputs.
3  pinMode(LEDR, OUTPUT);
4  pinMode(LEDG, OUTPUT);
5  pinMode(LEDB, OUTPUT);
6}
7
8// the loop function runs over and over again forever
9void loop() {
10  digitalWrite(LEDR, LOW);  // turn the LED on (LOW is the voltage level)
11  digitalWrite(LEDG, HIGH);  // turn the LED off (HIGH is the voltage level)
12  digitalWrite(LEDB, HIGH);  // turn the LED off (HIGH is the voltage level)
13  delay(1000);                      // wait for a second
14  digitalWrite(LEDR, HIGH);   // turn the LED off by making the voltage HIGH
15  digitalWrite(LEDG, LOW);   // turn the LED on by making the voltage LOW
16  digitalWrite(LEDB, HIGH);   // turn the LED off by making the voltage HIGH
17  delay(1000);                      // wait for a second
18  digitalWrite(LEDR, HIGH);   // turn the LED off by making the voltage HIGH
19  digitalWrite(LEDG, HIGH);   // turn the LED off by making the voltage HIGH
20  digitalWrite(LEDB, LOW);   // turn the LED on by making the voltage LOW
21  delay(1000);   
22}

Copy
1// Pin configured as an input
2pinMode(pin, INPUT);        
3
4// Pin configured as an output
5pinMode(pin, OUTPUT);        
6
7// Pin configured as an input, internal pull-up resistor enabled
8pinMode(pin, INPUT_PULLUP);

Copy
1// Read pin state, store value in a state variable
2state = digitalRead(pin);

Copy
1// Set pin on
2digitalWrite(pin, HIGH);    
3
4// Set pin off
5digitalWrite(pin, LOW);

Copy
1// Define button and LED pin
2int buttonPin = D4;
3int ledPin = D5;
4
5// Variable to store the button state
6int buttonState = 0;
7
8void setup() {
9  // Configure button and LED pins
10  pinMode(buttonPin, INPUT_PULLUP);
11  pinMode(ledPin, OUTPUT);
12
13  // Initialize Serial communication
14  Serial.begin(115200);
15}
16
17void loop() {
18  // Read the state of the button
19  buttonState = digitalRead(buttonPin);
20
21  // If the button is pressed, turn on the LED and print its state to the Serial Monitor
22  if (buttonState == LOW) {
23    digitalWrite(ledPin, HIGH);
24    Serial.println("- Button is pressed. LED is on.");
25  } else {
26    // If the button is not pressed, turn off the LED and print to the Serial Monitor
27    digitalWrite(ledPin, LOW);
28    Serial.println("- Button is not pressed. LED is off.");
29  }
30
31  // Wait for 1000 milliseconds
32  delay(1000);
33}

Copy
1analogWrite(pin, value);

Copy
1analogWriteResolution(bits);

Copy
1const int analogInPin = A0;   // Analog input pin that the potentiometer is attached to
2const int pwmOutPin = D13;  // PWM output pin
3
4int sensorValue = 0;  // value read from the pot
5int outputValue = 0;  // value output to the PWM (analog out)
6
7void setup() {
8  // initialize serial communications at 9600 bps:
9  Serial.begin(115200);
10  analogWriteResolution(12);
11}
12
13void loop() {
14  // read the analog in value:
15  sensorValue = analogRead(analogInPin);
16  // map it to the range of the analog out:
17  outputValue = sensorValue;
18  // change the analog out value:
19  analogWrite(pwmOutPin, outputValue);
20
21  // print the results to the Serial Monitor:
22  Serial.print("sensor = ");
23  Serial.print(sensorValue);
24  Serial.print("\t output = ");
25  Serial.println(outputValue);
26
27  // wait 2 milliseconds before the next loop for the analog-to-digital
28  // converter to settle after the last reading:
29  delay(2);
30}