Device is not responding

[nozrial]

Hi all,
I am new to using arduino and I am using Arduino 101 for my school project. The error I am getting back when I am trying to upload is as shown in attached image:

Any help would be appreciated.

[UKHeliBob]

Welcome to the forum

Please follow the advice given in the link below when posting code and/or error messages, in particular the section entitled 'Posting code and common code problems'

Use code tags (the </> icon above the compose window) to make it easier to read and copy for examination

How to get the best out of this forum

See also FAQ - Arduino Forum for general rules on forum behaviour and etiquette. Hello, Welcome to the Arduino Forum. This guide explains how to get the best out of this forum. Please read and follow the instructions below. Being new here you might think this is having rules for the sake of rules, but that is not the case. If you don’t follow the guidelines all that happens is there is a long exchange of posts while we try to get you to tell us what we need in order to help you, which is fru…

Is the board plugged into COM3 and does Windows recognise the board and create COM 3 when you plug it in ?

[nozrial]

I am attaching the link from which I have.(https://iot.appinventor.mit.edu/assets/resources/AIM-for-Things-Arduino101.zip

[StefanL38]

hI @nozrial

welcome to the arduino forum !
as additional information:

The probalility that your intentions are good is very high.
Anyway there is a small chance that a zip-file can contain malware.
This is the reason why no user will download a ZIP-file
You should post your code as a code-section.
don't post pictures: They are hard to read and contain only a fraction of the information of the compile / upload-logfile

You should post the complete text of this logfile as a code-section too!

simply click into the text
press ctrl-a to mark all
press ctrl-c to copy to clipboard
change to forum
click the code-section-button </>
and then press ctrl-v to paste the clipboard content.

Do the same thing with your sketch.

The more details you can provide the faster and better the help will be
.
It depends on your effort to provide the
complete sketch
and
the complete compile-logfile
both as a

code-section

to receive good advice how to solve the problems

best regards Stefan

[nozrial]

Ok here is the code
For AIM-for-Things-Arduino101.ino

#define NAME             "App Inventor"     // no more than 11 characters
#define DEBUGGING        ENABLED

#define ACCELEROMETER    ENABLED
#define BUTTON           ENABLED
#define CAMERA           ENABLED
#define CONSOLE          ENABLED
#define FINGERPRINT      DISABLED
#define GYROSCOPE        ENABLED
#define LED              ENABLED
#define LIGHT_SENSOR     ENABLED
#define MOISTURE_SENSOR  ENABLED
#define PINS             ENABLED
#define PROXIMITY        ENABLED
#define PWM              ENABLED
#define RGBLCD           ENABLED
#define SERVO            ENABLED
#define SOUND_RECORDER   ENABLED
#define TEMPERATURE      ENABLED

// frequency to read sensor values in µs
const unsigned long SENSOR_UPDATE_FREQ = 50000;
const unsigned long IMU_READ_FREQ = 5000;
const double IMU_FILTER_ALPHA = 0.5; //Alpha for accelerometer low pass filter

unsigned long nextSensorUpdate;
unsigned long nextIMURead;
double dt;

const uint8_t BITS[8] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
const uint8_t MASK[8] = { 0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F };

#include "common.h"

bool connected = false;
BLEPeripheral blePeripheral;
BLEService appinventorService("E95DFFFF-251D-470A-A062-FA1922DFA9A7");

#define MODE PREAMBLE
#include "sensors.h"
#undef MODE
#define MODE DEFINITIONS
#include "sensors.h"
#undef MODE
#define MODE FUNCTIONS
#include "sensors.h"
#undef MODE

void setup() {
  Serial.begin(9600);
#if DEBUGGING == ENABLED
  while (!Serial);
#endif
  LOGLN("Starting App Inventor...");

  blePeripheral.setDeviceName(NAME);
  blePeripheral.setLocalName(NAME);
  blePeripheral.setAppearance(128);
  blePeripheral.setAdvertisedServiceUuid(appinventorService.uuid());

  blePeripheral.addAttribute(appinventorService);

#define MODE SETUP
#include "sensors.h"
#undef MODE

  LOGLN("Setting connection interval");
  blePeripheral.setConnectionInterval(0x0006, 0x0010);
  LOGLN("Begin peripheral");
  blePeripheral.begin();

  Serial.println("App Inventor started.");
}

void loop() {
  BLECentral bleCentral = blePeripheral.central();
  if (bleCentral && !connected) {
    Serial.print("Connected to ");
    Serial.println(bleCentral.address());
    connected = true;
  } else if (connected && !bleCentral) {
    Serial.println("Disconnected");
    connected = false;
  }

  if (connected) {
    if ((long)(micros() - nextSensorUpdate) >= 0) {
      updateSensorValues();
      nextSensorUpdate += SENSOR_UPDATE_FREQ;
    }
#if ACCELEROMETER == ENABLED || GYROSCOPE == ENABLED
    if ((long)(micros() - nextIMURead) >= 0) {
      updateIMUValues();
    }
#endif
  }
}

void updateSensorValues() {
#define MODE UPDATE
#include "sensors.h"
#undef MODE
}

#if ACCELEROMETER == ENABLED || GYROSCOPE == ENABLED
#include "imu.hh"
#endif

For Accelerometer.hh

#if ACCELEROMETER == ENABLED
#if MODE == PREAMBLE

#include <CurieIMU.h>

#define ACCELEROMETER_SETUP  setupAccelerometer
#define ACCELEROMETER_UPDATE updateAccelerometer

#elif MODE == DEFINITIONS

struct AccelerometerData {
  float x;
  float y;
  float z;
};

volatile struct AccelerometerData accel;

BLEService accelerometerService("E95D0100-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic accelerometerReadChar("E95D0101-251D-470A-A062-FA1922DFA9A7", BLERead | BLENotify, sizeof(AccelerometerData));

void setupAccelerometer();
void updateAccelerometer();
float convertRawAcceleration(int aRaw);
float convertRawGyro(int gRaw);

#elif MODE == FUNCTIONS

void updateAccelerometer() {
  // accel is computed in updateIMUValues in imu.hh
  accelerometerReadChar.setValue((byte *)&accel, sizeof(accel));
}


void setupAccelerometer() {
  CurieIMU.begin();
  CurieIMU.setAccelerometerRange(4);
  CurieIMU.setGyroRange(250);

  // Configure initial values for characteristics
  LOGLN("Calibrate sensors");
  calibrateIMU();
  updateAccelerometer();
  updateIMUValues();

#if !ONE_SERVICE
  Serial.println("Configuring Accelerometer Service...");
  blePeripheral.addAttribute(accelerometerService);
#endif
  blePeripheral.addAttribute(accelerometerReadChar);

}

#elif MODE == SETUP

setupAccelerometer();

#elif MODE == UPDATE

updateAccelerometer();

#endif
#endif

For Button.hh

#if BUTTON == ENABLED
#if MODE == PREAMBLE

#define BUTTON_SETUP setupButton();
#define BUTTON_UPDATE updateButton();

#elif MODE == DEFINITIONS

struct ButtonPinData {
  /**
   * A sequence of 64 bits indicating which pins have buttons attached.
   */
  uint8_t buttons[DIGITAL_PIN_BYTES];
};

struct ButtonStateData {
  /**
   * A sequence of 64 bits where each bit indicates the state of a button.
   */
  uint8_t buttons[DIGITAL_PIN_BYTES];
};

struct ButtonPinData buttonPins;
struct ButtonStateData buttonStates;

BLEService buttonService("E95D0200-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic buttonPinCharacteristic("E95D0201-251D-470A-A062-FA1922DFA9A7", BLEWrite, 8);
BLECharacteristic buttonReadCharacteristic("E95D0202-251D-470A-A062-FA1922DFA9A7", BLERead | BLENotify, 8);

void setupButton();
void updateButton();
void buttonPinsWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupButton() {
#if !ONE_SERVICE
  LOGLN("Configuring Button Service...");
  blePeripheral.addAttribute(buttonService);
#endif
  blePeripheral.addAttribute(buttonPinCharacteristic);
  blePeripheral.addAttribute(buttonReadCharacteristic);
  buttonPinCharacteristic.setEventHandler(BLEWritten, buttonPinsWritten);
}


void buttonPinsWritten(BLECentral &central, BLECharacteristic &characteristic) {
  const byte *value = characteristic.value();
  memcpy(&buttonPins, value, sizeof(buttonPins));
}


void updateButtons() {
  int pin = 0;
  for (uint8_t i = 0; i < 8; ++i) {
    uint8_t newValue = 0;
    for (uint8_t j = 0x80; j != 0; j >>= 1, ++pin) {
      if ((buttonPins.buttons[i] & j) == j) {
        if (HIGH == digitalRead(pin)) {
          newValue |= j;
        }
      }
    }
    buttonStates.buttons[i] = newValue;
  }
  buttonReadCharacteristic.setValue(reinterpret_cast<byte *>(&buttonStates), sizeof(buttonStates));
}

#elif MODE == SETUP

setupButton();

#elif MODE == UPDATE

updateButtons();

#endif
#endif

For Camera.hh

#if BUTTON == ENABLED
#if MODE == PREAMBLE

#define BUTTON_SETUP setupButton();
#define BUTTON_UPDATE updateButton();

#elif MODE == DEFINITIONS

struct ButtonPinData {
  /**
   * A sequence of 64 bits indicating which pins have buttons attached.
   */
  uint8_t buttons[DIGITAL_PIN_BYTES];
};

struct ButtonStateData {
  /**
   * A sequence of 64 bits where each bit indicates the state of a button.
   */
  uint8_t buttons[DIGITAL_PIN_BYTES];
};

struct ButtonPinData buttonPins;
struct ButtonStateData buttonStates;

BLEService buttonService("E95D0200-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic buttonPinCharacteristic("E95D0201-251D-470A-A062-FA1922DFA9A7", BLEWrite, 8);
BLECharacteristic buttonReadCharacteristic("E95D0202-251D-470A-A062-FA1922DFA9A7", BLERead | BLENotify, 8);

void setupButton();
void updateButton();
void buttonPinsWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupButton() {
#if !ONE_SERVICE
  LOGLN("Configuring Button Service...");
  blePeripheral.addAttribute(buttonService);
#endif
  blePeripheral.addAttribute(buttonPinCharacteristic);
  blePeripheral.addAttribute(buttonReadCharacteristic);
  buttonPinCharacteristic.setEventHandler(BLEWritten, buttonPinsWritten);
}


void buttonPinsWritten(BLECentral &central, BLECharacteristic &characteristic) {
  const byte *value = characteristic.value();
  memcpy(&buttonPins, value, sizeof(buttonPins));
}


void updateButtons() {
  int pin = 0;
  for (uint8_t i = 0; i < 8; ++i) {
    uint8_t newValue = 0;
    for (uint8_t j = 0x80; j != 0; j >>= 1, ++pin) {
      if ((buttonPins.buttons[i] & j) == j) {
        if (HIGH == digitalRead(pin)) {
          newValue |= j;
        }
      }
    }
    buttonStates.buttons[i] = newValue;
  }
  buttonReadCharacteristic.setValue(reinterpret_cast<byte *>(&buttonStates), sizeof(buttonStates));
}

#elif MODE == SETUP

setupButton();

#elif MODE == UPDATE

updateButtons();

#endif
#endif

For Console.hh

#if CONSOLE == ENABLED
#if MODE == PREAMBLE

// no premable needed for console

#elif MODE == DEFINITIONS

BLEService consoleService("6E400001-B5A3-F393-E0A9-E50E24DCCA9E");
BLECharacteristic consoleTransmitCharacteristic("6E400002-B5A3-F393-E0A9-E50E24DCCA9E", BLEIndicate, 20);
BLECharacteristic consoleReceiveCharacteristic("6E400003-B5A3-F393-E0A9-E50E24DCCA9E", BLEWrite, 20);

void setupConsole();
void updateConsole();
void consoleReceivedBytes(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupConsole() {
#if !ONE_SERVICE
  LOGLN("Configuring Console Service...");
  blePeripheral.addAttribute(consoleService);
#endif
  blePeripheral.addAttribute(consoleTransmitCharacteristic);
  blePeripheral.addAttribute(consoleReceiveCharacteristic);
  consoleReceiveCharacteristic.setEventHandler(BLEWritten, consoleReceivedBytes);
}


void consoleReceivedBytes(BLECentral &central, BLECharacteristic &characteristic) {
  // TODO: implementation
}


void updateConsole() {
  
}

#elif MODE == SETUP

setupConsole();

#elif MODE == UPDATE

updateConsole();

#endif
#endif

For PWM.hh

#if PWM == ENABLED
#if MODE == PREAMBLE

#elif MODE == DEFINITIONS

struct PWMPinMsg {
  uint8_t pin;
  uint8_t power;
};

BLEService pwmService("E95D0F00-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic pwmSetChar("E95D0F01-251D-470A-A062-FA1922DFA9A7", BLEWrite, sizeof(PWMPinMsg));

void setupPWM();
void pwmPinWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupPWM() {
#if !ONE_SERVICE
  LOGLN("Configuring PWM service...");
  blePeripheral.addAttribute(pwmService);
#endif
  blePeripheral.addAttribute(pwmSetChar);
  pwmSetChar.setEventHandler(BLEWritten, pwmPinWritten);
}


void pwmPinWritten(BLECentral &central, BLECharacteristic &characteristic) {
  PWMPinMsg msg;
  memcpy((void *)&msg, characteristic.value(), sizeof(msg));
  LOG("Setting pin ");
  LOG(msg.pin);
  LOG(" to ");
  LOGLN(msg.power);
  analogWrite(msg.pin, (int)(2.55 * msg.power));
}

#elif MODE == SETUP

setupPWM();

#endif
#endif

For LED.hh

#if LED == ENABLED
#if MODE == PREAMBLE

#elif MODE == DEFINITIONS

struct LedPinData {
  uint8_t pin;
  uint8_t intensity;
};

BLEService ledService("E95D0700-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic ledStateChar("E95D0701-251D-470A-A062-FA1922DFA9A7", BLEWrite, sizeof(LedPinData));

void setupLED();
void ledPinWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupLED() {
#if !ONE_SERVICE
  LOGLN("Configuring LED Service...");
  blePeripheral.addAttribute(ledService);
#endif
  blePeripheral.addAttribute(ledStateChar);
  ledStateChar.setEventHandler(BLEWritten, ledPinWritten);
}


void ledPinWritten(BLECentral &central, BLECharacteristic &characteristic) {
  const LedPinData *data = reinterpret_cast<const LedPinData *>(characteristic.value());
  switch(data->pin) {
  case 3:
  case 5:
  case 6:
  case 9:
    analogWrite(data->pin, data->intensity);
    break;
  default:
    digitalWrite(data->pin, data->intensity);
  }
}

#elif MODE == SETUP

setupLED();

#endif
#endif

For Gyroscope.hh

#if GYROSCOPE == ENABLED
#if MODE == PREAMBLE

#elif MODE == DEFINITIONS

struct GyroscopeData {
  float angleX;
  float angleY;
};

volatile struct GyroscopeData gyro;

BLEService gyroService("E95D0500-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic gyroscopeReadChar("E95D0501-251D-470A-A062-FA1922DFA9A7", BLERead | BLENotify, sizeof(GyroscopeData));


#elif MODE == FUNCTIONS

void setupGyroscope() {
#if !ONE_SERVICE
  Serial.println("Configuring Gyroscope Service...");
  blePeripheral.addAttribute(gyroService);
#endif
  blePeripheral.addAttribute(gyroscopeReadChar);
}


void updateGyroscope() {
  // gyro is computed in updateIMUValues in imu.hh
  gyroscopeReadChar.setValue((const unsigned char *)&gyro, sizeof(gyro));
}

#elif MODE == SETUP

setupGyroscope();

#elif MODE == UPDATE

updateGyroscope();

#endif
#endif

For LightSensor.hh

#if LIGHT_SENSOR == ENABLED
#if MODE == PREAMBLE

#define LIGHT_SETUP  setupLightSensor();
#define LIGHT_UPDATE updateLightSensor();

#elif MODE == DEFINITIONS

struct LightSensorPinData {
  uint8_t pins[ANALOG_PIN_BYTES];
};

struct LightSensorData {
  uint8_t reading[8*ANALOG_PIN_BYTES];
};

struct LightSensorPinData lightPins;
struct LightSensorData lightData;

BLEService lightService("E95D0E00-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic lightSensorPinChar("E95D0E01-251D-470A-A062-FA1922DFA9A7", BLEWrite, sizeof(LightSensorPinData));
BLECharacteristic lightSensorDataChar("E95D0E02-251D-470A-A062-FA1922DFA9A7", BLERead | BLENotify, sizeof(LightSensorData));

void setupLightSensor();
void updateLightSensor();
void lightPinWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupLightSensor() {
#if !ONE_SERVICE
  LOGLN("Configuring Light Sensor Service...");
  blePeripheral.addAttribute(lightService);
#endif
  blePeripheral.addAttribute(lightSensorPinChar);
  blePeripheral.addAttribute(lightSensorDataChar);
  lightSensorPinChar.setEventHandler(BLEWritten, lightPinWritten);
}


void lightPinWritten(BLECentral &central, BLECharacteristic &characteristic) {
  memcpy((void *)&lightPins, characteristic.value(), sizeof(lightPins));
  printArray((uint8_t *)characteristic.value(), 8);
}


void updateLightSensor() {
  bool updated = false;
  int pin = 0;
  // read light data from the indicated pins
  for (int i = 0; i < ANALOG_PIN_BYTES; i++) {
    for (int j = 0x80; j != 0; j >>= 1) {
      if ((lightPins.pins[i] & j) == j) {
        // Map [0,1023] to [0,255] because we use 1-byte values in BLE characteristic.
        // Eventually this should match the sensor's hardware specs, but we assume a linear transformation for now.
        lightData.reading[pin] = map(analogRead(pin), 0, 1023, 0, 255);
        Serial.print("Light[");
        Serial.print(pin);
        Serial.print("]: ");
        Serial.println(lightData.reading[pin]);
        updated = true;
      }
      pin++;
    }
  }
  if (updated) {
    // write the updated values to the characteristic
    lightSensorDataChar.setValue(reinterpret_cast<byte *>(&lightData), sizeof(lightData));
  }
}

#elif MODE == SETUP

setupLightSensor();

#elif MODE == UPDATE

updateLightSensor();

#endif
#endif

** For Moisture.hh**

#if MOISTURE_SENSOR == ENABLED
#if MODE == PREAMBLE

#elif MODE == DEFINITIONS

struct MoisturePinData {
  uint8_t pins[ANALOG_PIN_BYTES];
};

struct MoistureData {
  uint8_t reading[8*ANALOG_PIN_BYTES];
};

struct MoisturePinData moisturePins;
struct MoistureData moistureData;

// moistureBLE
BLEService moistureService("E95D0800-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic moisturePinChar("E95D0801-251D-470A-A062-FA1922DFA9A7", BLEWrite, sizeof(MoisturePinData));
BLECharacteristic moistureReadChar("E95D0802-251D-470A-A062-FA1922DFA9A7", BLERead | BLENotify, sizeof(MoistureData));

void setupMoisture();
void updateMoistureData();
void moisturePinWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupMoisture() {
#if !ONE_SERVICE
  Serial.println("Configuring Moisture Service...");
  blePeripheral.addAttribute(moistureService);
#endif
  blePeripheral.addAttribute(moisturePinChar);
  blePeripheral.addAttribute(moistureReadChar);
  moisturePinChar.setEventHandler(BLEWritten, moisturePinWritten);
}

void moisturePinWritten(BLECentral &central, BLECharacteristic &characteristic) {
  Serial.println("Updating moisture pins...");
  memcpy((void *)&moisturePins, characteristic.value(), sizeof(moisturePins));
  Serial.print("moisture pins: ");
  printArray(moisturePins.pins, ANALOG_PIN_BYTES);
}

void updateMoistureData() {
  int pin = 0;
  bool updated = false;
  // read moisture data from the indicated pins
  for (int i = 0; i < ANALOG_PIN_BYTES; i++) {
    for (int j = 0x80; j != 0; j >>= 1) {
      if ((moisturePins.pins[i] & j) == j) {
        // Map [0,1023] to [0,255] because we use 1-byte values in BLE characteristic.
        // Eventually this should match the sensor's hardware specs, but we assume a linear transformation for now.
        moistureData.reading[pin] = map(analogRead(pin), 0, 1023, 0, 255);
        Serial.print("Moisture[");
        Serial.print(pin);
        Serial.print("]: ");
        Serial.println(moistureData.reading[pin]);
        updated = true;
      }
      pin++;
    }
  }
  if (updated) {
    // write the updated values to the characteristic
    moistureReadChar.setValue(reinterpret_cast<byte *>(&moistureData), sizeof(moistureData));
  }
}

#elif MODE == SETUP

setupMoisture();

#elif MODE == UPDATE

updateMoistureData();

#endif
#endif

For Pins.hh

#if PINS == ENABLED
#if MODE == PREAMBLE

#elif MODE == DEFINITIONS

struct AnalogPinData {
  uint8_t values[8*ANALOG_PIN_BYTES];
};

struct DigitalPinData {
  uint8_t values[DIGITAL_PIN_BYTES];
};

struct PinModeData {
  uint8_t mode[DIGITAL_PIN_BYTES];
};

struct PinModeData pinModes;

BLEService pinService("a56ada00-ed09-11e5-9c97-0002a5d5c51b");
BLECharacteristic analogPinChar("a56ada02-ed09-11e5-9c97-0002a5d5c51b", BLERead | BLENotify, sizeof(AnalogPinData));
BLECharacteristic digitalPinChar("a56ada03-ed09-11e5-9c97-0002a5d5c51b", BLERead | BLEWrite | BLENotify, sizeof(DigitalPinData));
BLECharacteristic pinModeChar("a56ada04-ed09-11e5-9c97-0002a5d5c51b", BLERead | BLEWrite, sizeof(PinModeData));

void setupPins();
void updateAnalogPins();
void updateDigitalPins();
void digitalPinWritten(BLECentral &central, BLECharacteristic &characteristic);
void pinModeWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupPins() {
#if !ONE_SERVICE
  Serial.println("Configuring Pin Service...");
  blePeripheral.addAttribute(pinService);
#endif
  blePeripheral.addAttribute(analogPinChar);
  blePeripheral.addAttribute(digitalPinChar);
  blePeripheral.addAttribute(pinModeChar);
  digitalPinChar.setEventHandler(BLEWritten, digitalPinWritten);
  pinModeChar.setEventHandler(BLEWritten, pinModeWritten);
}

void updateAnalogPins() {
  struct AnalogPinData analog;
  for (int i=0; i<=5; i++) {
    analog.values[i] = map(analogRead(i), 0, 1023, 0, 255);
  }
  analogPinChar.setValue(reinterpret_cast<byte *>(&analog), sizeof(analog));
}


void updateDigitalPins() {
  int pin = 0;
  struct DigitalPinData digital;
  for (uint8_t i = 0; i < 8; ++i) {
    uint8_t newValue = 0;
    for (uint8_t j = 1; j != 0; j <<= 1, ++pin) {
      if ((pinModes.mode[i] & BITS[j]) == INPUT) {
        if (HIGH == digitalRead(pin)) {
          newValue |= j;
        }
      }
    }
    digital.values[i] = newValue;
  }
  digitalPinChar.setValue(reinterpret_cast<byte *>(&digital), sizeof(digital));
}


void digitalPinWritten(BLECentral &central, BLECharacteristic &characteristic) {
  int pin = 0;
  struct DigitalPinData digital;
  memcpy(&digital, characteristic.value(), sizeof(digital));
  for (int i = 0; i < DIGITAL_PIN_BYTES; ++i) {
    for (int j = 0x80; j != 0; j >>= 1, ++pin) {
      digitalWrite(pin, digital.values[i] & j ? HIGH : LOW);
    }
  }
}


void pinModeWritten(BLECentral &central, BLECharacteristic &characteristic) {
  memcpy(&pinModes, characteristic.value(), sizeof(pinModes));
}


#elif MODE == SETUP

setupPins();

#elif MODE == UPDATE

updateAnalogPins();
updateDigitalPins();

#endif
#endif

For Proximity.hh

#if PROXIMITY == ENABLED
#if MODE == PREAMBLE

#elif MODE == DEFINITIONS

// ProximitySensor BLE
struct ProximityPinData {
  uint8_t pins[ANALOG_PIN_BYTES];
};

struct ProximityData {
  uint8_t reading[8*ANALOG_PIN_BYTES];
};

struct ProximityPinData proximityPins;
struct ProximityData proximityData;

BLEService proximityService("E95D0A00-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic proximityPinChar("E95D0A01-251D-470A-A062-FA1922DFA9A7", BLEWrite, sizeof(ProximityPinData));
BLECharacteristic proximityReadChar("E95D0A02-251D-470A-A062-FA1922DFA9A7", BLERead | BLENotify, sizeof(ProximityData));

void setupProximity();
void updateProximity();
void proximityPinWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupProximity() {
#if !ONE_SERVICE
  Serial.println("Configuring Proximity Service...");
  blePeripheral.addAttribute(proximityService);
#endif
  blePeripheral.addAttribute(proximityPinChar);
  blePeripheral.addAttribute(proximityReadChar);
  proximityPinChar.setEventHandler(BLEWritten, proximityPinWritten);
}

void proximityPinWritten(BLECentral &central, BLECharacteristic &characteristic) {
  memcpy((void *)&proximityPins, characteristic.value(), sizeof(proximityPins));
}

void updateProximity() {
  int pin = 0;
  // read proximity data from the indicated pins
  for (int i = 0; i < ANALOG_PIN_BYTES; i++) {
    for (int j = 0x80; j != 0; j >>= 1) {
      if ((proximityPins.pins[i] & j) == j) {
        float sensor_value, sum = 0.0;
        for (int k = 0; k < 20; k++) {
          sum += analogRead(pin);
        }
        sensor_value = sum / 20.0 * 5.0 / 1024.0;
        if (sensor_value >= 3.15) {
          proximityData.reading[pin] = 6;
        } else if (sensor_value >= 2.98) {
          proximityData.reading[pin] = 6 + lround((3.15 - sensor_value) / (3.15 - 2.98));
        } else if (sensor_value >= 2.75) {
          proximityData.reading[pin] = 7 + lround((2.98 - sensor_value) / (2.98 - 2.75));
        } else if (sensor_value >= 2.31) {
          proximityData.reading[pin] = 8 + lround(2 * (2.75 - sensor_value) / (2.75 - 2.31));
        } else if (sensor_value >= 1.65) {
          proximityData.reading[pin] = 10 + lround(5 * (2.31 - sensor_value) / (2.31 - 1.65));
        } else if (sensor_value >= 1.3) {
          proximityData.reading[pin] = 15 + lround(5 * (1.65 - sensor_value) / (1.65 - 1.3));
        } else if (sensor_value >= 1.08) {
          proximityData.reading[pin] = 20 + lround(5 * (1.3 - sensor_value) / (1.3 - 1.08));
        } else if (sensor_value >= 0.925) {
          proximityData.reading[pin] = 25 + lround(5 * (1.08 - sensor_value) / (1.08 - 0.925));
        } else if (sensor_value >= 0.75) {
          proximityData.reading[pin] = 30 + lround(10 * (0.925 - sensor_value) / (0.925 - 0.75));
        } else if (sensor_value >= 0.61) {
          proximityData.reading[pin] = 40 + lround(10 * (0.75 - sensor_value) / (0.75 - 0.61));
        } else if (sensor_value >= 0.525) {
          proximityData.reading[pin] = 50 + lround(10 * (0.61 - sensor_value) / (0.61 - 0.525));
        } else if (sensor_value >= 0.45) {
          proximityData.reading[pin] = 60 + lround(10 * (0.525 - sensor_value) / (0.61 - 0.45));
        } else if (sensor_value >= 0.4) {
          proximityData.reading[pin] = 70 + lround(10 * (0.45 - sensor_value) / (0.45 - 0.4));
        } else {
          proximityData.reading[pin] = 80;
        }
      }
      pin++;
    }
  }
  // write the updated values to the characteristic
  proximityReadChar.setValue(reinterpret_cast<byte *>(&proximityData), sizeof(proximityData));
}

#elif MODE == SETUP

setupProximity();

#elif MODE == UPDATE

updateProximity();

#endif
#endif

For RGBLcd.hh

#if RGBLCD == ENABLED
#if MODE == PREAMBLE

#include <rgb_lcd.h>

#define RGBLCD_SETUP setupRgbLcd();
#define RGBLCD_UPDATE

#elif MODE == DEFINITIONS

struct RgbLcdBackgroundData {
  uint8_t blue;
  uint8_t green;
  uint8_t red;
  uint8_t alpha;
};

struct RgbLcdMessageData {
  char text[24];
};

rgb_lcd lcd;
bool lcdPrepared = false;
struct RgbLcdBackgroundData rgbLcdBackground;
struct RgbLcdMessageData rgbLcdText1;
struct RgbLcdMessageData rgbLcdText2;

BLEService rgbLcdService("E95D0B00-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic rgbLcdBackgroundChar("E95D0B01-251D-470A-A062-FA1922DFA9A7", BLERead | BLEWrite, sizeof(RgbLcdBackgroundData));
BLECharacteristic rgbLcdTextChar1("E95D0B02-251D-470A-A062-FA1922DFA9A7", BLERead | BLEWrite, sizeof(RgbLcdMessageData));
BLECharacteristic rgbLcdTextChar2("E95D0B03-251D-470A-A062-FA1922DFA9A7", BLERead | BLEWrite, sizeof(RgbLcdMessageData));

void setupRgbLcd();
void rgbLcdBackgroundWritten(BLECentral &central, BLECharacteristic &characteristic);
void rgbLcdText1Written(BLECentral &central, BLECharacteristic &characteristic);
void rgbLcdText2Written(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupRgbLcd() {
#if !ONE_SERVICE
  Serial.println("Configuring RGB LCD Service...");
  blePeripheral.addAttribute(rgbLcdService);
#endif
  blePeripheral.addAttribute(rgbLcdBackgroundChar);
  blePeripheral.addAttribute(rgbLcdTextChar1);
  blePeripheral.addAttribute(rgbLcdTextChar2);
  rgbLcdBackgroundChar.setEventHandler(BLEWritten, rgbLcdBackgroundWritten);
  rgbLcdTextChar1.setEventHandler(BLEWritten, rgbLcdText1Written);
  rgbLcdTextChar2.setEventHandler(BLEWritten, rgbLcdText2Written);
  memset((void *) &rgbLcdBackground, 0, sizeof(rgbLcdBackground));
  memset((void *) &rgbLcdText1, 0, sizeof(rgbLcdText1));
  memset((void *) &rgbLcdText2, 0, sizeof(rgbLcdText2));
  rgbLcdTextChar1.setValue((const unsigned char *) rgbLcdText1.text, sizeof(rgbLcdText1));
  rgbLcdTextChar2.setValue((const unsigned char *) rgbLcdText2.text, sizeof(rgbLcdText2));
  lcd.begin(16, 2);
  lcd.clear();
  lcdPrepared = true;
}


void rgbLcdBackgroundWritten(BLECentral &central, BLECharacteristic &characteristic) {
  Serial.println("rgbLcdBackgroundWritten");
  if (!lcdPrepared) {
    Serial.println("Preparing LCD");
    lcd.begin(16, 2);
    lcdPrepared = true;
  }
  memcpy((void *) &rgbLcdBackground, characteristic.value(), sizeof(rgbLcdBackground));
  Serial.print("  alpha = "); Serial.println(rgbLcdBackground.alpha);
  Serial.print("  red = "); Serial.println(rgbLcdBackground.red);
  Serial.print("  green = "); Serial.println(rgbLcdBackground.green);
  Serial.print("  blue = "); Serial.println(rgbLcdBackground.blue);
  lcd.setRGB(rgbLcdBackground.red, rgbLcdBackground.green, rgbLcdBackground.blue);
}


void rgbLcdText1Written(BLECentral &central, BLECharacteristic &characteristic) {
  Serial.println("rgbLcdText1Written");
  if (!lcdPrepared) {
    Serial.println("Preparing LCD");
    lcd.begin(16, 2);
    lcdPrepared = true;
  }
  memcpy((void *) &rgbLcdText1, characteristic.value(), sizeof(rgbLcdText1));
  lcd.clear();
  rgbLcdText1.text[23] = 0;  // make sure that the string is null terminated
  Serial.print("  text = "); Serial.println(rgbLcdText1.text);
  lcd.print(rgbLcdText1.text);
}

void rgbLcdText2Written(BLECentral &central, BLECharacteristic &characteristic) {
  Serial.println("rgbLcdText2Written");
  if (!lcdPrepared) {
    Serial.println("Preparing LCD");
    lcd.begin(16, 2);
    lcdPrepared = true;
  }
  memcpy((void *) &rgbLcdText2, characteristic.value(), sizeof(rgbLcdText2));
  rgbLcdText2.text[23] = 0;  // make sure that the string is null terminated
  Serial.print("  text = "); Serial.println(rgbLcdText2.text);
  lcd.setCursor(0, 1);  // move to second row
  lcd.print(rgbLcdText2.text);
}

#elif MODE == SETUP

setupRgbLcd();

#endif
#endif

For Servo.hh

#if SERVO == ENABLED
#if MODE == PREAMBLE

#include <Servo.h>

#elif MODE == DEFINITIONS

struct ServoData {
  uint8_t pins[DIGITAL_PINS];
};

Servo servos[14];
ServoData servoPins;

BLEService servoService("E95D0C00-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic servoPosition("E95D0C01-251D-470A-A062-FA1922DFA9A7", BLERead | BLEWrite, sizeof(ServoData));
BLECharacteristic servoPositionMicros("E95D0C02-251D-470A-A062-FA1922DFA9A7", BLEWrite, sizeof(ServoData));

void setupServo();
void servoPositionWritten(BLECentral &central, BLECharacteristic &characteristic);
void servoPositionMicrosWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupServo() {
#if !ONE_SERVICE
  LOGLN("Configuring Servo Service...");
  blePeripheral.addAttribute(servoService);
#endif
  blePeripheral.addAttribute(servoPosition);
  blePeripheral.addAttribute(servoPositionMicros);
  servoPosition.setEventHandler(BLEWritten, servoPositionWritten);
  servoPositionMicros.setEventHandler(BLEWritten, servoPositionMicrosWritten);
  memset(&servoPins, 255, sizeof(ServoData));
  servoPosition.setValue((const uint8_t *)&servoPins, sizeof(servoPins));
}


void servoPositionWritten(BLECentral &central, BLECharacteristic &characteristic) {
  memcpy(&servoPins, characteristic.value(), sizeof(ServoData));
  for (int i = 0; i < DIGITAL_PINS; i++) {
    if (servoPins.pins[i] != 255) {
      if (!servos[i].attached()) {
        servos[i].attach(i);
        Serial.println("Attached servo to pin " + String(i));
      }
      servos[i].write(servoPins.pins[i]);
      Serial.println("Wrote " + String(servoPins.pins[i]) + " to pin " + String(i));
    } else if (servoPins.pins[i] == 255 && servos[i].attached()) {
      servos[i].detach();
      Serial.println("Detached servo from pin " + String(i));
    }
  }
}


void servoPositionMicrosWritten(BLECentral &central, BLECharacteristic &characteristic) {
  struct { int16_t pin, microseconds; } data;
  memcpy(&data, characteristic.value(), 4);
  if (!servos[data.pin].attached()) {
    servos[data.pin].attach(data.pin);
  }
  servos[data.pin].writeMicroseconds(data.microseconds);
  uint8_t value = servos[data.pin].read();
  if (servoPins.pins[data.pin] != value) {
    servoPins.pins[data.pin] = value;
    servoPosition.setValue((const uint8_t *)&servoPins, sizeof(servoPins));
  }
}

#elif MODE == SETUP

setupServo();

#endif
#endif

For SoundRecorder.hh

#if SOUND_RECORDER == ENABLED
#if MODE == PREAMBLE

#elif MODE == DEFINITIONS

struct SoundRecorderPins {
  uint8_t recorderPins[DIGITAL_PIN_BYTES];
  uint8_t playbackPins[DIGITAL_PIN_BYTES];
};

struct SoundRecorderMessage {
  int8_t pin;
  int8_t state;
};

SoundRecorderPins recorderPins;

BLEService soundRecorderService("E95D0D00-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic soundRecorderInitialize("E95D0D01-251D-470A-A062-FA1922DFA9A7", BLERead | BLEWrite, sizeof(SoundRecorderPins));
BLECharacteristic soundRecorderRecord("E95D0D02-251D-470A-A062-FA1922DFA9A7", BLEWrite, sizeof(SoundRecorderMessage));
BLECharacteristic soundRecorderPlayback("E95D0D03-251D-470A-A062-FA1922DFA9A7", BLEWrite, sizeof(SoundRecorderMessage));

void soundRecorderInitializeRequested(BLECentral &central, BLECharacteristic &characteristic);
void soundRecorderRecordRequested(BLECentral &central, BLECharacteristic &characteristic);
void soundRecorderPlaybackRequested(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupSoundRecorder() {
#if !ONE_SERVICE
  LOGLN("Configuring Sound Recorder Service...");
  blePeripheral.addAttribute(soundRecorderService);
#endif
  blePeripheral.addAttribute(soundRecorderInitialize);
  blePeripheral.addAttribute(soundRecorderRecord);
  blePeripheral.addAttribute(soundRecorderPlayback);
  soundRecorderInitialize.setEventHandler(BLEWritten, soundRecorderInitializeRequested);
  soundRecorderRecord.setEventHandler(BLEWritten, soundRecorderRecordRequested);
  soundRecorderPlayback.setEventHandler(BLEWritten, soundRecorderPlaybackRequested);
}


void soundRecorderInitializeRequested(BLECentral &central, BLECharacteristic &characteristic) {
  int pin = 0;
  memcpy(&recorderPins, characteristic.value(), sizeof(SoundRecorderPins));
  for (int i = 0; i < DIGITAL_PIN_BYTES; i++) {
    for (int j = 0x80; j != 0; j >>= 1) {
      if ((recorderPins.recorderPins[i] & j) == j || (recorderPins.playbackPins[i] & j) == j) {
        pinMode(pin, OUTPUT);
        digitalWrite(pin, HIGH);
      }
      pin++;
    }
  }
}


void soundRecorderRecordRequested(BLECentral &central, BLECharacteristic &characteristic) {
  SoundRecorderMessage message;
  memcpy(&message, characteristic.value(), sizeof(SoundRecorderMessage));
  digitalWrite(message.pin, message.state ? LOW : HIGH);
}


void soundRecorderPlaybackRequested(BLECentral &central, BLECharacteristic &characteristic) {
  SoundRecorderMessage message;
  memcpy(&message, characteristic.value(), sizeof(SoundRecorderMessage));
  if (message.state) {
    digitalWrite(message.pin, LOW);
    delay(100);
    digitalWrite(message.pin, HIGH);
  }
}

#elif MODE == SETUP

setupSoundRecorder();

#endif
#endif

For Temperature.hh

#if TEMPERATURE == ENABLED
#if MODE == PREAMBLE

#include <DHT.h>

#elif MODE == DEFINITIONS

struct HumidityPinData {
  uint8_t pins[DIGITAL_PIN_BYTES];
};

struct HumidityData {
  uint8_t recording[16];
};

struct TemperatureData {
  int8_t recording[16];
};

struct HumidityPinData humidityPins;
struct HumidityData humidityData;
struct TemperatureData temperatureData;
DHT *sensors[16];

BLEService humidityService("E95D0600-251D-470A-A062-FA1922DFA9A7");
BLECharacteristic humidityPinChar("E95D0601-251D-470A-A062-FA1922DFA9A7", BLEWrite, sizeof(HumidityPinData));
BLECharacteristic humidityReadChar("E95D0602-251D-470A-A062-FA1922DFA9A7", BLERead | BLENotify, sizeof(HumidityData));
BLECharacteristic temperatureReadChar("E95D0603-251D-470A-A062-FA1922DFA9A7", BLERead | BLENotify, sizeof(TemperatureData));

void setupDHT();
void updateDHT();
void humidityPinWritten(BLECentral &central, BLECharacteristic &characteristic);

#elif MODE == FUNCTIONS

void setupDHT() {
#if !ONE_SERVICE
  Serial.println("Configuring Temperature & Humidity Service...");
  blePeripheral.addAttribute(humidityService);
#endif
  blePeripheral.addAttribute(humidityPinChar);
  blePeripheral.addAttribute(humidityReadChar);
  blePeripheral.addAttribute(temperatureReadChar);
  humidityPinChar.setEventHandler(BLEWritten, humidityPinWritten);
  for (int i = 0; i < 16; i++) {
    sensors[i] = NULL;
  }
}

void humidityPinWritten(BLECentral &central, BLECharacteristic &characteristic) {
  uint8_t newPins[DIGITAL_PIN_BYTES];
  uint8_t sensor = 0;
  memcpy((void *)&newPins, characteristic.value(), DIGITAL_PIN_BYTES);
  for (int i = 0; i < 2; i++) {
    for (uint8_t j = 0x80; j != 0; j >>= 1) {
      LOG("humidity pin[j] = ");
      LOGLN(humidityPins.pins[i] & j);
      LOG("new pin[j] = ");
      LOGLN(newPins[i] & j);
      if ((humidityPins.pins[i] & j) < (newPins[i] & j)) {
        // new DHT
        LOG("Creating new DHT on pin ");
        LOGLN(sensor);
        sensors[sensor] = new DHT(sensor, DHT11);
        sensors[sensor]->begin();
      } else if ((humidityPins.pins[i] & j) > (newPins[i] & j)) {
        // delete DHT
        LOG("Deleting DHT on pin ");
        LOGLN(sensor);
        delete sensors[sensor];
        sensors[sensor] = NULL;
      }
      sensor++;
    }
  }
  memcpy((void *)&humidityPins, newPins, sizeof(humidityPins));
}


void updateHumidityTemperatureData() {
  bool updated = false;
  for (int i = 0; i < 16; i++) {
    if (sensors[i] != NULL) {
      humidityData.recording[i] = (uint8_t) (sensors[i]->readHumidity());
      temperatureData.recording[i] = (int8_t) (sensors[i]->readTemperature());
      LOG("Humidity: ");
      LOG(humidityData.recording[i]);
      LOG(" %\t");
      LOG("Temperature: ");
      LOG(temperatureData.recording[i]);
      LOGLN(" *C");
      updated = true;
    }
  }
  if (updated) {
    LOGLN("Updating Temp/Humidity Characteristics");
    humidityReadChar.setValue(reinterpret_cast<byte *>(&humidityData), sizeof(humidityData));
    temperatureReadChar.setValue(reinterpret_cast<byte *>(&temperatureData), sizeof(temperatureData));
  }
}

#elif MODE == SETUP

setupDHT();

#elif MODE == UPDATE

updateHumidityTemperatureData();

#endif
#endif

For common.h

#define ENABLED 1
#define DISABLED 0

#define ONE_SERVICE 0
#define ANALOG_PIN_BYTES 2
#define DIGITAL_PIN_BYTES 8
#define DIGITAL_PINS 14
#define MAX_BLE_PACKET 20
#define PWM_PINS 4

#if DEBUGGING == ENABLED
#define LOG(x) Serial.print((x))
#define LOGLN(x) Serial.println((x))
#else
#define LOG(x)
#define LOGLN(x)
#endif

#ifndef INCLUDED_CURIE_BLE_H
#include <CurieBLE.h>
#define INCLUDED_CURIE_BLE_H
#endif

#include "modes.h"

void printArray(const uint8_t values[], int n) {
  for (int i = 0; i < n; i++) {
    Serial.print(values[i]);
    Serial.print(' ');
  }
  Serial.println();
}

void printSignedArray(const int8_t values[], int n) {
  for (int i = 0; i < n; i++) {
    Serial.print(values[i]);
    Serial.print(' ');
  }
  Serial.println();
}


#if ACCELEROMETER == ENABLED || GYROSCOPE == ENABLED

#include <CurieIMU.h>

float convertRawAcceleration(int aRaw);
float convertRawGyro(int gRaw);
void calibrateIMU();
void updateIMUValues();

#endif

For imu.hh

#ifndef APPINVENTOR_IMU_HH_
#define APPINVENTOR_IMU_HH_

float convertRawAcceleration(int aRaw) {
  return (float) aRaw / 8912.0;
}


float convertRawGyro(int gRaw) {
  return gRaw * 250.0 / 32768.0;
}


void calibrateIMU() {
  CurieIMU.autoCalibrateGyroOffset();
  CurieIMU.autoCalibrateAccelerometerOffset(X_AXIS, 0);
  CurieIMU.autoCalibrateAccelerometerOffset(Y_AXIS, 0);
  CurieIMU.autoCalibrateAccelerometerOffset(Z_AXIS, 1);
}


void updateIMUValues() {
  int ax, ay, az, gx, gy, gz;
  float roll, pitch;

  CurieIMU.readMotionSensor(ax, ay, az, gx, gy, gz);
  dt = (double)(micros() - (nextIMURead - IMU_READ_FREQ)) / 1000000;
  nextIMURead = micros() + IMU_READ_FREQ;

#if ACCELEROMETER == ENABLED
  accel.x = ax * IMU_FILTER_ALPHA + accel.x * (1.0 - IMU_FILTER_ALPHA);
  accel.y = ay * IMU_FILTER_ALPHA + accel.y * (1.0 - IMU_FILTER_ALPHA);
  accel.z = az * IMU_FILTER_ALPHA + accel.z * (1.0 - IMU_FILTER_ALPHA);
#endif

#if GYROSCOPE == ENABLED
  roll = atan2(convertRawAcceleration(ay), convertRawAcceleration(az)) * RAD_TO_DEG;
  pitch = atan2(-convertRawAcceleration(ax), convertRawAcceleration(az)) * RAD_TO_DEG;

  gyro.angleX = 0.93 * (gyro.angleX + convertRawGyro(gx) * dt) + 0.07 * roll;
  gyro.angleY = 0.93 * (gyro.angleY + convertRawGyro(gy) * dt) + 0.07 * pitch;

  if (gyro.angleX > 180) {
    gyro.angleX -= 360;
  } else if (gyro.angleX < -180) {
    gyro.angleX += 360;
  }
#endif
}

#endif

For modes.h

#define PREAMBLE 0
#define DEFINITIONS 1
#define FUNCTIONS 2
#define SETUP 3
#define UPDATE 4

For sensors.h

#include "Accelerometer.hh"
#include "Button.hh"
#include "Camera.hh"
#include "Console.hh"
#include "Fingerprint.hh"
#include "Gyroscope.hh"
#include "LED.hh"
#include "LightSensor.hh"
#include "Moisture.hh"
#include "Pins.hh"
#include "Proximity.hh"
#include "PWM.hh"
#include "RgbLcd.hh"
#include "Servo.hh"
#include "SoundRecorder.hh"
#include "Temperature.hh"

[StefanL38]

You are using Arduino IDE 2.0.3 for which @ptillisch confirmed that copying the complete content of the compile-output can not be copied.

In your case it is essential to have this complete text of the compiling and upload process.

With Arduino-IDE version 1.8.19 this is very easy to do
While with version 2.0.3 it is impossible.
@ptillisch: if you know a way to get the complete output with 2 or 3 mouse-clicks post this solution.

So you can download Arduino-IDE version 1.8.19 here
https://downloads.arduino.cc/arduino-1.8.19-windows.exe

best regards Stefan

[gcjr]

@nozrial

I am attaching the link from which I have.(https://iot.appinventor.mit.edu/assets/resources/AIM-for-Things-Arduino101.zip

seems that the board and/or com port are not configure in the IDE correctly under Tools->board/port

[UKHeliBob]

@StefanL38

You are using Arduino IDE 2.0.3 for which @ptillisch confirmed that copying the complete content of the compile-output can not be copied.

Where did he do that ?

[StefanL38]

@UKHeliBob

Where did he do that ?

don't remember where.

I checked it again
after the hussle of a not working IDE2.0.4
and rolling back to IDE 2.0.3
Version 2.0.3 you can use ctrl-a, ctrl-c
to copy the whole output

best regards Stefan

[jivaro]

Sorry to say this, but welcome to the club !

[ptillisch]

@StefanL38

a not working IDE2.0.4

I would be happy to investigate it if you want to open a dedicated topic with a detailed description of the problem. I haven't seen any reports of problems specific to Arduino IDE 2.0.4 that make the IDE "not working".

UPDATE: I see the topic here:

Updated from 2.0.3 to 2.0.4 - just an empty screen

Hello Everybody, I started Arduino-IDE 2.0.3 and got a suggestion to update to version 2.0.4 and let do the arduino IDE the update process. After finishing the update-process I got a message start IDE and confirmed. The only thing that happens is showing the starting-screen with this "breathing" arduino-logo [image] Did the Arduino-Team make a radical new orientation to use the IDE for meditation? breath in - breath out - breath in - breath out

@StefanL38

you can use ctrl-a, ctrl-c
to copy the whole output

Yes, but there is a far easier way. When compilation fails in Arduino IDE 2.x, you will see a "Compilation error: ..." notification at the bottom right corner of the Arduino IDE window:

Simple click the "COPY ERROR MESSAGES*" button on that notification to copy the full contents of the "Output" panel.

---

In cases where the compilation did not fail, you might find it more convenient to right click on the black "Output" panel at the bottom of the Arduino IDE window and then select "Copy All" from the context menu.

[ptillisch]

Hi @nozrial. In order to gather more information that might help us to troubleshoot your problem, I'm going to ask you to post the full output from the upload when in verbose mode.

---

NOTE: These instructions will not solve the problem. They are only intended to gather more information which might provide a clue that eventually leads to a solution.

---

Please do this:

1. Select File > Preferences from the Arduino IDE menus.
2. Uncheck the box next to Show verbose output during: ☑ compilation
3. Check the box next to Show verbose output during: ☐ upload.
4. Click the OK button.
5. Attempt an upload, as you did before.
6. Wait for the upload to fail.
7. You will see a "Upload error: ..." notification at the bottom right corner of the Arduino IDE window. Click the COPY ERROR MESSAGES button on that notification.
8. Open a forum reply here by clicking the Reply button.
9. Click the </> icon on the post composer toolbar.
   This will add the forum's code block markup (```) to your reply to make sure the error messages are correctly formatted.
   
10. Press Ctrl+V.
    This will paste the error output from the upload into the code block.
11. Move the cursor outside of the code tags before you add any additional text to your reply.
12. Click the Reply button to post the output.