Flutter:

Description: Flutter is an open-source UI framework developed by Google. It allows you to build natively compiled applications for mobile, web, and desktop from a single codebase.

Features:

• Cross-Platform: Flutter supports multiple platforms, including Android, iOS, web, and desktop.
• Rich Widgets: Flutter provides a wide range of customizable widgets for building beautiful UIs.
• Hot Reload: Developers can see changes instantly during development.
• Dart Language: Flutter uses the Dart programming language.
• Use Case: Flutter is suitable for creating responsive and visually appealing GUIs for various devices, including microcontrollers.

Pros and Cons:

• Pros: Fast development, expressive UI, and strong community support.
• Cons: May have a learning curve if you’re new to Dart and Flutter.

MIT App Inventor:

Description: MIT App Inventor is a visual development environment for creating Android apps. It’s beginner-friendly and uses a block-based programming approach.

Features:

• Visual Blocks: Drag-and-drop blocks to create app logic.
• Live Testing: Test your app on a connected Android device or emulator.
• Simple Interface: Ideal for beginners and educational purposes.
• Use Case: Great for quickly prototyping simple apps and connecting them to microcontrollers.

Pros and Cons:

• Pros: No coding experience required, rapid development.
• Cons: Limited flexibility for complex apps.

Processing:

Description: Processing is an open-source programming language and environment for creative coding and visual arts.

Features:

• Graphics and Animation: Processing excels in creating visual content.
• Java-Based: Uses a simplified version of Java.
• Community Libraries: Extensive libraries for various tasks.

Pros and Cons:

• Use Case: Ideal for creating interactive visualizations and artistic GUIs.
• Pros: Great for creative projects, strong community.
• Cons: Not specifically designed for microcontroller interfaces.

        
            /*
                Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleServer.cpp
                Ported to Arduino ESP32 by Evandro Copercini
                updates by chegewara
            */

            #include <BLEDevice.h>
            #include <BLEUtils.h>
            #include <BLEServer.h>

            // See the following for generating UUIDs:
            // https://www.uuidgenerator.net/

            #define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
            #define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

            void setup() {
              Serial.begin(115200);
              Serial.println("Starting BLE work!");

              BLEDevice::init("Long name works now");
              BLEServer *pServer = BLEDevice::createServer();
              BLEService *pService = pServer->createService(SERVICE_UUID);
              BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                             CHARACTERISTIC_UUID,
                                             BLECharacteristic::PROPERTY_READ |
                                             BLECharacteristic::PROPERTY_WRITE
                                           );

              pCharacteristic->setValue("Hello World says Neil");
              pService->start();
              // BLEAdvertising *pAdvertising = pServer->getAdvertising();  // this still is working for backward compatibility
              BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
              pAdvertising->addServiceUUID(SERVICE_UUID);
              pAdvertising->setScanResponse(true);
              pAdvertising->setMinPreferred(0x06);  // functions that help with iPhone connections issue
              pAdvertising->setMinPreferred(0x12);
              BLEDevice::startAdvertising();
              Serial.println("Characteristic defined! Now you can read it in your phone!");
            }

            void loop() {
              // put your main code here, to run repeatedly:
              delay(2000);
            }
        
    

        
            // Turns an Arduino Nano ESP32 into a Bluetooth® Low Energy peripheral.
            // This BLE peripheral is providing a service that allows a BLE central 
            // to switch on and off the internal LED of the Arduino Nano ESP32.
            // https://tutoduino.fr/
            // Copyleft 2023
            #include <ArduinoBLE.h>
            BLEService ledService("19b10000-e8f2-537e-4f6c-d104768a1214"); // Bluetooth® Low Energy LED Service
            // Bluetooth® Low Energy LED Switch Characteristic - custom 128-bit UUID, read and writable by central
            BLEByteCharacteristic switchCharacteristic("19b10000-e8f2-537e-4f6c-d104768a1214", BLERead | BLEWrite);
            const int ledPin = LED_BUILTIN; // internal LED pin
            void setup() {
              Serial.begin(9600);
              // set LED pin to output mode
              pinMode(ledPin, OUTPUT);
              // BLE initialization
              if (!BLE.begin()) {
                Serial.println("starting Bluetooth® Low Energy module failed!");
                while (1);
              }
              // set advertised local name and service UUID:
              BLE.setLocalName("LED");
              BLE.setAdvertisedService(ledService);
              // add the characteristic to the service
              ledService.addCharacteristic(switchCharacteristic);
              // add service
              BLE.addService(ledService);
              // set the initial value for the characeristic:
              switchCharacteristic.writeValue(0);
              // start advertising
              BLE.advertise();
              Serial.println("BLE LED Peripheral");
            }
            void loop() {
              // wait for a Bluetooth® Low Energy central
              BLEDevice central = BLE.central();
              // check if a central is connected to this peripheral
              if (central) {
                Serial.print("Connected to central: ");
                // print the central's MAC address:
                Serial.println(central.address());
                // while the central is still connected to peripheral:
                while (central.connected()) {
                  // if the remote device wrote to the characteristic,
                  // use the value to control the LED:
                  if (switchCharacteristic.written()) {
                    if (switchCharacteristic.value()) {   // any value other than 0
                      Serial.println("LED on");
                      digitalWrite(ledPin, HIGH);         // will turn the LED on
                    } else {                              // a 0 value
                      Serial.println(F("LED off"));
                      digitalWrite(ledPin, LOW);          // will turn the LED off
                    }
                  }
                }
                // the central has disconnected
                Serial.println("Disconnected from central: ");
              }
            }
        
    

        
            char val; // Data received from the serial port
            int ledPin = 3; // Set the pin to digital I/O 13
            boolean ledState = LOW; // To toggle our LED

            void setup()
            {
              pinMode(ledPin, OUTPUT); // Set pin as OUTPUT
              // Initialize serial communications at a 9600 baud rate
              Serial.begin(9600);
              establishContact(); // Send a byte to establish contact until receiver responds
            }

            void loop()
            {
              if (Serial.available() > 0) { // If data is available to read,
                val = Serial.read(); // Read it and store it in val

                if (val == '1') // If we get a 1
                {
                  ledState = !ledState; // Flip the ledState
                  digitalWrite(ledPin, ledState);
                }
                delay(100);
              }
              else {
                Serial.println("Hello, I am processing it!"); // Send back a message
                delay(50);
              }
            }

            void establishContact() {
              while (Serial.available() <= 0) {
                Serial.println("A"); // Send a capital A
                delay(300);
              }
            }
        
    

        
            import processing.serial.*; //import the Serial library
            Serial myPort; //the Serial port object
            String val;
            // since we're doing serial handshaking,
            // we need to check if we've heard from the microcontroller
            boolean firstContact = false;

            void setup() {
              size(400, 400); //make our canvas 200 x 200 pixels big
              // initialize your serial port and set the baud rate to 9600
              String portName = "COM7"; //this setup is for windows port change the # to match your port
              myPort = new Serial(this, portName, 9600);
              myPort.bufferUntil('\n');
            }

            void draw() {
              //we can leave the draw method empty,
              //because all our programming happens in the serialEvent (see below)
            }

            void serialEvent( Serial myPort) {
              //put the incoming data into a String -
              //the '\n' is our end delimiter indicating the end of a complete packet
              val = myPort.readStringUntil('\n');
              //make sure our data isn't empty before continuing
              if (val != null) {
                //trim whitespace and formatting characters (like carriage return)
                val = trim(val);
                println(val);

                //look for our 'A' string to start the handshake
                //if it's there, clear the buffer, and send a request for data
                if (firstContact == false) {
                  if (val.equals("A")) {
                    myPort.clear();
                    firstContact = true;
                    myPort.write("A");
                    println("contact");
                  }
                }
                else { //if we've already established contact, keep getting and parsing data
                  println(val);

                  if (mousePressed == true)
                  { //if we clicked in the window
                    myPort.write('1'); //send a 1
                    println("1");
                  }

                  // when you've parsed the data you have, ask for more:
                  myPort.write("A");
                }
              }
            }
        
    

        
            #include <Servo.h>

            Servo myServo;
            int servoPosition = 0; // Initial position

            void setup() {
              myServo.attach(2); // Connect servo to pin 9
              Serial.begin(9600);
            }

            void loop() {
              if (Serial.available() > 0) {
                int angle = Serial.parseInt(); // Read angle from Processing
                if (angle >= 0 && angle <= 180) {
                  myServo.write(angle);
                  delay(500); // Delay for servo movement
                }
              }
            }
        
    

        
            import processing.serial.*;

            Serial arduinoPort; // Serial port for communication with Arduino
            boolean servoMoved = false; // Flag to track servo position
            Button servoButton; // Declare the button

            void setup() {
              size(400, 200);
              String[] portNames = Serial.list();
              if (portNames.length > 0) {
                arduinoPort = new Serial(this, portNames[0], 9600); // Change baud rate if needed
              } else {
                println("No Arduino port found. Make sure it's connected.");
                noLoop();
              }

              // Create the button
              servoButton = new Button(width / 2 - 50, height / 2 - 20, 100, 40, "Move Servo");
              servoButton.onClick(() -> {
                if (!servoMoved) {
                  arduinoPort.write("90"); // Send "90" to Arduino
                  servoMoved = true;
                } else {
                  arduinoPort.write("0"); // Send "0" to return servo to initial position
                  servoMoved = false;
                }
              });
            }

            void draw() {
              background(220);
              // Display the button
              servoButton.display();
            }

            class Button {
              float x, y, w, h;
              String label;
              Runnable onClickAction;

              Button(float x, float y, float w, float h, String label) {
                this.x = x;
                this.y = y;
                this.w = w;
                this.h = h;
                this.label = label;
              }

              void display() {
                // Button appearance
                fill(255);
                stroke(0);
                rect(x, y, w, h, 10); // Rounded corners
                fill(0);
                textAlign(CENTER, CENTER);
                textSize(16);
                text(label, x + w / 2, y + h / 2);
              }

              void onClick(Runnable action) {
                onClickAction = action;
              }

              void checkClick(float mx, float my) {
                if (mx > x && mx < x + w && my > y && my < y + h) {
                  onClickAction.run();
                }
              }
            }

            void mousePressed() {
              servoButton.checkClick(mouseX, mouseY);
            }