add sensebox sensor blocks

src/components/Blockly/generator/generator.js

@@ -81,6 +81,19 @@ Blockly['Arduino'].ORDER_ASSIGNMENT = 14; // = *= /= ~/= %= += -= <<= >>= &= ^=
 Blockly['Arduino'].ORDER_COMMA = 18; // ,
 Blockly['Arduino'].ORDER_NONE = 99; // (...)
 
+
+
+
+/**
+ * 
+ * @param {} workspace 
+ * 
+ * Blockly Types
+ */
+
+
+
+
 /**
  * Initialise the database of variable names.
  * @param {!Blockly.Workspace} workspace Workspace to generate code from.
@@ -89,9 +102,17 @@ Blockly['Arduino'].init = function (workspace) {
     // Create a dictionary of definitions to be printed before the code.
     Blockly['Arduino'].libraries_ = Object.create(null);
 
+    Blockly['Arduino'].definitions_ = Object.create(null);
+
     // creates a list of code to be setup before the setup block
     Blockly['Arduino'].setupCode_ = Object.create(null);
 
+    // creates a list of code for the loop to be runned once
+    Blockly['Arduino'].loopCodeOnce_ = Object.create(null)
+
+    // creates a list of code variables  
+    Blockly['Arduino'].variables_ = Object.create(null)
+
     // Create a dictionary mapping desired function names in definitions_
     // to actual function names (to avoid collisions with user functions).
     Blockly['Arduino'].functionNames_ = Object.create(null);
@@ -172,39 +193,42 @@ Blockly['Arduino'].init = function (workspace) {
  */
 Blockly['Arduino'].finish = function (code) {
     let libraryCode = '';
+    let variablesCode = ''
     let functionsCode = '';
+    let definitionsCode = '';
+    let loopCodeOnce = '';
+    let setupCode = '';
+    let preSetupCode = '';
     let devVariables = '\n';
 
     for (const key in Blockly['Arduino'].libraries_) {
         libraryCode += Blockly['Arduino'].libraries_[key] + '\n';
     }
 
+    for (const key in Blockly['Arduino'].variables_) {
+        variablesCode += Blockly['Arduino'].variables_[key] + '\n';
+    }
+
+    for (const key in Blockly['Arduino'].definitions_) {
+        definitionsCode += Blockly['Arduino'].definitions_[key] + '\n';
+    }
+
+    for (const key in Blockly['Arduino'].loopCodeOnce_) {
+        loopCodeOnce += Blockly['Arduino'].loopCodeOnce_[key] + '\n';
+    }
+
     for (const key in Blockly['Arduino'].functionNames_) {
         functionsCode += Blockly['Arduino'].functionNames_[key] + '\n';
     }
 
-    if (!_.isEmpty(Blockly['Arduino'].setupCode_['bluetooth_setup'])) {
-        devVariables += 'String bluetoothMessageDEV = ""; \n';
-    }
 
-    if (!_.isEmpty(Blockly['Arduino'].setupCode_['serial_begin'])) {
-        devVariables += 'String serialMessageDEV = ""; \n';
-    }
-
-    if (!_.isEmpty(Blockly['Arduino'].functionNames_['double_to_string_debug'])) {
-        devVariables += 'boolean stopDebugging = false; \n';
-    }
-
-    let setupCode = '';
-
-    let preSetupCode = '';
 
     for (const key in Blockly['Arduino'].setupCode_) {
         preSetupCode += Blockly['Arduino'].setupCode_[key] || '';
     }
     setupCode = '\nvoid setup() { \n' + preSetupCode + '\n}\n';
 
-    let loopCode = '\nvoid loop() { \n' + code + '\n}\n';
+    let loopCode = '\nvoid loop() { \n' + loopCodeOnce + code + '\n}\n';
 
 
     // Convert the definitions dictionary into a list.
@@ -213,6 +237,10 @@ Blockly['Arduino'].finish = function (code) {
         '\n' +
         libraryCode +
         '\n' +
+        variablesCode +
+        '\n' +
+        definitionsCode +
+        '\n' +
         Blockly['Arduino'].variablesInitCode_ +
         '\n' +
         functionsCode +
@@ -225,6 +253,7 @@ Blockly['Arduino'].finish = function (code) {
     // Clean up temporary data.
     delete Blockly['Arduino'].definitions_;
     delete Blockly['Arduino'].functionNames_;
+    delete Blockly['Arduino'].loopCodeOnce_;
     delete Blockly['Arduino'].variablesInitCode_;
     delete Blockly['Arduino'].libraries_;
     Blockly['Arduino'].variableDB_.reset();

src/components/Blockly/generator/index.js

@@ -1,7 +1,12 @@
 import './generator';
 import './loops';
-import './sensebox';
+import './sensebox-sensors';
+import './sensebox-telegram';
+import './sensebox-osem';
 import './logic';
 import './math';
 import './io';
+import './procedures';
+import './time';
+
 

src/components/Blockly/generator/io.js

@@ -30,3 +30,86 @@ Blockly.Arduino['io_digitalread'] = function (block) {
     var code = 'digitalRead(' + pin + ')';
     return [code, Blockly.Arduino.ORDER_ATOMIC];
 };
+
+
+/**
+ * Function for setting the state (Y) of a built-in LED (X).
+ * Arduino code: setup { pinMode(X, OUTPUT); }
+ *               loop  { digitalWrite(X, Y); }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['io_builtin_led'] = function (block) {
+    var pin = block.getFieldValue('BUILT_IN_LED');
+    var stateOutput = Blockly.Arduino.valueToCode(
+        block, 'STATE', Blockly.Arduino.ORDER_ATOMIC) || 'LOW';
+    Blockly['Arduino'].setupCode_['pinMode' + pin] = 'pindMode(' + pin + 'OUTPUT);'
+    var code = 'digitalWrite(' + pin + ', ' + stateOutput + ');\n';
+    return code;
+};
+
+
+/**
+ * Function for setting the state (Y) of an analogue output (X).
+ * Arduino code: setup { pinMode(X, OUTPUT); }
+ *               loop  { analogWrite(X, Y);  }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['io_analogwrite'] = function (block) {
+    var pin = block.getFieldValue('PIN');
+    var stateOutput = Blockly.Arduino.valueToCode(
+        block, 'NUM', Blockly.Arduino.ORDER_ATOMIC) || '0';
+    Blockly['Arduino'].setupCode_['pinMode' + pin] = 'pinMode(' + pin + ', OUTPUT);';
+    // Warn if the input value is out of range
+    if ((stateOutput < 0) || (stateOutput > 255)) {
+        block.setWarningText('The analogue value set must be between 0 and 255',
+            'pwm_value');
+    } else {
+        block.setWarningText(null, 'pwm_value');
+    }
+    var code = 'analogWrite(' + pin + ', ' + stateOutput + ');\n';
+    return code;
+};
+
+/**
+ * Function for reading an analogue pin value (X).
+ * Arduino code: setup { pinMode(X, INPUT); }
+ *               loop  { analogRead(X)      }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['io_analogread'] = function (block) {
+    var pin = block.getFieldValue('PIN');
+    Blockly['Arduino'].setupCode_['pinMode' + pin] = 'pinMode(' + pin + ', INPUT);';
+    var code = 'analogRead(' + pin + ')';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+/**
+ * Value for defining a digital pin state.
+ * Arduino code: loop { HIGH / LOW }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['io_highlow'] = function (block) {
+    var code = block.getFieldValue('STATE');
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+Blockly.Arduino['io_pulsein'] = function (block) {
+    var pin = block.getFieldValue("PULSEPIN");
+    var type = Blockly.Arduino.valueToCode(block, "PULSETYPE", Blockly.Arduino.ORDER_ATOMIC);
+    Blockly['Arduino'].setupCode_['pinMode' + pin] = 'pinMode(' + pin + ', INPUT);';
+    var code = 'pulseIn(' + pin + ', ' + type + ')';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+Blockly.Arduino['io_pulsetimeout'] = function (block) {
+    var pin = block.getFieldValue("PULSEPIN");
+    var type = Blockly.Arduino.valueToCode(block, "PULSETYPE", Blockly.Arduino.ORDER_ATOMIC);
+    var timeout = Blockly.Arduino.valueToCode(block, "TIMEOUT", Blockly.Arduino.ORDER_ATOMIC);
+    Blockly['Arduino'].setupCode_['pinMode' + pin] = 'pinMode(' + pin + ', INPUT);';
+    var code = 'pulseIn(' + pin + ', ' + type + ', ' + timeout + ')';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};

src/components/Blockly/generator/logic.js

@@ -55,7 +55,7 @@ Blockly.Arduino['logic_operation'] = function (Block) {
     return [code, order];
 };
 
-Blockly.Arduino['control_if'] = function (Block) {
+Blockly.Arduino['controls_if'] = function (Block) {
     // If/elseif/else condition.
     let n = 0;
     let code = '',

src/components/Blockly/generator/procedures.js

@@ -0,0 +1,30 @@
+import * as Blockly from 'blockly/core';
+import { Block } from 'blockly';
+
+/**
+ * Code generator to add code into the setup() and loop() functions.
+ * Its use is not mandatory, but necessary to add manual code to setup().
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['arduino_functions'] = function (block) {
+    // Edited version of Blockly.Generator.prototype.statementToCode
+    function statementToCodeNoTab(block, name) {
+        var targetBlock = block.getInputTargetBlock(name);
+        var code = Blockly.Arduino.blockToCode(targetBlock);
+        if (typeof code != 'string') {
+            throw 'Expecting code from statement block "' + targetBlock.type + '".';
+        }
+        return code;
+    }
+
+    var setupBranch = Blockly.Arduino.statementToCode(block, 'SETUP_FUNC');
+    //var setupCode = Blockly.Arduino.scrub_(block, setupBranch); No comment block
+    if (setupBranch) {
+        Blockly.Arduino.setupCode_('userSetupCode', setupBranch, true);
+    }
+
+    var loopBranch = statementToCodeNoTab(block, 'LOOP_FUNC');
+    //var loopcode = Blockly.Arduino.scrub_(block, loopBranch); No comment block
+    return loopBranch;
+};

src/components/Blockly/generator/sensebox-osem.js

@@ -0,0 +1,178 @@
+import Blockly, { Blocks } from 'blockly';
+import { getColour } from '../helpers/colour'
+import Block from 'blockly';
+
+
+/**
+* Block send Data to the openSenseMap
+*/
+Blockly.Arduino.sensebox_send_to_osem = function (block) {
+  var code = '';
+  var sensor_id = this.getFieldValue('SensorID');
+  var id = sensor_id.slice(-3).toUpperCase();
+  var sensor_value = Blockly.Arduino.valueToCode(this, 'Value', Blockly.Arduino.ORDER_ATOMIC) || '"Keine Eingabe"';
+  Blockly.Arduino.definitions_['SENSOR_ID' + id + ''] = 'const char SENSOR_ID' + id + '[] PROGMEM = "' + sensor_id + '";';
+  code += 'addMeasurement(SENSOR_ID' + id + ',' + sensor_value + ');\n';
+  return code;
+};
+
+Blockly.Arduino.sensebox_osem_connection = function (Block) {
+  var box_id = this.getFieldValue('BoxID');
+  var host = this.getFieldValue('host');
+  var branch = Blockly.Arduino.statementToCode(Block, 'DO');
+  var blocks = Blockly.Block.getDescendants;
+  var type = this.getFieldValue('type');
+  var ssl = this.getFieldValue('SSL');
+  var port = 0;
+  var count = 0;
+  // for (var i = 0; i < blocks.length; i++) {
+  //     if (blocks[i].type === 'sensebox_send_to_osem') {
+  //         count++;
+
+  //     }
+  // }
+  var num_sensors = count;
+  Blockly.Arduino.libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
+  Blockly.Arduino.definitions_['num_sensors'] = 'static const uint8_t NUM_SENSORS = ' + num_sensors + ';'
+  Blockly.Arduino.definitions_['SenseBoxID'] = 'const char SENSEBOX_ID [] PROGMEM = "' + box_id + '";';
+  Blockly.Arduino.definitions_['host'] = 'const char server [] PROGMEM =' + host + ';';
+  if (ssl == 'TRUE') {
+    Blockly.Arduino.definitions_['WiFiSSLClient'] = 'WiFiSSLClient client;';
+    port = 443;
+  } else if (ssl == 'FALSE') {
+    Blockly.Arduino.definitions_['WiFiClient'] = 'WiFiClient client;';
+    port = 80;
+  }
+
+  Blockly.Arduino.definitions_['measurement'] = `typedef struct measurement {
+      const char *sensorId;
+      float value;
+    } measurement;`;
+  Blockly.Arduino.definitions_['buffer'] = 'char buffer[750];';
+  Blockly.Arduino.definitions_['num_measurement'] = `measurement measurements[NUM_SENSORS];
+    uint8_t num_measurements = 0;`;
+  Blockly.Arduino.definitions_['lengthMultiplikator'] = 'const int lengthMultiplikator = 35;';
+  Blockly.Arduino.functionNames_['addMeasurement'] = `
+    void addMeasurement(const char *sensorId, float value) {
+    measurements[num_measurements].sensorId = sensorId;
+    measurements[num_measurements].value = value;
+    num_measurements++;
+    }`;
+  if (type === 'Stationary') {
+    Blockly.Arduino.functionNames_['writeMeasurementsToClient'] = `
+    void writeMeasurementsToClient() {
+    // iterate throug the measurements array
+    for (uint8_t i = 0; i < num_measurements; i++) {
+      sprintf_P(buffer, PSTR("%s,%9.2f\\n"), measurements[i].sensorId,
+                measurements[i].value);
+      // transmit buffer to client
+      client.print(buffer);
+    }
+    // reset num_measurements
+    num_measurements = 0;
+  }`;
+    Blockly.Arduino.functionNames_['submitValues'] = `
+    void submitValues() {
+  if (client.connected()) {
+    client.stop();
+    delay(10);
+  }
+  bool connected = false;
+  char _server[strlen_P(server)];
+  strcpy_P(_server, server);
+  for (uint8_t timeout = 2; timeout != 0; timeout--) {
+    Serial.println(F("connecting..."));
+    connected = client.connect(_server, `+ port + `);
+    if (connected == true) {
+      // construct the HTTP POST request:
+      sprintf_P(buffer,
+                PSTR("POST /boxes/%s/data HTTP/1.1\\nHost: %s\\nContent-Type: "
+                     "text/csv\\nConnection: close\\nContent-Length: %i\\n\\n"),
+                SENSEBOX_ID, server, num_measurements * lengthMultiplikator);
+      // send the HTTP POST request:
+      client.print(buffer);
+      // send measurements
+      writeMeasurementsToClient();
+      // send empty line to end the request
+      client.println();
+      uint16_t timeout = 0;
+      // allow the response to be computed
+      while (timeout <= 5000) {
+        delay(10);
+        timeout = timeout + 10;
+        if (client.available()) {
+          break;
+        }
+      }
+      num_measurements = 0;
+      break;
+    }
+  }
+  }`;
+    var code = '';
+    code += branch;
+    code += "submitValues();\n";
+  }
+  else if (type === 'Mobile') {
+    var lat = Blockly.Arduino.valueToCode(Block, 'lat', Blockly.Arduino.ORDER_ATOMIC);
+    var lng = Blockly.Arduino.valueToCode(Block, 'lng', Blockly.Arduino.ORDER_ATOMIC);
+    var timestamp = Blockly.Arduino.valueToCode(Block, 'timeStamp', Blockly.Arduino.ORDER_ATOMIC);
+    var altitude = Blockly.Arduino.valueToCode(Block, 'altitude', Blockly.Arduino.ORDER_ATOMIC);
+    Blockly.Arduino.definitions_['lengthMultiplikator'] = 'const int lengthMultiplikator = 77;';
+    Blockly.Arduino.functionNames_['writeMeasurementsToClient'] = `
+      void writeMeasurementsToClient(float lat, float lng, float altitude, char* timeStamp) {
+      // iterate throug the measurements array
+      for (uint8_t i = 0; i < num_measurements; i++) {
+      sprintf_P(buffer, PSTR("%s,%9.2f,%s,%3.6f,%3.6f,%5.2f\\n"), measurements[i].sensorId,
+                measurements[i].value, timeStamp, lng, lat, altitude);
+      // transmit buffer to client
+      client.print(buffer);
+      }
+      // reset num_measurements
+      num_measurements = 0;
+      }`;
+    Blockly.Arduino.functionNames_['submitValues'] = `
+      void submitValues(float lat, float lng, float altitude, char* timeStamp) {
+    if (client.connected()) {
+      client.stop();
+      delay(10);
+    }
+    bool connected = false;
+    char _server[strlen_P(server)];
+    strcpy_P(_server, server);
+    for (uint8_t timeout = 2; timeout != 0; timeout--) {
+      Serial.println(F("connecting..."));
+      connected = client.connect(_server, `+ port + `);
+      if (connected == true) {
+        // construct the HTTP POST request:
+        sprintf_P(buffer,
+                  PSTR("POST /boxes/%s/data HTTP/1.1\\nHost: %s\\nContent-Type: "
+                       "text/csv\\nConnection: close\\nContent-Length: %i\\n\\n"),
+                  SENSEBOX_ID, server, num_measurements * lengthMultiplikator);
+        // send the HTTP POST request:
+        client.print(buffer);
+        // send measurements
+        writeMeasurementsToClient(lat, lng, altitude, timeStamp);
+        // send empty line to end the request
+        client.println();
+        uint16_t timeout = 0;
+        // allow the response to be computed
+        while (timeout <= 5000) {
+          delay(10);
+          timeout = timeout + 10;
+          if (client.available()) {
+            break;
+          }
+        }
+    
+        num_measurements = 0;
+        break;
+      }
+    }
+  }`
+    var code = '';
+    code += branch;
+    code += 'submitValues(' + lat + ',' + lng + ',' + altitude + ',' + timestamp + ');\n';
+  }
+  return code;
+};

src/components/Blockly/generator/sensebox-sensors.js

@@ -1,6 +1,225 @@
-import * as Blockly from 'blockly/core';
-import { Block } from 'blockly';
+import Blockly from 'blockly';
+import { getColour } from '../helpers/colour';
+import { selectedBoard } from '../helpers/board';
 
-Blockly.Arduino['sensebox_telegram'] = function (Block) {
+/**
+ * HDC1080 Temperature and Humidity Sensor
+ * 
+ */
 
-};
+Blockly.Arduino.sensebox_sensor_temp_hum = function () {
+    var dropdown_name = this.getFieldValue('NAME');
+    Blockly.Arduino.libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
+    Blockly.Arduino.definitions_['define_hdc'] = 'HDC1080 hdc;';
+    Blockly.Arduino.setupCode_['sensebox_sensor_temp_hum'] = 'hdc.begin();';
+    var code = 'hdc.get' + dropdown_name + '()';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+/**
+ * VEML 6070 and TSL4513 UV-Light/Illuminance Sensor
+ * 
+ */
+
+Blockly.Arduino.sensebox_sensor_uv_light = function () {
+    var dropdown_name = this.getFieldValue('NAME');
+    Blockly.Arduino.libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
+    if (dropdown_name === 'UvIntensity') {
+        Blockly.Arduino.definitions_['define_veml'] = 'VEML6070 veml;'
+        Blockly.Arduino.setupCode_['sensebox_sensor_uv_light'] = 'veml.begin();'
+        var code = 'veml.get' + dropdown_name + '()';
+    }
+    if (dropdown_name === 'Illuminance') {
+        Blockly.Arduino.definitions_['define_tsl'] = 'TSL45315 tsl;'
+        Blockly.Arduino.setupCode_['sensebox_sensor_illuminance'] = 'tsl.begin();'
+        var code = 'tsl.get' + dropdown_name + '()';
+    }
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+
+/**
+ * BMX055 Accelerometer
+ * 
+ */
+
+Blockly.Arduino.sensebox_sensor_bmx055_accelerometer = function () {
+    var dropdown_value = this.getFieldValue('VALUE');
+    var range = this.getFieldValue('RANGE');
+    Blockly.Arduino.libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
+    Blockly.Arduino.definitions_['define_bmx'] = 'BMX055 bmx;';
+    Blockly.Arduino.setupCode_['sensebox_sensor_bmx055'] = 'bmx.beginAcc(' + range + ');';
+    var code = 'bmx.getAcceleration' + dropdown_value + '()';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+/**
+ * SDS011 Fine Particlar Matter
+ * 
+ */
+
+Blockly.Arduino.sensebox_sensor_sds011 = function () {
+    var dropdown_name = this.getFieldValue('NAME');
+    var serial_name = this.getFieldValue('SERIAL');
+    Blockly.Arduino.libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
+    Blockly.Arduino.codeFunctions_['define_sds011'] = 'SDS011 my_sds(' + serial_name + ');';
+    Blockly.Arduino.variables_['variables_sds011'] = 'float p10,p25;\n';
+    Blockly.Arduino.setupCode_['sensebox_sensor_sds011'] = serial_name + '.begin(9600);';
+    var code = 'my_sds.get' + dropdown_name + '()';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+/**
+ * BMP280 Pressure Sensor
+ * 
+ */
+
+Blockly.Arduino.sensebox_sensor_pressure = function () {
+    var dropdown_name = this.getFieldValue('NAME');
+    var referencePressure = this.getFieldValue('referencePressure');
+    Blockly.Arduino.libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
+    Blockly.Arduino.definitions_['define_pressure'] = 'BMP280 bmp_sensor;';
+    Blockly.Arduino.setupCode_['sensebox_bmp_sensor'] = 'bmp_sensor.begin();';
+    if (dropdown_name === 'Pressure' || dropdown_name == 'Temperature') {
+        var code = 'bmp_sensor.get' + dropdown_name + '()';
+    }
+    else if (dropdown_name === 'Altitude') {
+        var code = 'bmp_sensor.getAltitude(' + referencePressure + ')';
+    }
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+
+/**
+ * BME680 Environmental Sensor
+ * 
+ */
+
+
+Blockly.Arduino.sensebox_sensor_bme680_bsec = function () {
+    var dropdown_name = this.getFieldValue('dropdown');
+    Blockly.Arduino.libraries_['library_bsec'] = '#include "bsec.h"';
+    Blockly.Arduino.definitions_['bsec_iaqSensor'] = 'Bsec iaqSensor;'
+    Blockly.Arduino.variables_['bmeTemperatur'] = 'float bmeTemperatur;';
+    Blockly.Arduino.variables_['bmeHumidity'] = 'float bmeHumidity;';
+    Blockly.Arduino.variables_['bmePressure'] = 'double bmePressure;';
+    Blockly.Arduino.variables_['bmeIAQ'] = 'float bmeIAQ;';
+    Blockly.Arduino.variables_['bmeIAQAccuracy'] = 'float bmeIAQAccuracy;';
+    Blockly.Arduino.variables_['bmeCO2'] = 'int bmeCO2;';
+    Blockly.Arduino.variables_['bmeBreathVocEquivalent'] = 'float bmeBreathVocEquivalent;'
+
+    Blockly.Arduino.functionNames_['checkIaqSensorStatus'] = `
+    void checkIaqSensorStatus(void)
+  {
+    if (iaqSensor.status != BSEC_OK) {
+      if (iaqSensor.status < BSEC_OK) {
+        for (;;)
+          errLeds(); /* Halt in case of failure */
+      } 
+    }
+  
+    if (iaqSensor.bme680Status != BME680_OK) {
+      if (iaqSensor.bme680Status < BME680_OK) {
+        for (;;)
+          errLeds(); /* Halt in case of failure */
+      } 
+    }
+  }
+  `;
+    Blockly.Arduino.functionNames_['errLeds'] = `
+  void errLeds(void)
+  {
+    pinMode(LED_BUILTIN, OUTPUT);
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(100);
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(100);
+  }`;
+    //Setup Code
+    Blockly.Arduino.setupCode_['Wire.begin'] = 'Wire.begin();';
+    Blockly.Arduino.setupCode_['iaqSensor.begin'] = 'iaqSensor.begin(BME680_I2C_ADDR_PRIMARY, Wire);';
+    Blockly.Arduino.setupCode_['checkIaqSensorStatus'] = 'checkIaqSensorStatus();';
+    Blockly.Arduino.setupCode_['bsec_sensorlist'] = `
+    bsec_virtual_sensor_t sensorList[10] = {
+      BSEC_OUTPUT_RAW_TEMPERATURE,
+      BSEC_OUTPUT_RAW_PRESSURE,
+      BSEC_OUTPUT_RAW_HUMIDITY,
+      BSEC_OUTPUT_RAW_GAS,
+      BSEC_OUTPUT_IAQ,
+      BSEC_OUTPUT_STATIC_IAQ,
+      BSEC_OUTPUT_CO2_EQUIVALENT,
+      BSEC_OUTPUT_BREATH_VOC_EQUIVALENT,
+      BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE,
+      BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY,
+    };
+    `;
+    Blockly.Arduino.setupCode_['iaqSensorUpdateSubscription'] = 'iaqSensor.updateSubscription(sensorList, 10, BSEC_SAMPLE_RATE_LP);\ncheckIaqSensorStatus();';
+    //Loop Code
+    Blockly.Arduino.loopCodeOnce_['iaqloop'] = `
+    if (iaqSensor.run()) {
+      bmeTemperatur = iaqSensor.temperature;
+      bmeHumidity = iaqSensor.humidity;
+      bmePressure = iaqSensor.pressure;
+      bmeIAQ = iaqSensor.iaq;
+      bmeIAQAccuracy = iaqSensor.iaqAccuracy;
+      bmeCO2 = iaqSensor.co2Equivalent;
+      bmeBreathVocEquivalent = iaqSensor.breathVocEquivalent;
+    } else {
+      checkIaqSensorStatus();
+    }
+    `;
+    switch (dropdown_name) {
+        case 'temperature':
+            var code = 'bmeTemperatur';
+            break;
+        case 'humidity':
+            var code = 'bmeHumidity';
+            break;
+        case 'pressure':
+            var code = 'bmePressure'
+            break;
+        case 'IAQ':
+            var code = 'bmeIAQ';
+            break;
+        case 'IAQAccuracy':
+            var code = 'bmeIAQAccuracy';
+            break;
+        case 'CO2':
+            var code = 'bmeCO2';
+            break;
+        case 'breathVocEquivalent':
+            var code = 'bmeBreathVocEquivalent';
+            break;
+    }
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+
+/**
+ * Ultrasonic Distance Sensor
+ * 
+ */
+
+Blockly.Arduino.sensebox_sensor_ultrasonic_ranger = function () {
+    var dropdown_pin_RX = this.getFieldValue('ultrasonic_trigger');
+    var dropdown_pin_TX = this.getFieldValue('ultrasonic_echo');
+    var port = this.getFieldValue('port');
+    Blockly.Arduino.libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
+    Blockly.Arduino.definitions_['var_ultrasonic' + port] = 'Ultrasonic Ultrasonic' + port + '(' + dropdown_pin_RX + ',' + dropdown_pin_TX + ');';
+    var code;
+    code = 'Ultrasonic' + port + '.getDistance()';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+/**
+ * Microphone
+ * 
+ */
+
+Blockly.Arduino.sensebox_sensor_sound = function () {
+    var dropdown_pin = this.getFieldValue('PIN');
+    Blockly.Arduino.libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
+    Blockly.Arduino.definitions_['define_microphone'] = 'Microphone microphone(' + dropdown_pin + ');'
+    var code = 'microphone.getValue()';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};

src/components/Blockly/generator/sensebox-telegram.js

@@ -0,0 +1,58 @@
+import * as Blockly from 'blockly/core';
+import { Block } from 'blockly';
+
+
+/**
+ * Telegram Bot by re:edu
+ */
+Blockly.Arduino.sensebox_telegram = function (Block) {
+    let token = Block.getFieldValue('telegram_token');
+    Blockly['Arduino'].libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
+    Blockly['Arduino'].libraries_['library_telegram'] = `#include <UniversalTelegramBot.h>`
+    Blockly['Arduino'].functionNames_['WiFiSSLClient'] = 'WiFiSSLClient client;';
+    Blockly['Arduino'].functionNames_['telegram_objects'] = `#define BOTtoken "${token}"  // your Bot Token (Get from Botfather)
+      
+    UniversalTelegramBot bot(BOTtoken, client);`
+
+    let code = 'testcode';
+    return code;
+};
+
+Blockly.Arduino.sensebox_telegram_do = function (block) {
+    var messageProcessing = Blockly.Arduino.statementToCode(block, 'telegram_do', Blockly.Arduino.ORDER_ATOMIC);
+
+    Blockly.Arduino.definitions_['telegram_variables'] = `int Bot_mtbs = 1000; //mean time between scan messages
+  long Bot_lasttime;   //last time messages' scan has been done`
+
+    Blockly.Arduino.loopCodeOnce_['sensebox_telegram_loop'] = `if (millis() > Bot_lasttime + Bot_mtbs)  {
+      int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
+      while(numNewMessages) {
+        for(int i=0; i<numNewMessages; i++) {
+          String chat_id = String(bot.messages[i].chat_id);
+          String text = bot.messages[i].text;
+  
+          ${messageProcessing}
+        }
+        numNewMessages = bot.getUpdates(bot.last_message_received + 1);
+      }
+      Bot_lasttime = millis();
+    }`;
+    var code = '';
+    return code;
+};
+
+Blockly.Arduino.sensebox_telegram_do_on_message = function (block) {
+    var message = this.getFieldValue('telegram_message');
+    var stuffToDo = Blockly.Arduino.statementToCode(block, 'telegram_do_on_message', Blockly.Arduino.ORDER_ATOMIC);
+    var code = `
+        if (text == "${message}") {
+          ${stuffToDo}
+        }`;
+    return code;
+};
+
+Blockly.Arduino.sensebox_telegram_send = function (block) {
+    var textToSend = Blockly.Arduino.valueToCode(this, 'telegram_text_to_send', Blockly.Arduino.ORDER_ATOMIC) || '"Keine Eingabe"';
+    var code = `bot.sendMessage(chat_id, String(${textToSend}), "");\n`;
+    return code;
+};

src/components/Blockly/generator/sensebox.js

@@ -1,19 +1,3 @@
 import * as Blockly from 'blockly/core';
 import { Block } from 'blockly';
 
-
-/**
- * Telegram Bot by re:edu
- */
-Blockly.Arduino['sensebox_telegram'] = function (Block) {
-  let token = Block.getFieldValue('telegram_token');
-  Blockly['Arduino'].libraries_['library_senseBoxMCU'] = '#include "SenseBoxMCU.h"';
-  Blockly['Arduino'].libraries_['library_telegram'] = `#include <UniversalTelegramBot.h>`
-  Blockly['Arduino'].functionNames_['WiFiSSLClient'] = 'WiFiSSLClient client;';
-  Blockly['Arduino'].functionNames_['telegram_objects'] = `#define BOTtoken "${token}"  // your Bot Token (Get from Botfather)
-    
-  UniversalTelegramBot bot(BOTtoken, client);`
-
-  let code = 'testcode';
-  return code;
-};

src/components/Blockly/generator/time.js

@@ -0,0 +1,80 @@
+import Blockly from 'blockly';
+
+/**
+ * @license Licensed under the Apache License, Version 2.0 (the "License"):
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @fileoverview Arduino code generator for the Time blocks.
+ *     Arduino built-in function docs: http://arduino.cc/en/Reference/HomePage
+ */
+
+/**
+ * Code generator for the delay Arduino block.
+ * Arduino code: loop { delay(X); }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['time_delay'] = function (block) {
+    var delayTime = Blockly.Arduino.valueToCode(
+        block, 'DELAY_TIME_MILI', Blockly.Arduino.ORDER_ATOMIC) || '0';
+    var code = 'delay(' + delayTime + ');\n';
+    return code;
+};
+
+/**
+ * Code generator for the delayMicroseconds block.
+ * Arduino code: loop { delayMicroseconds(X); }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['time_delaymicros'] = function (block) {
+    var delayTimeMs = Blockly.Arduino.valueToCode(
+        block, 'DELAY_TIME_MICRO', Blockly.Arduino.ORDER_ATOMIC) || '0';
+    var code = 'delayMicroseconds(' + delayTimeMs + ');\n';
+    return code;
+};
+
+/**
+ * Code generator for the elapsed time in milliseconds block.
+ * Arduino code: loop { millis() }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['time_millis'] = function (block) {
+    var code = 'millis()';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+/**
+ * Code generator for the elapsed time in microseconds block.
+ * Arduino code: loop { micros() }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['time_micros'] = function (block) {
+    var code = 'micros()';
+    return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+/**
+ * Code generator for the wait forever (end of program) block
+ * Arduino code: loop { while(true); }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['infinite_loop'] = function (block) {
+    return 'while(true);\n';
+};
+
+Blockly.Arduino.sensebox_interval_timer = function (block) {
+    var interval = this.getFieldValue('interval');
+    Blockly.Arduino.variables_['define_interval_variables'] = 'const long interval = ' + interval + ';\nlong time_start = 0;\nlong time_actual = 0;';
+    var branch = Blockly.Arduino.statementToCode(block, 'DO');
+    var code = 'time_start = millis();\n';
+    code += 'if (time_start > time_actual + interval) {\n  time_actual = millis();\n'
+    code += branch;
+    code += '}\n'
+    return code;
+};