diff --git a/ardublockly/ardublockly_toolbox.js b/ardublockly/ardublockly_toolbox.js
index 10f75f68f8..da553e51fb 100644
--- a/ardublockly/ardublockly_toolbox.js
+++ b/ardublockly/ardublockly_toolbox.js
@@ -150,6 +150,16 @@ Ardublockly.TOOLBOX_XML =
 '        <block type="math_number"></block>' +
 '      </value>'+
 '    </block>' +
+'    <block type="analogsensor_config_hub"></block>' +
+'    <block type="analogsensor_read"></block>' +
+'    <block type="digitalinput_config_hub"></block>' +
+'    <block type="digitalinput_read"></block>' +
+'    <block type="button_setup"></block>' +
+'    <block type="button_input"></block>' +
+'    <block type="digitaloutput_config_hub"></block>' +
+'    <block type="digitaloutput_write"></block>' +
+'    <block type="pwmoutput_config_hub"></block>' +
+'    <block type="pwmoutput_write"></block>' +
 '  </category>' +
 '  <sep></sep>' +
 '  <category id="catTime" name="Time">' +
@@ -172,6 +182,83 @@ Ardublockly.TOOLBOX_XML =
 '    <block type="infinite_loop"></block>' +
 '  </category>' +
 '  <sep></sep>' +
+'  <category id="catComponent" name="Components">' +
+'    <block type="core_hub_component"></block>' +
+'    <block type="led_config_hub"></block>' +
+'    <block type="neopixel_config_hub">' +
+'      <value name="NUMBER">' +
+'        <block type="math_number">' +
+'          <field name="NUM">1</field>' +
+'        </block>' +
+'      </value>' +
+'    </block>' +
+'    <block type="analogsensor_config_hub"></block>' +
+'    <block type="digitalinput_config_hub"></block>' +
+'    <block type="button_setup"></block>' +
+'    <block type="digitaloutput_config_hub"></block>' +
+'    <block type="pwmoutput_config_hub"></block>' +
+'    <block type="servo_config_hub"></block>' +
+'    <block type="stepper_config_hub">' +
+'      <value name="STEPPER_STEPS">' +
+'        <block type="math_number">' +
+'          <field name="NUM">100</field>' +
+'        </block>' +
+'      </value>' +
+'      <value name="STEPPER_SPEED">' +
+'        <block type="math_number">' +
+'          <field name="NUM">10</field>' +
+'        </block>' +
+'      </value>' +
+'    </block>' +
+'    <block type="led_digitalwrite_onoff"></block>' +
+'    <block type="led_digitalwrite">' +
+'      <value name="STATE">' +
+'        <shadow type="io_highlow"></shadow>' +
+'      </value>' +
+'    </block>' +
+'    <block type="neopixel_colourpick_write">' +
+'      <value name="LEDPIXEL">' +
+'        <block type="math_number">' +
+'          <field name="NUM">1</field>' +
+'        </block>' +
+'      </value>' +
+'    </block>' +
+'    <block type="neopixel_colourpick_dim_write">' +
+'      <value name="LEDPIXEL">' +
+'        <block type="math_number">' +
+'          <field name="NUM">1</field>' +
+'        </block>' +
+'      </value>' +
+'      <value name="BRIGHTNESS">' +
+'        <block type="math_number">' +
+'          <field name="NUM">100</field>' +
+'        </block>' +
+'      </value>' +
+'    </block>' +
+'    <block type="neopixel_write">' +
+'      <value name="LEDPIXEL">' +
+'        <block type="math_number">' +
+'          <field name="NUM">1</field>' +
+'        </block>' +
+'      </value>' +
+'      <value name="RED">' +
+'        <block type="math_number">' +
+'          <field name="NUM">255</field>' +
+'        </block>' +
+'      </value>' +
+'      <value name="GREEN">' +
+'        <block type="math_number">' +
+'          <field name="NUM">0</field>' +
+'        </block>' +
+'      </value>' +
+'      <value name="BLUE">' +
+'        <block type="math_number">' +
+'          <field name="NUM">0</field>' +
+'        </block>' +
+'      </value>' +
+'    </block>' +
+'  </category>' +
+'  <sep></sep>' +
 '  <category id="catMusic" name="Music">' +
 '    <block type="io_tone">' +
 '      <field name="TONEPIN">0</field>' +
@@ -214,6 +301,41 @@ Ardublockly.TOOLBOX_XML =
 '        </block>' +
 '      </value>' +
 '    </block>' +
+'    <block type="servo_config_hub"></block>' +
+'    <block type="stepper_config_hub">' +
+'      <value name="STEPPER_STEPS">' +
+'        <block type="math_number">' +
+'          <field name="NUM">100</field>' +
+'        </block>' +
+'      </value>' +
+'      <value name="STEPPER_SPEED">' +
+'        <block type="math_number">' +
+'          <field name="NUM">10</field>' +
+'        </block>' +
+'      </value>' +
+'    </block>' +
+'    <block type="servohub_write">' +
+'      <value name="SERVO_ANGLE">' +
+'        <block type="math_number">' +
+'          <field name="NUM">90</field>' +
+'        </block>' +
+'      </value>' +
+'    </block>' +
+'    <block type="servohub_write2">' +
+'      <value name="SERVO_SPEED">' +
+'        <block type="math_number">' +
+'          <field name="NUM">50</field>' +
+'        </block>' +
+'      </value>' +
+'    </block>' +
+'    <block type="servohub_read"></block>' +
+'    <block type="stepper_step">' +
+'      <value name="STEPPER_STEPS">' +
+'        <block type="math_number">' +
+'          <field name="NUM">10</field>' +
+'        </block>' +
+'      </value>' +
+'    </block>' +
 '  </category>' +
 '  <sep></sep>' +
 '  <category id="catComms" name="Comms">' +
diff --git a/ardublockly/index.html b/ardublockly/index.html
index fac392f695..3cc1ab3905 100644
--- a/ardublockly/index.html
+++ b/ardublockly/index.html
@@ -18,6 +18,7 @@
   <script src="../blockly/arduino_compressed.js"></script>
   <!-- To use the uncompressed version comment out the above and comment in the ones below -->
   <!--script src="../blockly/blockly_uncompressed.js"></script>
+  <script src="../blockly/blocks/component_variable.js"></script>
   <script src="../blockly/blocks/logic.js"></script>
   <script src="../blockly/blocks/loops.js"></script>
   <script src="../blockly/blocks/math.js"></script>
@@ -26,7 +27,10 @@
   <script src="../blockly/blocks/colour.js"></script>
   <script src="../blockly/blocks/variables.js"></script>
   <script src="../blockly/blocks/procedures.js"></script>
+  <script src="../blockly/blocks/arduino/button.js"></script>
+  <script src="../blockly/blocks/arduino/components.js"></script>
   <script src="../blockly/blocks/arduino/io.js"></script>
+  <script src="../blockly/blocks/arduino/light.js"></script>
   <script src="../blockly/blocks/arduino/map.js"></script>
   <script src="../blockly/blocks/arduino/procedures.js"></script>
   <script src="../blockly/blocks/arduino/serial.js"></script>
@@ -38,6 +42,9 @@
   <script src="../blockly/blocks/arduino/variables.js"></script>
   <script src="../blockly/generators/arduino.js"></script>
   <script src="../blockly/generators/arduino/boards.js"></script>
+  <script src="../blockly/generators/arduino/button.js"></script>
+  <script src="../blockly/generators/arduino/components.js"></script>
+  <script src="../blockly/generators/arduino/light.js"></script>
   <script src="../blockly/generators/arduino/io.js"></script>
   <script src="../blockly/generators/arduino/lists.js"></script>
   <script src="../blockly/generators/arduino/logic.js"></script>
diff --git a/blockly/blocks/arduino/button.js b/blockly/blocks/arduino/button.js
new file mode 100644
index 0000000000..739880b480
--- /dev/null
+++ b/blockly/blocks/arduino/button.js
@@ -0,0 +1,165 @@
+/**
+ * @license Licensed under the Apache License, Version 2.0 (the "License"):
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @fileoverview Block for the Microduino functions.
+ *     The Arduino built in functions syntax can be found at:
+ *     https://arduino.cc/en/Reference/HomePage
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.button');
+
+goog.require('Blockly.Blocks');
+
+
+/** Common HSV hue for all blocks in this category. */
+Blockly.Blocks.button.HUE = 250;
+
+
+/** Attach a button block to the hub*/
+Blockly.Blocks['button_setup'] = {
+  init: function() {
+    this.appendDummyInput()
+        .appendField(new Blockly.FieldImage("../media/arduino/Button.png", 19, 19, "*"))
+        .appendField(Blockly.Msg.ARD_BUTTON_COMPONENT)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_BUTTON_DEFAULT_NAME, 'Button'), 'BUTTONNAME')
+        .appendField(Blockly.Msg.ARD_BUTTON_IFPUSHED)
+        .appendField(
+            new Blockly.FieldDropdown([[Blockly.Msg.ARD_HIGH, 'HIGH'], [Blockly.Msg.ARD_LOW, 'LOW']]),
+           'STATE');
+    this.setOutput(true, 'HUB_DIG');
+    this.setColour(Blockly.Blocks.button.HUE);
+    this.setTooltip(Blockly.Msg.ARD_BUTTON_TIP);
+    this.setHelpUrl('https://www.arduino.cc/en/Tutorial/Button');
+  },
+  /**
+   * Set the connection pins that the component connects to
+   * @param {array} array of the connections (as string, eg '1', 'SDA', 'A1', ...
+   * @this Blockly.Block
+   */
+  setHubConnector: function(connector) {
+    this['connector'] = connector;
+  },
+  /**
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'Button';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('BUTTONNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('BUTTONNAME'))) {
+      this.setFieldValue(newName, 'BUTTONNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  }
+};
+
+
+Blockly.Blocks['button_input'] = {
+  init: function() {
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_BUTTON_INPUT_IF)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_BUTTON_DEFAULT_NAME, 'Button'), 'BUTTONNAME')
+        .appendField(Blockly.Msg.ARD_BUTTON_INPUT_CLICK);
+    this.appendStatementInput("CLICKINPUT")
+        .setCheck('ARD_BLOCK')
+        .appendField(Blockly.Msg.ARD_BUTTON_INPUT_THEN);
+    this.appendDummyInput()
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField(Blockly.Msg.ARD_BUTTON_INPUT_LONGCLICK);
+    this.appendStatementInput("LONGPRESSINPUT")
+        .setCheck('ARD_BLOCK')
+        .appendField(Blockly.Msg.ARD_BUTTON_INPUT_THEN);
+    this.appendDummyInput()
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField(Blockly.Msg.ARD_BUTTON_INPUT_PRESSED);
+    this.appendStatementInput("PRESSINPUT")
+        .setCheck('ARD_BLOCK')
+        .appendField(Blockly.Msg.ARD_BUTTON_INPUT_THEN);
+    this.appendDummyInput()
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField(new Blockly.FieldCheckbox("TRUE"), "WAIT_INPUT")
+        .appendField(Blockly.Msg.ARD_BUTTON_INPUT_WAIT);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setColour(Blockly.Blocks.button.HUE);
+    this.setTooltip(Blockly.Msg.ARD_BUTTON_INPUT_TIP);
+    this.setHelpUrl('');
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('BUTTONNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('BUTTONNAME'))) {
+      this.setFieldValue(newName, 'BUTTONNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of the config block and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('BUTTONNAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'Button')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_BUTTON_COMPONENT).replace('%1', Blockly.Msg.ARD_BUTTON_COMPONENT));
+    }
+  }
+};
diff --git a/blockly/blocks/arduino/components.js b/blockly/blocks/arduino/components.js
new file mode 100644
index 0000000000..09d6c3a422
--- /dev/null
+++ b/blockly/blocks/arduino/components.js
@@ -0,0 +1,436 @@
+/**
+ * @license Licensed under the Apache License, Version 2.0 (the "License"):
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @fileoverview Block for standard Arduino components.
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.components');
+
+goog.require('Blockly.Blocks');
+
+
+/** Common HSV hue for all blocks in this category. */
+Blockly.Blocks.components.HUE = '#70D65C'; //110;
+
+
+Blockly.Blocks['core_hub_component'] = {
+  /**
+   * Block for the core hub component to which you can connect sensors/light/...
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.arguments_ = [];
+    this.setHelpUrl(''); //Blockly.Msg.ARD_CONTROLS_EFFECT_HELPURL);
+    this.setColour(Blockly.Blocks.components.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_BOARD)
+        .appendField(
+            new Blockly.FieldDropdown(
+                [['Arduino Uno', 'uno'],
+                 ['Arduino Duemilanove', 'duemilanove_168p'],
+                 ['Arduino Mega', 'mega'],
+                 ['Arduino Leonardo/Yun', 'leonardo']
+                ]), 'BOARD');
+    this.setMutator(new Blockly.Mutator(['core_hub_digpin',
+                                         'core_hub_anapin',
+                                         'core_hub_pwmpin',
+                                         'core_hub_digdigpin']));
+    // Assign 'this' to a variable for use in the tooltip closure below.
+    var thisBlock = this;
+    this.setTooltip(Blockly.Msg.ARD_COMPONENT_BOARD_TIP);
+    this.digCount_ = 0;
+    this.anaCount_ = 0;
+    this.pwmCount_ = 0;
+    this.digdigCount_ = 0;
+  },
+  /**
+   * Returns the Arduino Board name that is required for this block.
+   * @return {!string} Board name.
+   * @this Blockly.Block
+   */
+  getBoardName: function() {
+    return this.getFieldValue('BOARD');
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks if the board selected corresponds to the what it should be
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    // Iterate through top level blocks to find if there are other board modules
+    var blocks = this.workspace.getAllBlocks();
+    var otherBoardPresent = false;
+    for (var x = 0; x < blocks.length; x++) {
+      var func = blocks[x].getBoardName;
+      if (func) {
+        var BoardName = func.call(blocks[x]);
+        if (BoardName != this.getBoardName()) {
+          otherBoardPresent = true;
+        }
+      }
+    }
+    
+    if (otherBoardPresent) {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_BOARD_WARN.replace('%1', Blockly.Msg.ARD_COMPONENT_BOARD), 'board');
+    } else {
+      Blockly.Arduino.Boards.changeBoard(this.workspace, this.getBoardName());
+      this.setWarningText(null, 'board');
+    }
+  },
+  /**
+   * Create XML to represent the number of pins.
+   * @return {Element} XML storage element.
+   * @this Blockly.Block
+   */
+  mutationToDom: function() {
+    if (!this.digCount_ && !this.anaCount_ && !this.pwmCount_) {
+      return null;
+    }
+    var container = document.createElement('mutation');
+    if (this.digCount_) {
+      container.setAttribute('dig', this.digCount_);
+    }
+    if (this.anaCount_) {
+      container.setAttribute('ana', this.anaCount_);
+    }
+    if (this.pwmCount_) {
+      container.setAttribute('pwm', this.pwmCount_);
+    }
+    if (this.digdigCount_) {
+      container.setAttribute('digdig', this.digdigCount_);
+    }
+    return container;
+  },
+  /**
+   * Parse XML to restore the pin inputs.
+   * @param {!Element} xmlElement XML storage element.
+   * @this Blockly.Block
+   */
+  domToMutation: function(xmlElement) {
+    this.digCount_ = parseInt(xmlElement.getAttribute('dig'), 10) || 0;
+    this.anaCount_ = parseInt(xmlElement.getAttribute('ana'), 10) || 0;
+    this.pwmCount_ = parseInt(xmlElement.getAttribute('pwm'), 10) || 0;
+    this.digdigCount_ = parseInt(xmlElement.getAttribute('digdig'), 10) || 0;
+    for (var i = 1; i <= this.digCount_; i++) {
+      this.appendValueInput('DIG' + i)
+          .setCheck(["HUB_DIG", "HUB_DIGOUT"])
+          .appendField(Blockly.Msg.ARD_PIN_DIG)
+          .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.digitalPins), "PIND"+i)
+          .setAlign(Blockly.ALIGN_RIGHT);
+    }
+    for (var i = 1; i <= this.anaCount_; i++) {
+      this.appendValueInput('ANA' + i)
+          .setCheck(["HUB_DIG", "HUB_ANA"])
+          .appendField(Blockly.Msg.ARD_PIN_AN)
+          .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.analogPins), "PINA"+i)
+          .setAlign(Blockly.ALIGN_RIGHT);
+    }
+    for (var i = 1; i <= this.pwmCount_; i++) {
+      this.appendValueInput('PWM' + i)
+          .setCheck(["HUB_PWM"])
+          .appendField(Blockly.Msg.ARD_PIN_PWM)
+          .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.pwmPins), "PINP"+i)
+          .setAlign(Blockly.ALIGN_RIGHT);
+    }
+    for (var i = 1; i <= this.digdigCount_; i++) {
+      this.appendValueInput('DIGDIG' + i)
+          .setCheck(["HUB_DIGDIG"])
+          .appendField(Blockly.Msg.ARD_PIN_DIGDIG1)
+          .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.digitalPins), "PINDD1_"+i)
+          .appendField(Blockly.Msg.ARD_PIN_DIGDIG2)
+          .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.digitalPins), "PINDD2_"+i)
+          .setAlign(Blockly.ALIGN_RIGHT);
+    }
+  },
+  /**
+   * Populate the mutator's dialog with this block's components.
+   * @param {!Blockly.Workspace} workspace Mutator's workspace.
+   * @return {!Blockly.Block} Root block in mutator.
+   * @this Blockly.Block
+   */
+  decompose: function(workspace) {
+    var containerBlock = workspace.newBlock('core_hub_hub');
+    containerBlock.initSvg();
+    var connection = containerBlock.nextConnection;
+    for (var i = 1; i <= this.digCount_; i++) {
+      var digpinBlock = workspace.newBlock('core_hub_digpin');
+      digpinBlock.initSvg();
+      connection.connect(digpinBlock.previousConnection);
+      connection = digpinBlock.nextConnection;
+    }
+    for (var i = 1; i <= this.anaCount_; i++) {
+      var anapinBlock = workspace.newBlock('core_hub_anapin');
+      anapinBlock.initSvg();
+      connection.connect(anapinBlock.previousConnection);
+      connection = anapinBlock.nextConnection;
+    }
+    for (var i = 1; i <= this.pwmCount_; i++) {
+      var pwmpinBlock = workspace.newBlock('core_hub_pwmpin');
+      pwmpinBlock.initSvg();
+      connection.connect(pwmpinBlock.previousConnection);
+      connection = pwmpinBlock.nextConnection;
+    }
+    for (var i = 1; i <= this.digdigCount_; i++) {
+      var digpinBlock = workspace.newBlock('core_hub_digdigpin');
+      digpinBlock.initSvg();
+      connection.connect(digpinBlock.previousConnection);
+      connection = digpinBlock.nextConnection;
+    }
+    return containerBlock;
+  },
+  /**
+   * Reconfigure this block based on the mutator dialog's components.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this Blockly.Block
+   */
+  compose: function(containerBlock) {
+    // Disconnect all the digpin input blocks and remove the inputs.
+    var oldInputs = {}
+    for (var i = this.digCount_; i > 0; i--) {
+      oldInputs['DIG' + i] = this.getFieldValue('PIND' + i);
+      this.removeInput('DIG' + i);
+    }
+    this.digCount_ = 0;
+    // Disconnect all the anapin input blocks and remove the inputs.
+    for (var i = this.anaCount_; i > 0; i--) {
+      oldInputs['ANA' + i] = this.getFieldValue('PINA' + i);
+      this.removeInput('ANA' + i);
+    }
+    this.anaCount_ = 0;
+    // Disconnect all the pwmpin input blocks and remove the inputs.
+    for (var i = this.pwmCount_; i > 0; i--) {
+      oldInputs['PWM' + i] = this.getFieldValue('PINP' + i);
+      this.removeInput('PWM' + i);
+    }
+    this.pwmCount_ = 0;
+    // Disconnect all the double digpin input blocks and remove the inputs.
+    for (var i = this.digdigCount_; i > 0; i--) {
+      oldInputs['DIGDIG' + i] = [this.getFieldValue('PINDD1_' + i),
+                              this.getFieldValue('PINDD2_' + i)];
+      this.removeInput('DIGDIG' + i);
+    }
+    this.digdigCount_ = 0;
+    // Rebuild the block's optional inputs.
+    var clauseBlock = containerBlock.nextConnection.targetBlock();
+    console.log('inputs', oldInputs);
+    while (clauseBlock) {
+      switch (clauseBlock.type) {
+        case 'core_hub_digpin':
+          this.digCount_++;
+          var digInput = this.appendValueInput('DIG' + this.digCount_)
+              .setCheck(["HUB_DIG", "HUB_DIGOUT"])
+              .appendField(Blockly.Msg.ARD_PIN_DIG)
+              .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.digitalPins), "PIND" + this.digCount_)
+              .setAlign(Blockly.ALIGN_RIGHT);
+          if (! (oldInputs['DIG' + this.digCount_] == undefined)) {
+            this.setFieldValue(oldInputs['DIG' + this.digCount_], "PIND" + this.digCount_);
+          }
+          if (clauseBlock.valueDConnection_) {
+            digInput.connection.connect(clauseBlock.valueDConnection_);
+          }
+          break;
+        case 'core_hub_anapin':
+          this.anaCount_++;
+          var anaInput = this.appendValueInput('ANA' + this.anaCount_)
+              .setCheck(["HUB_DIG", "HUB_ANA"])
+              .appendField(Blockly.Msg.ARD_PIN_AN)
+              .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.analogPins), "PINA" + this.anaCount_)
+              .setAlign(Blockly.ALIGN_RIGHT);
+          if (! (oldInputs['ANA' + this.anaCount_] == undefined)) {
+            this.setFieldValue(oldInputs['ANA' + this.anaCount_], "PINA" + this.anaCount_);
+          }
+          if (clauseBlock.valueAConnection_) {
+            anaInput.connection.connect(clauseBlock.valueAConnection_);
+          }
+          break;
+        case 'core_hub_pwmpin':
+          this.pwmCount_++;
+          var pwmInput = this.appendValueInput('PWM' + this.pwmCount_)
+              .setCheck(["HUB_PWM"])
+              .appendField(Blockly.Msg.ARD_PIN_PWM)
+              .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.pwmPins), "PINP" + this.pwmCount_)
+              .setAlign(Blockly.ALIGN_RIGHT);
+          if (! (oldInputs['PWM' + this.pwmCount_] == undefined)) {
+            this.setFieldValue(oldInputs['PWM' + this.pwmCount_], "PINP" + this.pwmCount_);
+          }
+          if (clauseBlock.valuePConnection_) {
+            pwmInput.connection.connect(clauseBlock.valuePConnection_);
+          }
+          break;
+        case 'core_hub_digdigpin':
+          this.digdigCount_++;
+          var digInput = this.appendValueInput('DIGDIG' + this.digdigCount_)
+              .setCheck(["HUB_DIGDIG"])
+              .appendField(Blockly.Msg.ARD_PIN_DIGDIG1)
+              .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.digitalPins), "PINDD1_" + this.digdigCount_)
+              .appendField(Blockly.Msg.ARD_PIN_DIGDIG2)
+              .appendField(new Blockly.FieldDropdown(Blockly.Arduino.Boards.selected.digitalPins), "PINDD2_" + this.digdigCount_)
+              .setAlign(Blockly.ALIGN_RIGHT);
+          if (! (oldInputs['DIGDIG' + this.digdigCount_] == undefined)) {
+            this.setFieldValue(oldInputs['DIGDIG' + this.digdigCount_][0], "PINDD1_" + this.digdigCount_);
+            this.setFieldValue(oldInputs['DIGDIG' + this.digdigCount_][1], "PINDD2_" + this.digdigCount_);
+          }
+          if (clauseBlock.valueDDConnection_) {
+            digInput.connection.connect(clauseBlock.valueDDConnection_);
+          }
+          break;
+        default:
+          throw 'Unknown block type.';
+      }
+      clauseBlock = clauseBlock.nextConnection &&
+          clauseBlock.nextConnection.targetBlock();
+    }
+  },
+  /**
+   * Store pointers to any connected child blocks.
+   * @param {!Blockly.Block} containerBlock Root block in mutator.
+   * @this Blockly.Block
+   */
+  saveConnections: function(containerBlock) {
+    var clauseBlock = containerBlock.nextConnection.targetBlock();
+    var i = 1, j=1, k=1, ii=1;
+    while (clauseBlock) {
+      switch (clauseBlock.type) {
+        case 'core_hub_digpin':
+          var inputDig = this.getInput('DIG' + i);
+          clauseBlock.valueDConnection_ =
+              inputDig && inputDig.connection.targetConnection;
+          i++;
+          break;
+        case 'core_hub_anapin':
+          var inputAna = this.getInput('ANA' + j);
+          clauseBlock.valueAConnection_ =
+              inputAna && inputAna.connection.targetConnection;
+          j++;
+          break;
+        case 'core_hub_pwmpin':
+          var inputPwm = this.getInput('PWM' + k);
+          clauseBlock.valuePConnection_ =
+              inputPwm && inputPwm.connection.targetConnection;
+          k++;
+          break;
+        case 'core_hub_digdigpin':
+          var inputDigDig = this.getInput('DIGDIG' + ii);
+          clauseBlock.valueDDConnection_ =
+              inputDigDig && inputDigDig.connection.targetConnection;
+          ii++;
+          break;
+        default:
+          throw 'Unknown block type ' + clauseBlock.type ;
+      }
+      clauseBlock = clauseBlock.nextConnection &&
+          clauseBlock.nextConnection.targetBlock();
+    }
+  },
+  /**
+   * Updates the content of the the pin related fields.
+   * @this Blockly.Block
+   */
+  updateFields: function() {
+    for (var i = 1; i <= this.digCount_; i++) {
+      Blockly.Arduino.Boards.refreshBlockFieldDropdown(
+          this, 'PIND'+i, 'digitalPins');
+    }
+    for (var i = 1; i <= this.anaCount_; i++) {
+      Blockly.Arduino.Boards.refreshBlockFieldDropdown(
+          this, 'PINA'+i, 'analogPins');
+    }
+    for (var i = 1; i <= this.pwmCount_; i++) {
+      Blockly.Arduino.Boards.refreshBlockFieldDropdown(
+          this, 'PINP'+i, 'pwmPins');
+    }
+    for (var i = 1; i <= this.digdigCount_; i++) {
+      Blockly.Arduino.Boards.refreshBlockFieldDropdown(
+          this, 'PINDD1_'+i, 'digitalPins');
+      Blockly.Arduino.Boards.refreshBlockFieldDropdown(
+          this, 'PINDD2_'+i, 'digitalPins');
+    }
+  }
+};
+
+Blockly.Blocks['core_hub_hub'] = {
+  /**
+   * Mutator block for if container.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setColour(Blockly.Blocks.components.HUE);
+    this.appendDummyInput()
+        .appendField('Arduino Hub');
+    this.setNextStatement(true);
+    this.setTooltip(Blockly.Msg.ARD_COMPONENT_BOARD_HUB_TIP);
+    this.contextMenu = false;
+  }
+};
+
+Blockly.Blocks['core_hub_digpin'] = {
+  /**
+   * Mutator block for single digital pin connection.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setColour(Blockly.Blocks.components.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_PIN_DIG)
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.setTooltip(Blockly.Msg.ARD_PIN_DIG_TIP);
+    this.contextMenu = false;
+  }
+};
+
+Blockly.Blocks['core_hub_anapin'] = {
+  /**
+   * Mutator block for single analog pin connection.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setColour(Blockly.Blocks.components.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_PIN_AN);
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.setTooltip(Blockly.Msg.ARD_PIN_AN_TIP);
+    this.contextMenu = false;
+  }
+};
+
+Blockly.Blocks['core_hub_pwmpin'] = {
+  /**
+   * Mutator block for else condition.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setColour(Blockly.Blocks.components.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_PIN_PWM);
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.setTooltip(Blockly.Msg.ARD_PIN_PWM_TIP);
+    this.contextMenu = false;
+  }
+};
+
+Blockly.Blocks['core_hub_digdigpin'] = {
+  /**
+   * Mutator block for single digital pin connection.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setColour(Blockly.Blocks.components.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_PIN_DIGDIG)
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+    this.setTooltip(Blockly.Msg.ARD_PIN_DIGDIG_TIP);
+    this.contextMenu = false;
+  }
+};
diff --git a/blockly/blocks/arduino/io.js b/blockly/blocks/arduino/io.js
index bd144ba9ef..95c834b12e 100644
--- a/blockly/blocks/arduino/io.js
+++ b/blockly/blocks/arduino/io.js
@@ -241,3 +241,512 @@ Blockly.Blocks['io_pulsetimeout'] = {
     return Blockly.Types.NUMBER;
   }
 };
+
+
+/** Attach a generic analog sensor to the hub*/
+Blockly.Blocks['analogsensor_config_hub'] = {
+  init: function() {
+    this.appendDummyInput()
+        //.appendField(new Blockly.FieldImage("../media/arduino/Led.png", 19, 19, "*"))
+        .appendField(Blockly.Msg.ARD_ANASENSOR)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_ANASENSOR_DEFAULT_NAME, 'AnalogSensor'), 'SENSORNAME')
+    this.setOutput(true, 'HUB_ANA');
+    this.setColour(Blockly.Blocks.io.HUE);
+    this.setTooltip(Blockly.Msg.ARD_ANASENSOR_TIP);
+    this.setHelpUrl('http://arduino.cc/en/Reference/AnalogRead');
+  },
+  /**
+   * Set the connection pins that the component connects to
+   * @param {array} array of the connections (as string, eg '1', 'SDA', 'A1', ...
+   * @this Blockly.Block
+   */
+  setHubConnector: function(connector) {
+    this['connector'] = connector;
+  },
+  /**
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'AnalogSensor';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('SENSORNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('SENSORNAME'))) {
+      this.setFieldValue(newName, 'SENSORNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  }
+};
+
+Blockly.Blocks['analogsensor_read'] = {
+  /**
+   * Block for reading an analogue sensor input.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/AnalogRead');
+    this.setColour(Blockly.Blocks.io.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_ANASENSOR_READ)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_ANASENSOR_DEFAULT_NAME, 'AnalogSensor'), 'SENSORNAME')
+    this.setOutput(true, Blockly.Types.NUMBER.output);
+    this.setTooltip(Blockly.Msg.ARD_ANALOGREAD_TIP);
+  },
+  /** @return {!string} The type of return value for the block, an integer. */
+  getBlockType: function() {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('SENSORNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('SENSORNAME'))) {
+      this.setFieldValue(newName, 'SENSORNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of stepper_config and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('SENSORNAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'AnalogSensor')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_ANASENSOR_COMPONENT).replace('%1', Blockly.Msg.ARD_ANASENSOR_COMPONENT));
+    }
+  }
+};
+
+
+/** Attach a generic digital input to the hub*/
+Blockly.Blocks['digitalinput_config_hub'] = {
+  init: function() {
+    this.appendDummyInput()
+        //.appendField(new Blockly.FieldImage("../media/arduino/Led.png", 19, 19, "*"))
+        .appendField(Blockly.Msg.ARD_DIGINPUT)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_DIGINPUT_DEFAULT_NAME, 'DigitalInput'), 'SENSORNAME')
+    this.setOutput(true, 'HUB_DIG');
+    this.setColour(Blockly.Blocks.io.HUE);
+    this.setTooltip(Blockly.Msg.ARD_DIGINPUT_TIP);
+    this.setHelpUrl('http://arduino.cc/en/Reference/DigitalRead');
+  },
+  /**
+   * Set the connection pins that the component connects to
+   * @param {array} array of the connections (as string, eg '1', 'SDA', 'A1', ...
+   * @this Blockly.Block
+   */
+  setHubConnector: function(connector) {
+    this['connector'] = connector;
+  },
+  /**
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'DigitalInput';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('SENSORNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('SENSORNAME'))) {
+      this.setFieldValue(newName, 'SENSORNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  }
+};
+
+Blockly.Blocks['digitalinput_read'] = {
+  /**
+   * Block for reading an digital input.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/DigitalRead');
+    this.setColour(Blockly.Blocks.io.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_DIGINPUT_READ)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_DIGINPUT_DEFAULT_NAME, 'DigitalInput'), 'SENSORNAME')
+    this.setOutput(true, Blockly.Types.BOOLEAN.output);
+    this.setTooltip(Blockly.Msg.ARD_DIGINPUT_TIP);
+  },
+  /** @return {!string} The type of return value for the block, an integer. */
+  getBlockType: function() {
+    return Blockly.Types.BOOLEAN;
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('SENSORNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('SENSORNAME'))) {
+      this.setFieldValue(newName, 'SENSORNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of stepper_config and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('SENSORNAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'DigitalInput')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_DIGINPUT_COMPONENT).replace('%1', Blockly.Msg.ARD_DIGINPUT_COMPONENT));
+    }
+  }
+};
+
+
+/** Attach a generic digital output to the hub*/
+Blockly.Blocks['digitaloutput_config_hub'] = {
+  init: function() {
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_DIGOUTPUT)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_DIGOUTPUT_DEFAULT_NAME, 'DigitalOutput'), 'OUTPUTNAME')
+    this.setOutput(true, 'HUB_DIGOUT');
+    this.setColour(Blockly.Blocks.io.HUE);
+    this.setTooltip(Blockly.Msg.ARD_DIGOUTPUT_TIP);
+    this.setHelpUrl('http://arduino.cc/en/Reference/DigitalWrite');
+  },
+  /**
+   * Set the connection pins that the component connects to
+   * @param {array} array of the connections (as string, eg '1', 'SDA', 'A1', ...
+   * @this Blockly.Block
+   */
+  setHubConnector: function(connector) {
+    this['connector'] = connector;
+  },
+  /**
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'DigitalOutput';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('OUTPUTNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('OUTPUTNAME'))) {
+      this.setFieldValue(newName, 'OUTPUTNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  }
+};
+
+Blockly.Blocks['digitaloutput_write'] = {
+  /**
+   * Block for writing to digital output pin
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/DigitalWrite');
+    this.setColour(Blockly.Blocks.io.HUE);
+    this.appendValueInput('STATE')
+        .appendField(Blockly.Msg.ARD_DIGOUTPUT_WRITE)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_DIGOUTPUT_DEFAULT_NAME, 'DigitalOutput'), 'OUTPUTNAME')
+        .appendField(Blockly.Msg.ARD_OUTPUT_WRITE_TO)
+        .setCheck(Blockly.Types.BOOLEAN.checkList);
+    this.setInputsInline(false);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setTooltip(Blockly.Msg.ARD_DIGOUTPUT_TIP);
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('OUTPUTNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('OUTPUTNAME'))) {
+      this.setFieldValue(newName, 'OUTPUTNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of stepper_config and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('OUTPUTNAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'DigitalOutput')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_DIGOUTPUT_COMPONENT).replace('%1', Blockly.Msg.ARD_DIGOUTPUT_COMPONENT));
+    }
+  }
+};
+
+/** Attach a generic PWM output to the hub*/
+Blockly.Blocks['pwmoutput_config_hub'] = {
+  init: function() {
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_PWMOUTPUT)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_PWMOUTPUT_DEFAULT_NAME, 'PWMOutput'), 'OUTPUTNAME')
+    this.setOutput(true, 'HUB_PWM');
+    this.setColour(Blockly.Blocks.io.HUE);
+    this.setTooltip(Blockly.Msg.ARD_PWMOUTPUT_TIP);
+    this.setHelpUrl('http://arduino.cc/en/Reference/AnalogWrite');
+  },
+  /**
+   * Set the connection pins that the component connects to
+   * @param {array} array of the connections (as string, eg '1', 'SDA', 'A1', ...
+   * @this Blockly.Block
+   */
+  setHubConnector: function(connector) {
+    this['connector'] = connector;
+  },
+  /**
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'PWMOutput';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('OUTPUTNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('OUTPUTNAME'))) {
+      this.setFieldValue(newName, 'OUTPUTNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  }
+};
+
+Blockly.Blocks['pwmoutput_write'] = {
+  /**
+   * Block for writing to digital output pin
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/AnalogWrite');
+    this.setColour(Blockly.Blocks.io.HUE);
+    this.appendValueInput('NUM')
+        .appendField(Blockly.Msg.ARD_PWMOUTPUT_WRITE)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_PWMOUTPUT_DEFAULT_NAME, 'PWMOutput'), 'OUTPUTNAME')
+        .appendField(Blockly.Msg.ARD_OUTPUT_WRITE_TO)
+        .setCheck(Blockly.Types.NUMBER.output);
+    this.setInputsInline(false);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setTooltip(Blockly.Msg.ARD_PWMOUTPUT_TIP);
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('OUTPUTNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('OUTPUTNAME'))) {
+      this.setFieldValue(newName, 'OUTPUTNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of stepper_config and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('OUTPUTNAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'PWMOutput')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_PWMOUTPUT_COMPONENT).replace('%1', Blockly.Msg.ARD_PWMOUTPUT_COMPONENT));
+    }
+  }
+};
diff --git a/blockly/blocks/arduino/light.js b/blockly/blocks/arduino/light.js
new file mode 100644
index 0000000000..8a0e20f2a2
--- /dev/null
+++ b/blockly/blocks/arduino/light.js
@@ -0,0 +1,544 @@
+/**
+ * @license Licensed under the Apache License, Version 2.0 (the "License"):
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @fileoverview Block for the Microduino functions.
+ *     The Arduino built in functions syntax can be found at:
+ *     https://arduino.cc/en/Reference/HomePage
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.light');
+
+goog.require('Blockly.Blocks');
+
+
+/** Common HSV hue for all blocks in this category. */
+Blockly.Blocks.light.HUE = 512;
+
+
+/** Attach a LED block to the hub*/
+Blockly.Blocks['led_config_hub'] = {
+  init: function() {
+    this.appendDummyInput()
+        .appendField(new Blockly.FieldImage("../media/arduino/Led.png", 19, 19, "*"))
+        .appendField(Blockly.Msg.ARD_LEDLEG)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_LEDLEG_DEFAULT_NAME, 'LedLeg'), 'LEDNAME')
+        .appendField(Blockly.Msg.ARD_LEDLEGPOL)
+        .appendField(
+            new Blockly.FieldDropdown(
+                [[Blockly.Msg.ARD_LEDLEGPOS, 'pos'],
+                 [Blockly.Msg.ARD_LEDLEGNEG, 'neg']
+                ]), 'POLARITY');
+    this.setOutput(true, 'HUB_DIGOUT');
+    this.setColour(Blockly.Blocks.light.HUE);
+    this.setTooltip(Blockly.Msg.ARD_LEDLEG_TIP);
+    this.setHelpUrl('https://www.arduino.cc/en/tutorial/blink');
+  },
+  /**
+   * Set the connection pins that the component connects to
+   * @param {array} array of the connections (as string, eg '1', 'SDA', 'A1', ...
+   * @this Blockly.Block
+   */
+  setHubConnector: function(connector) {
+    this['connector'] = connector;
+  },
+  /**
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'LedLeg';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('LEDNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('LEDNAME'))) {
+      this.setFieldValue(newName, 'LEDNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  }
+};
+
+/** Attach a LED block to the hub*/
+Blockly.Blocks['neopixel_config_hub'] = {
+  init: function() {
+    this.appendValueInput('NUMBER')
+        .appendField(new Blockly.FieldImage("../media/arduino/Led.png", 19, 19, "*"))
+        .appendField(Blockly.Msg.ARD_NEOPIXEL)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_NEOPIXEL_DEFAULT_NAME, 'LedStrip'), 'LEDNAME')
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_STRIP);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_PIXELS)
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_HZ)
+        .appendField(
+            new Blockly.FieldDropdown(
+                [['800 KHz', 'NEO_KHZ800'],
+                 ['400 KHz', 'NEO_KHZ400']
+                ]), 'KHZ')
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_TYPE)
+        .appendField(
+            new Blockly.FieldDropdown(
+                [['GRB', 'NEO_GRB'],
+                 ['RGB', 'NEO_RGB'],
+                 ['GRB+White', 'NEO_GRBW'],
+                 ['RGB+White', 'NEO_RGBW']
+                ]), 'NEOPIXEL_TYPE');
+    this.setOutput(true, 'HUB_DIGOUT');
+    this.setColour(Blockly.Blocks.light.HUE);
+    this.setTooltip(Blockly.Msg.ARD_NEOPIXEL_TIP);
+    this.setHelpUrl('https://learn.adafruit.com/adafruit-neopixel-uberguide/neopixel-strips');
+  },
+  /**
+   * Set the connection pins that the component connects to
+   * @param {array} array of the connections (as string, eg '1', 'SDA', 'A1', ...
+   * @this Blockly.Block
+   */
+  setHubConnector: function(connector) {
+    this['connector'] = connector;
+  },
+  /**
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'LedStrip';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('LEDNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('LEDNAME'))) {
+      this.setFieldValue(newName, 'LEDNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  }
+};
+
+
+Blockly.Blocks['led_digitalwrite'] = {
+  /**
+   * Block for creating a 'set pin' to a state.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/DigitalWrite');
+    this.setColour(Blockly.Blocks.light.HUE);
+    this.appendValueInput('STATE')
+        .appendField(Blockly.Msg.ARD_LEDLEG_SET)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_LEDLEG_DEFAULT_NAME, 'LedLeg'), 'LEDNAME')
+        .setCheck(Blockly.Types.BOOLEAN.checkList);
+    this.setInputsInline(false);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setTooltip(Blockly.Msg.ARD_DIGITALWRITE_TIP);
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('LEDNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('LEDNAME'))) {
+      this.setFieldValue(newName, 'LEDNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of stepper_config and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('LEDNAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'LedLeg')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_LEDLEG_COMPONENT).replace('%1', Blockly.Msg.ARD_LEDLEG_COMPONENT));
+    }
+  }
+};
+
+Blockly.Blocks['led_digitalwrite_onoff'] = {
+  /**
+   * Block for setting led to on or off.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/DigitalWrite');
+    this.setColour(Blockly.Blocks.light.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_LEDLEG_SET)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_LEDLEG_DEFAULT_NAME, 'LedLeg'), 'LEDNAME')
+        .appendField(
+            new Blockly.FieldDropdown(
+                [[Blockly.Msg.ARD_LEDLEG_ON, 'on'],
+                 [Blockly.Msg.ARD_LEDLEG_OFF, 'off']
+                ]), 'STATE');
+    this.setInputsInline(false);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setTooltip(Blockly.Msg.ARD_DIGITALWRITE_TIP);
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('LEDNAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('LEDNAME'))) {
+      this.setFieldValue(newName, 'LEDNAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of stepper_config and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('LEDNAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'LedLeg')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_LEDLEG_COMPONENT).replace('%1', Blockly.Msg.ARD_LEDLEG_COMPONENT));
+    }
+  }
+};
+
+/**
+ * The neopixel set block with dropdown of color to show
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Blocks['neopixel_colourpick_write'] = {
+  init: function() {
+    this.setColour(Blockly.Blocks.light.HUE);
+    this.appendDummyInput("")
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_SET)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_NEOPIXEL_DEFAULT_NAME, 'LedStrip'), 'NEONAME')
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_PIXEL)
+    
+    this.appendValueInput("LEDPIXEL")
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .setAlign(Blockly.ALIGN_RIGHT)
+    
+    var colour = new Blockly.FieldColour('#ff0000');
+    colour.setColours(['rgb(255,0,0)', 'rgb(0,255,0)', 'rgb(0,0,255)', 'rgb(255,255,0)', 'rgb(255,0,179)', 'rgb(255,102,0)', 'rgb(210,0,255)', 'rgb(255,255,255)', 'rgb(0,0,0)']).setColumns(3);
+    
+    this.appendDummyInput("")
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_ONCOLOUR)
+        .appendField(colour, 'COLOUR');
+
+    this.setInputsInline(true);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setTooltip(Blockly.Msg.ARD_DIGITALWRITE_TIP);
+    this.setHelpUrl('http://arduino.cc/en/Reference/DigitalWrite');
+    },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('NEONAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('NEONAME'))) {
+      this.setFieldValue(newName, 'NEONAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of stepper_config and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('NEONAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'LedStrip')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_NEOPIXEL_COMPONENT).replace('%1', Blockly.Msg.ARD_NEOPIXEL_COMPONENT));
+    }
+  }
+};
+
+/**
+ * The neopixel set block with dropdown of color to show and dim value
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Blocks['neopixel_colourpick_dim_write'] = {
+  init: function() {
+    this.setColour(Blockly.Blocks.light.HUE);
+    this.appendDummyInput("")
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_SET)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_NEOPIXEL_DEFAULT_NAME, 'LedStrip'), 'NEONAME')
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_PIXEL)
+    
+    this.appendValueInput("LEDPIXEL")
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .setAlign(Blockly.ALIGN_RIGHT)
+    
+    var colour = new Blockly.FieldColour('#ff0000');
+    colour.setColours(['rgb(255,0,0)', 'rgb(0,255,0)', 'rgb(0,0,255)', 'rgb(255,255,0)', 'rgb(255,0,179)', 'rgb(255,102,0)', 'rgb(210,0,255)', 'rgb(255,255,255)', 'rgb(0,0,0)']).setColumns(3);
+    
+    this.appendDummyInput("")
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_ONCOLOUR)
+        .appendField(colour, 'COLOUR');
+    this.appendValueInput("BRIGHTNESS")
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_BRIGHTNESS)
+
+    this.setInputsInline(true);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setTooltip(Blockly.Msg.ARD_DIGITALWRITE_TIP);
+    this.setHelpUrl('http://arduino.cc/en/Reference/DigitalWrite');
+    },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('NEONAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('NEONAME'))) {
+      this.setFieldValue(newName, 'NEONAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of stepper_config and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('NEONAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'LedStrip')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_NEOPIXEL_COMPONENT).replace('%1', Blockly.Msg.ARD_NEOPIXEL_COMPONENT));
+    }
+  }
+};
+
+/**
+ * The neopixel set block with full control
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Blocks['neopixel_write'] = {
+  init: function() {
+    this.setColour(Blockly.Blocks.light.HUE);
+    this.appendDummyInput("")
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_SET)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_NEOPIXEL_DEFAULT_NAME, 'LedStrip'), 'NEONAME')
+        .appendField('pixel')
+    this.appendValueInput("LEDPIXEL")
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .setAlign(Blockly.ALIGN_RIGHT)
+    this.appendValueInput("RED")
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_ONCOLOURVALRED);
+    this.appendValueInput("GREEN")
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_ONCOLOURVALGREEN);
+    this.appendValueInput("BLUE")
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField(Blockly.Msg.ARD_NEOPIXEL_ONCOLOURVALBLUE);
+
+    this.setInputsInline(true);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setTooltip(Blockly.Msg.ARD_DIGITALWRITE_TIP);
+    this.setHelpUrl('http://arduino.cc/en/Reference/DigitalWrite');
+    },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('NEONAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('NEONAME'))) {
+      this.setFieldValue(newName, 'NEONAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of stepper_config and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('NEONAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'LedStrip')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_NEOPIXEL_COMPONENT).replace('%1', Blockly.Msg.ARD_NEOPIXEL_COMPONENT));
+    }
+  }
+};
diff --git a/blockly/blocks/arduino/servo.js b/blockly/blocks/arduino/servo.js
index fce8fb074e..8daf8e7f94 100644
--- a/blockly/blocks/arduino/servo.js
+++ b/blockly/blocks/arduino/servo.js
@@ -82,3 +82,282 @@ Blockly.Blocks['servo_read'] = {
         this, 'SERVO_PIN', 'pwmPins');
   }
 };
+
+Blockly.Blocks['servo_config_hub'] = {
+  /**
+   * Block for adding a servo to a hub.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.appendDummyInput()
+        .appendField(new Blockly.FieldImage("../media/arduino/Servo.png", 19, 19, "*"))
+        .appendField(Blockly.Msg.ARD_SERVOHUB)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_SERVO_DEFAULT_NAME, 'Servo'), 'NAMESERVO')
+        .appendField(Blockly.Msg.ARD_SERVO_TYPE)
+        .appendField(
+            new Blockly.FieldDropdown([ 
+                                       [Blockly.Msg.ARD_180SERVO, '180SERVO'],
+                                       [Blockly.Msg.ARD_360SERVO, '360SERVO']
+                                      ]),
+           'SERVOTYPE');
+    this.setOutput(true, "HUB_PWM");
+    this.setColour(Blockly.Blocks.servo.HUE);
+    this.setTooltip(Blockly.Msg.ARD_SERVOHUB_TIP);
+    this.setHelpUrl('https://wiki.microduino.cc/index.php/Servo');
+  },
+  /**
+   * Set the connection pins that the component connects to
+   * @param {array} array of the connections (as string, eg '1', 'SDA', 'A1', ...
+   * @this Blockly.Block
+   */
+  setHubConnector: function(connector) {
+    this['connector'] = connector;
+  },
+  /**
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'Servo';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('NAMESERVO')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('NAMESERVO'))) {
+      this.setFieldValue(newName, 'NAMESERVO');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  }
+};
+
+Blockly.Blocks['servohub_write'] = {
+  /**
+   * Block for writing an angle value into a servo PWM pin.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/ServoWrite');
+    this.setColour(Blockly.Blocks.servo.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_SERVOHUB_WRITE)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_SERVO_DEFAULT_NAME, 'Servo'), 'SERVO_NAME');
+    this.setInputsInline(false);
+    this.appendValueInput('SERVO_ANGLE')
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .appendField(Blockly.Msg.ARD_SERVO_WRITE_TO);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_SERVO_WRITE_DEG_180);
+    this.setInputsInline(true);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setTooltip(Blockly.Msg.ARD_SERVO_WRITE_TIP);
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('SERVO_NAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('SERVO_NAME'))) {
+      this.setFieldValue(newName, 'SERVO_NAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of servos and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('SERVO_NAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'Servo')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_SERVO_COMPONENT).replace('%1', Blockly.Msg.ARD_SERVO_COMPONENT));
+    }
+  }
+};
+
+Blockly.Blocks['servohub_read'] = {
+  /**
+   * Block for reading an angle value of a servo PWM pin.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/ServoRead');
+    this.setColour(Blockly.Blocks.servo.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_SERVOHUB_READ)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_SERVO_DEFAULT_NAME, 'Servo'), 'SERVO_NAME');
+    this.setOutput(true, Blockly.Types.NUMBER.output);
+    this.setTooltip(Blockly.Msg.ARD_SERVO_READ_TIP);
+  },
+  /** @return {string} The type of return value for the block, an integer. */
+  getBlockType: function() {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('SERVO_NAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('SERVO_NAME'))) {
+      this.setFieldValue(newName, 'SERVO_NAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of servos and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('SERVO_NAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'Servo')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_SERVO_COMPONENT).replace('%1', Blockly.Msg.ARD_SERVO_COMPONENT));
+    }
+  }
+};
+
+
+Blockly.Blocks['servohub_write2'] = {
+  /**
+   * Block for writing an angle value into a servo PWM pin.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/ServoWrite');
+    this.setColour(Blockly.Blocks.servo.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_SERVO_ROTATE360)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_SERVO_DEFAULT_NAME, 'Servo'), 'SERVO_NAME');
+    this.appendValueInput('SERVO_SPEED')
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .appendField(Blockly.Msg.ARD_SERVO_ROTATESPEED);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_SERVO_ROTATEPERC);
+    this.setInputsInline(true);
+    this.setPreviousStatement(true, 'ARD_BLOCK');
+    this.setNextStatement(true, 'ARD_BLOCK');
+    this.setTooltip(Blockly.Msg.ARD_SERVO_ROTATE_TIP);
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('SERVO_NAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('SERVO_NAME'))) {
+      this.setFieldValue(newName, 'SERVO_NAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.NUMBER;
+  },
+  /**
+   * Called whenever anything on the workspace changes.
+   * It checks the instances of servos and attaches a warning to this
+   * block if not valid data is found.
+   * @this Blockly.Block
+   */
+  onchange: function() {
+    if (!this.workspace) { return; }  // Block has been deleted.
+
+    var currentDropdown = this.getFieldValue('SERVO_NAME');
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'Servo')) {
+      this.setWarningText(null);
+    } else {
+      // Set a warning to select a valid config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_SERVO_COMPONENT).replace('%1', Blockly.Msg.ARD_SERVO_COMPONENT));
+    }
+  }
+};
diff --git a/blockly/blocks/arduino/stepper.js b/blockly/blocks/arduino/stepper.js
index b7248689c1..c690d43b36 100644
--- a/blockly/blocks/arduino/stepper.js
+++ b/blockly/blocks/arduino/stepper.js
@@ -28,64 +28,6 @@ goog.require('Blockly.Types');
 /** Common HSV hue for all blocks in this category. */
 Blockly.Blocks.stepper.HUE = 80;
 
-/** Strings for easy reference. */
-Blockly.Blocks.stepper.noInstance = 'No_Instances';
-Blockly.Blocks.stepper.noName = 'Empty_input_name';
-
-/**
- * Finds all user-created instances of the Stepper block config.
- * @return {!Array.<string>} Array of instance names.
- */
-Blockly.Blocks.stepper.stepperInstances = function() {
-  var stepperList = [];
-  var blocks = Blockly.mainWorkspace.getTopBlocks();
-  for (var x = 0; x < blocks.length; x++) {
-    var getStepperSetupInstance = blocks[x].getStepperSetupInstance;
-    if (getStepperSetupInstance) {
-      var stepperInstance = getStepperSetupInstance.call(blocks[x]);
-        if (stepperInstance) {
-          stepperList.push(stepperInstance);
-        }
-    }
-  }
-  return stepperList;
-};
-
-/**
- * Return a sorted list of instances names for set dropdown menu.
- * @return {!Array.<string>} Array of stepper instances names.
- */
-Blockly.Blocks.stepper.stepperDropdownList = function() {
-  var stepperList = Blockly.Blocks.stepper.stepperInstances();
-  var options = [];
-  if (stepperList.length > 0) {
-    stepperList.sort(goog.string.caseInsensitiveCompare);
-    // Variables are not language-specific, use the name as both the
-    // user-facing text and the internal representation.
-    for (var x = 0; x < stepperList.length; x++) {
-      options[x] = [stepperList[x], stepperList[x]];
-    }
-  } else {
-    // There are no config blocks in the work area
-    options[0] = [Blockly.Blocks.stepper.noInstance,
-                  Blockly.Blocks.stepper.noInstance];
-  }
-  return options;
-};
-
-/**
- * Class for a variable's dropdown field.
- * @extends {Blockly.FieldDropdown}
- * @constructor
- */
-Blockly.Blocks.stepper.FieldStepperInstance = function() {
-  Blockly.Blocks.stepper.FieldStepperInstance.superClass_.constructor
-      .call(this, Blockly.Blocks.stepper.stepperDropdownList);
-};
-goog.inherits(
-    Blockly.Blocks.stepper.FieldStepperInstance, Blockly.FieldDropdown);
-
-
 Blockly.Blocks['stepper_config'] = {
   /**
    * Block for for the stepper generator configuration including creating
@@ -97,7 +39,8 @@ Blockly.Blocks['stepper_config'] = {
     this.setColour(Blockly.Blocks.stepper.HUE);
     this.appendDummyInput()
         .appendField(Blockly.Msg.ARD_STEPPER_SETUP)
-        .appendField(new Blockly.FieldTextInput('MyStepper'), 'STEPPER_NAME')
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_STEPPER_DEFAULT_NAME, 'Stepper'), 'STEPPER_NAME')
         .appendField(Blockly.Msg.ARD_STEPPER_MOTOR);
     this.appendDummyInput()
         .setAlign(Blockly.ALIGN_RIGHT)
@@ -118,18 +61,41 @@ Blockly.Blocks['stepper_config'] = {
     this.setTooltip(Blockly.Msg.ARD_STEPPER_SETUP_TIP);
   },
   /**
-   * Returns the stepper instance name, defined in the 'STEPPER_NAME' input
-   * String block attached to this block.
-   * @return {!string} List with the instance name.
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'Stepper';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
    * @this Blockly.Block
    */
-  getStepperSetupInstance: function() {
-    var InstanceName = this.getFieldValue('STEPPER_NAME');
-    if (!InstanceName) {
-      InstanceName = Blockly.Blocks.stepper.noName;
+  getVars: function() {
+    return [this.getFieldValue('STEPPER_NAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('STEPPER_NAME'))) {
+      this.setFieldValue(newName, 'STEPPER_NAME');
     }
-    // Replace all spaces with underscores
-    return InstanceName.replace(/ /g, '_');
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.ARRAY;
   },
   /**
    * Updates the content of the the pin related fields.
@@ -143,6 +109,78 @@ Blockly.Blocks['stepper_config'] = {
   }
 };
 
+Blockly.Blocks['stepper_config_hub'] = {
+  /**
+   * Block for for the stepper generator configuration including creating
+   * an object instance and setting up the speed. Info in the setHelpUrl link.
+   * @this Blockly.Block
+   */
+  init: function() {
+    this.setHelpUrl('http://arduino.cc/en/Reference/StepperConstructor');
+    this.setColour(Blockly.Blocks.stepper.HUE);
+    this.appendDummyInput()
+        .appendField(Blockly.Msg.ARD_STEPPER_SETUP)
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_STEPPER_DEFAULT_NAME, 'Stepper'), 'STEPPER_NAME')
+        .appendField(Blockly.Msg.ARD_STEPPER_MOTOR);
+    this.appendValueInput('STEPPER_STEPS')
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField(Blockly.Msg.ARD_STEPPER_REVOLVS);
+    this.appendValueInput('STEPPER_SPEED')
+        .setCheck(Blockly.Types.NUMBER.checkList)
+        .setAlign(Blockly.ALIGN_RIGHT)
+        .appendField(Blockly.Msg.ARD_STEPPER_SPEED);
+    this.setTooltip(Blockly.Msg.ARD_STEPPER_SETUP_TIP);
+    this.setOutput(true, "HUB_DIGDIG");
+  },
+  /**
+   * Set the connection pins that the component connects to
+   * @param {array} array of the connections (as string, eg '1', 'SDA', 'A1', ...
+   * @this Blockly.Block
+   */
+  setHubConnector: function(connector) {
+    this['connector'] = connector;
+  },
+  /**
+   * Return the name of the component defined in this block
+   * @return {!<string>} The name of the component
+   * @this Blockly.Block
+   */
+  getComponentName: function() {
+    return 'Stepper';
+  },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('STEPPER_NAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('STEPPER_NAME'))) {
+      this.setFieldValue(newName, 'STEPPER_NAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.ARRAY;
+  }
+};
+
 Blockly.Blocks['stepper_step'] = {
   /**
    * Block for for the stepper 'step()' function.
@@ -153,8 +191,8 @@ Blockly.Blocks['stepper_step'] = {
     this.setColour(Blockly.Blocks.stepper.HUE);
     this.appendDummyInput()
         .appendField(Blockly.Msg.ARD_STEPPER_STEP)
-        .appendField(new Blockly.Blocks.stepper.FieldStepperInstance(),
-            'STEPPER_NAME');
+        .appendField(new Blockly.Blocks.ComponentFieldVariable(
+        Blockly.Msg.ARD_STEPPER_DEFAULT_NAME, 'Stepper'), 'STEPPER_NAME')
     this.appendValueInput('STEPPER_STEPS')
         .setCheck(Blockly.Types.NUMBER.checkList);
     this.appendDummyInput()
@@ -163,6 +201,35 @@ Blockly.Blocks['stepper_step'] = {
     this.setNextStatement(true);
     this.setTooltip(Blockly.Msg.ARD_STEPPER_STEP_TIP);
   },
+  /**
+   * Return all variables referenced by this block.
+   * @return {!Array.<string>} List of variable names.
+   * @this Blockly.Block
+   */
+  getVars: function() {
+    return [this.getFieldValue('STEPPER_NAME')];
+  },
+  /**
+   * Notification that a variable is renaming.
+   * If the name matches one of this block's variables, rename it.
+   * @param {string} oldName Previous name of variable.
+   * @param {string} newName Renamed variable.
+   * @this Blockly.Block
+   */
+  renameVar: function(oldName, newName) {
+    if (Blockly.Names.equals(oldName, this.getFieldValue('STEPPER_NAME'))) {
+      this.setFieldValue(newName, 'STEPPER_NAME');
+    }
+  },
+  /**
+   * Gets the variable type required.
+   * @param {!string} varName Name of the variable selected in this block to
+   *     check.
+   * @return {string} String to indicate the variable type.
+   */
+  getVarType: function(varName) {
+    return Blockly.Types.ARRAY;
+  },
   /**
    * Called whenever anything on the workspace changes.
    * It checks the instances of stepper_config and attaches a warning to this
@@ -173,46 +240,11 @@ Blockly.Blocks['stepper_step'] = {
     if (!this.workspace) { return; }  // Block has been deleted.
 
     var currentDropdown = this.getFieldValue('STEPPER_NAME');
-    var instances = Blockly.Blocks.stepper.stepperDropdownList();
-
-    // Check for configuration block presence
-    if (instances[0][0] === Blockly.Blocks.stepper.noInstance) {
-      // Ensure dropdown menu says there is no config block
-      if (currentDropdown !== Blockly.Blocks.stepper.noInstance) {
-        this.setFieldValue(Blockly.Blocks.stepper.noInstance, 'STEPPER_NAME');
-      }
-      this.setWarningText(Blockly.Msg.ARD_STEPPER_STEP_WARN1);
+    if (Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent(this.workspace, currentDropdown, 'Stepper')) {
+      this.setWarningText(null);
     } else {
-      // Configuration blocks present, check if any selected and contains name
-      var existingConfigSelected = false;
-      for (var x = 0; x < instances.length; x++) {
-        // Check if any of the config blocks does not have a name
-        if (instances[x][0] === Blockly.Blocks.stepper.noName) {
-          // If selected config has no name either, set warning and exit func
-          if (currentDropdown === Blockly.Blocks.stepper.noName) {
-            this.setWarningText(Blockly.Msg.ARD_STEPPER_STEP_WARN2);
-            return;
-          }
-        } else if (instances[x][0] === currentDropdown) {
-          existingConfigSelected = true;
-        }
-      }
-
-      // At this point select config has a name, check if it exist
-      if (existingConfigSelected) {
-        // All good, just remove any warnings and exit the function
-        this.setWarningText(null);
-      } else {
-        if ((currentDropdown === Blockly.Blocks.stepper.noName) ||
-            (currentDropdown === Blockly.Blocks.stepper.noInstance)) {
-          // Just pick the first config block
-          this.setFieldValue(instances[0][0], 'STEPPER_NAME');
-          this.setWarningText(null);
-        } else {
-          // Al this point just set a warning to select a valid stepper config
-          this.setWarningText(Blockly.Msg.ARD_STEPPER_STEP_WARN3);
-        }
-      }
+      // Set a warning to select a valid stepper config
+      this.setWarningText(Blockly.Msg.ARD_COMPONENT_WARN1.replace('%1', Blockly.Msg.ARD_STEPPER_COMPONENT).replace('%1', Blockly.Msg.ARD_STEPPER_COMPONENT));
     }
   }
 };
diff --git a/blockly/blocks/component_variable.js b/blockly/blocks/component_variable.js
new file mode 100644
index 0000000000..3d5560a1b3
--- /dev/null
+++ b/blockly/blocks/component_variable.js
@@ -0,0 +1,166 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2012 Google Inc.
+ * https://developers.google.com/blockly/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Variable input field of a specific component type.
+ * @author fraser@google.com (Neil Fraser)
+ */
+'use strict';
+
+goog.provide('Blockly.Blocks.ComponentFieldVariable');
+
+goog.require('Blockly.Blocks');
+
+
+/**
+ * Class for a variable's dropdown field.
+ * @param {?string} varname The default name for the variable.  If null,
+ *     a unique variable name will be generated.
+ * @param {?string} component_type The type of component to show in the dropdown list, eg 'Stepper'
+ * @param {Function=} opt_validator A function that is executed when a new
+ *     option is selected.  Its sole argument is the new option value.
+ * @extends {Blockly.FieldVariable}
+ * @constructor
+ */
+Blockly.Blocks.ComponentFieldVariable = function(varname, component_type, opt_validator) {
+  /** @type {string} */
+  this.component_type = component_type;
+  Blockly.Blocks.ComponentFieldVariable.superClass_.constructor.call(this,
+      varname, opt_validator);
+  this.setValue(varname || '');
+};
+goog.inherits(Blockly.Blocks.ComponentFieldVariable, Blockly.FieldVariable);
+
+Blockly.Blocks.ComponentFieldVariable.ComponentVariables = function(root, component_type) {
+  var blocks;
+  if (root.getDescendants) {
+    // Root is Block.
+    blocks = root.getDescendants();
+  } else if (root.getAllBlocks) {
+    // Root is Workspace.
+    blocks = root.getAllBlocks();
+  } else {
+    throw 'Not Block or Workspace: ' + root;
+  }
+  var variableHash = Object.create(null);
+  // Iterate through every block and add each variable to the hash.
+  for (var x = 0; x < blocks.length; x++) {
+    if (blocks[x].getComponentName && blocks[x].getVars && 
+        (blocks[x].getComponentName() ==  component_type)) {
+      var blockVariables = blocks[x].getVars();
+      for (var y = 0; y < blockVariables.length; y++) {
+        var varName = blockVariables[y];
+        // Variable name may be null if the block is only half-built.
+        if (varName) {
+          variableHash[varName.toLowerCase()] = varName;
+        }
+      }
+    }
+  }
+  // Flatten the hash into a list.
+  var variableList = [];
+  for (var name in variableHash) {
+    variableList.push(variableHash[name]);
+  }
+  return variableList;
+};
+
+
+/**
+ * Return a sorted list of variable names for variable dropdown menus.
+ * Include a special option at the end for creating a new variable name.
+ * @return {!Array.<string>} Array of variable names.
+ * @this {!ComponentFieldVariable}
+ */
+Blockly.Blocks.ComponentFieldVariable.prototype.dropdownCreate = function() {
+  if (this.sourceBlock_ && this.sourceBlock_.workspace) {
+    var variableList =
+        Blockly.Blocks.ComponentFieldVariable.ComponentVariables(this.sourceBlock_.workspace, 
+                this.component_type);
+  } else {
+    var variableList = [];
+  }
+  // Ensure that the currently selected variable is an option.
+  var name = this.getText();
+  if (name && variableList.indexOf(name) == -1) {
+    variableList.push(name);
+  }
+  variableList.sort(goog.string.caseInsensitiveCompare);
+  variableList.push(Blockly.Msg.RENAME_VARIABLE);
+  variableList.push(Blockly.Msg.NEW_VARIABLE);
+  // Variables are not language-specific, use the name as both the user-facing
+  // text and the internal representation.
+  var options = [];
+  for (var x = 0; x < variableList.length; x++) {
+    options[x] = [variableList[x], variableList[x]];
+  }
+  return options;
+};
+
+
+/**
+ * Finds all user-created instances of the ComponentFieldVariable block config.
+ * @param {!Blockly.Workspace} workspace The block's workspace.
+ * @param {?string} component_type The type of component setup block to obtain instances from
+ * @return {!Array.<string>} Array of instance names.
+ */
+Blockly.Blocks.ComponentFieldVariable.Instances = function(workspace, component_type) {
+  var instList = [];
+  var blocks = Blockly.mainWorkspace.getAllBlocks();
+  for (var x = 0; x < blocks.length; x++) {
+    var getSetupInstance = blocks[x].getComponentName;
+    if (getSetupInstance) {
+      var Instances = getSetupInstance.call();
+      if (Instances) {
+        if (Instances == component_type) {
+          instList.push(blocks[x].getVars()[0]);
+        }
+      }
+    }
+  }
+  return instList;
+};
+
+/**
+ * Check to know of a setup block (which sets pin number) is present for a used
+ * ComponentFieldVariable.
+ * @param {!Blockly.Workspace} workspace The block's workspace.
+ * @param {?string} currentDropdown The selected name in the dropdown for which to check
+ *              if setup block present
+ * @param {?string} component_type The type of component setup block must be checked
+ * @return {<boolean>} Wether setup block is present or not
+ */
+Blockly.Blocks.ComponentFieldVariable.CheckSetupPresent = function(workspace, currentDropdown, component_type) {
+  var instances = Blockly.Blocks.ComponentFieldVariable.Instances(workspace, component_type);
+
+  // Check for configuration block presence
+  if (! instances) {
+    return false;
+  } else {
+    // Configuration blocks present, check if any selected in this block
+    var existingConfigSelected = false;
+    for (var x = 0; x < instances.length; x++) {
+      if (instances[x] === currentDropdown) {
+        existingConfigSelected = true;
+      }
+    }
+    return existingConfigSelected;
+  }
+}
diff --git a/blockly/core/field_variable.js b/blockly/core/field_variable.js
index 6cd627abf2..451832253b 100644
--- a/blockly/core/field_variable.js
+++ b/blockly/core/field_variable.js
@@ -44,7 +44,7 @@ goog.require('goog.string');
  */
 Blockly.FieldVariable = function(varname, opt_validator) {
   Blockly.FieldVariable.superClass_.constructor.call(this,
-      Blockly.FieldVariable.dropdownCreate, opt_validator);
+      this.dropdownCreate, opt_validator);
   this.setValue(varname || '');
 };
 goog.inherits(Blockly.FieldVariable, Blockly.FieldDropdown);
@@ -124,7 +124,7 @@ Blockly.FieldVariable.prototype.setValue = function(newValue) {
  * @return {!Array.<string>} Array of variable names.
  * @this {!Blockly.FieldVariable}
  */
-Blockly.FieldVariable.dropdownCreate = function() {
+Blockly.FieldVariable.prototype.dropdownCreate = function() {
   if (this.sourceBlock_ && this.sourceBlock_.workspace) {
     var variableList =
         Blockly.Variables.allVariables(this.sourceBlock_.workspace);
diff --git a/blockly/generators/arduino/boards.js b/blockly/generators/arduino/boards.js
index 950bca0dbc..17db07d322 100644
--- a/blockly/generators/arduino/boards.js
+++ b/blockly/generators/arduino/boards.js
@@ -168,6 +168,7 @@ Blockly.Arduino.Boards.profiles.yun = Blockly.Arduino.Boards.profiles.leonardo;
 
 /** Set default profile to Arduino standard-compatible board */
 Blockly.Arduino.Boards.selected = Blockly.Arduino.Boards.profiles.uno;
+Blockly.Arduino.Boards.selected.profilename_ = 'uno';
 
 /**
  * Changes the Arduino board profile selected, which trigger a refresh of the
@@ -180,13 +181,16 @@ Blockly.Arduino.Boards.changeBoard = function(workspace, newBoard) {
     console.log('Tried to set non-existing Arduino board: ' + newBoard);
     return;
   }
-  Blockly.Arduino.Boards.selected = Blockly.Arduino.Boards.profiles[newBoard];
-  // Update the pin out of all the blocks that uses them
-  var blocks = workspace.getAllBlocks();
-  for (var i = 0; i < blocks.length; i++) {
-    var updateFields = blocks[i].updateFields;
-    if (updateFields) {
-      updateFields.call(blocks[i]);
+  if (Blockly.Arduino.Boards.selected.profilename_ != newBoard) {
+    Blockly.Arduino.Boards.selected = Blockly.Arduino.Boards.profiles[newBoard];
+    Blockly.Arduino.Boards.selected.profilename_ = newBoard;
+    // Update the pin out of all the blocks that uses them
+    var blocks = workspace.getAllBlocks();
+    for (var i = 0; i < blocks.length; i++) {
+      var updateFields = blocks[i].updateFields;
+      if (updateFields) {
+        updateFields.call(blocks[i]);
+      }
     }
   }
 };
diff --git a/blockly/generators/arduino/button.js b/blockly/generators/arduino/button.js
new file mode 100644
index 0000000000..f534c047f3
--- /dev/null
+++ b/blockly/generators/arduino/button.js
@@ -0,0 +1,129 @@
+/**
+ * @license Licensed under the Apache License, Version 2.0 (the "License"):
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @fileoverview Generating Microduino code for procedure (function) blocks.
+ *
+ */
+'use strict';
+
+goog.provide('Blockly.Arduino.button');
+
+goog.require('Blockly.Arduino');
+
+/**
+ * The button setup block
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['button_setup'] = function(block) {
+  var btnName = block.getFieldValue('BUTTONNAME');
+  var stateOutput = block.getFieldValue('STATE');
+  
+  //the hub saved the connector in the attached block
+  var hubconnector = block['connector'] || ['0', '1']
+  //compute the pins, normally only possible to attach at valid pins
+  var pin = hubconnector[0];
+  
+  Blockly.Arduino.reservePin(
+      block, pin, Blockly.Arduino.PinTypes.INPUT, 'Digital Read');
+
+  //btnName is a variable containing the used pins
+  Blockly.Arduino.addVariable(btnName,
+      'int ' + btnName + ' = ' + pin + ';', true);
+  
+  Blockly.Arduino.addDeclaration(btnName, 'boolean ' + btnName + '_PRESSED = ' + stateOutput + ';\n');
+  var pinSetupCode = 'pinMode(' + btnName + ', INPUT);';
+  Blockly.Arduino.addSetup('io_' + pin, pinSetupCode, false);
+
+  return '';
+};
+
+
+/**
+ * Function for waiting on an input of a button.
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['button_input'] = function(block) {
+  var ClickBranch = Blockly.Arduino.statementToCode(block, 'CLICKINPUT');
+  var LongPressBranch = Blockly.Arduino.statementToCode(block, 'LONGPRESSINPUT');
+  var PressBranch = Blockly.Arduino.statementToCode(block, 'PRESSINPUT');
+
+  var btnName = block.getFieldValue('BUTTONNAME');
+  var checkbox_name = (block.getFieldValue('WAIT_INPUT') == 'TRUE');
+  
+  if (checkbox_name) {
+    var whilecode_start = '    while (' + btnName + 'PressType == ' + btnName + 'NOPRESS) { \n';
+    var whilecode_end = '    }\n';
+  } else {
+    var whilecode_start = '';
+    var whilecode_end = '';
+  }
+
+  var decl_code = '' +
+'long ' + btnName + 'buttonTimer = 0;\n' +
+'#define ' + btnName + 'minShortPressTime 80\n' +
+'#define ' + btnName + 'longPressTime 750\n' +
+'boolean ' + btnName + 'buttonActive = false;\n' +
+'boolean ' + btnName + 'longPressActive = false;\n' +
+'#define ' + btnName + 'NOPRESS    0\n' +
+'#define ' + btnName + 'SHORTPRESS 1\n' +
+'#define ' + btnName + 'LONGPRESS  2\n' +
+'int ' + btnName + 'PressType = ' + btnName + 'NOPRESS;';
+
+  Blockly.Arduino.addDeclaration('btn_' + btnName + '_button_input', decl_code);
+  
+  //now a function to handle the button
+  
+  var decl_code_fun = '\nvoid handle' + btnName + 'Press() {\n' +
+'  ' + btnName + 'PressType = ' + btnName + 'NOPRESS;\n' + 
+    whilecode_start +
+'      if (digitalRead(' + btnName + ') == ' + btnName + '_PRESSED) {\n'+
+'        if (' + btnName + 'buttonActive == false) {\n'+
+'          ' + btnName + 'buttonActive = true;\n'+
+'          ' + btnName + 'buttonTimer = millis();\n'+
+'        }\n'+
+'        if ((millis() - ' + btnName + 'buttonTimer > ' + btnName + 'longPressTime) && (' + btnName + 'longPressActive == false)) {\n'+
+'          ' + btnName + 'longPressActive = true;\n'+
+'          ' + btnName + 'PressType = ' + btnName + 'LONGPRESS;\n'+
+'        }\n'+
+'      } else {\n'+
+'        if (' + btnName + 'buttonActive == true) {\n'+
+'          if (' + btnName + 'longPressActive == true) {\n'+
+'            ' + btnName + 'longPressActive = false;\n'+
+'          } else {\n'+
+'            //avoid fast fluctuations to be identified as a click\n' +
+'            if (millis() - ' + btnName + 'buttonTimer > ' + btnName + 'minShortPressTime)\n' +
+'              ' + btnName + 'PressType = ' + btnName + 'SHORTPRESS;\n' +
+'          }\n'+
+'          ' + btnName + 'buttonActive = false;\n'+
+'        }\n'+
+'      }\n' + whilecode_end +
+'}\n'
+    Blockly.Arduino.userFunctions_['btn_' + btnName + '_handlefun'] = decl_code_fun;
+  
+  //we now have code to poll the status of the button
+  //Execute the code block for the status found
+  var code = 'handle' + btnName + 'Press();\n' + 
+'\n' +
+'if (' + btnName + 'PressType == ' + btnName + 'SHORTPRESS) {\n' +
+'  //START STATEMENTS SHORT PRESS \n' +
+    ClickBranch +
+'  //END  STATEMENTS SHORT PRESS \n' +
+'} else if (' + btnName + 'PressType == ' + btnName + 'LONGPRESS) {\n' +
+'  //START STATEMENTS LONG PRESS \n' +
+    LongPressBranch +
+'  //END  STATEMENTS LONG PRESS \n' +
+'} else if (!' + btnName + 'longPressActive && digitalRead(' + btnName + ') == ' + btnName + '_PRESSED) {\n' +
+'  //START STATEMENTS PRESS \n' +
+    PressBranch +
+'  //END  STATEMENTS PRESS \n' +
+'}\n \n';
+  
+  return code;
+};
+
+
diff --git a/blockly/generators/arduino/components.js b/blockly/generators/arduino/components.js
new file mode 100644
index 0000000000..cf33b32f68
--- /dev/null
+++ b/blockly/generators/arduino/components.js
@@ -0,0 +1,60 @@
+/**
+ * @license Licensed under the Apache License, Version 2.0 (the "License"):
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @fileoverview Generating Microduino code for procedure (function) blocks.
+ *
+ */
+'use strict';
+
+goog.provide('Blockly.Arduino.components');
+
+goog.require('Blockly.Arduino');
+
+
+/**
+ * The default arduino Hub block
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['core_hub_component'] = function(block) {
+  
+  function parseInput(block, name, connectors) {
+    var targetBlock = block.getInputTargetBlock(name);
+    if (targetBlock) {
+      targetBlock.setHubConnector(connectors);
+    }
+    var code = Blockly.Arduino.blockToCode(targetBlock);
+    if (!goog.isString(code)) {
+      throw 'Expecting code from statement block "' + targetBlock.type + '".';
+    }
+    if (code) {
+      // blocks should only init data ... 
+      console.log('Unexpected code in core_hub_component', code)
+    }
+    return code;
+  }
+
+  //set to which pin a block connects
+  for (var i = 1; i <= this.digCount_; i++) {
+    var pin = block.getFieldValue('PIND' + i);
+    parseInput(block, 'DIG' + i, [pin]);
+  }
+  for (var i = 1; i <= this.anaCount_; i++) {
+    var pin = block.getFieldValue('PINA' + i);
+    parseInput(block, 'ANA' + i, [pin]);
+  }
+  for (var i = 1; i <= this.pwmCount_; i++) {
+    var pin = block.getFieldValue('PINP' + i);
+    parseInput(block, 'PWM' + i, [pin]);
+  }
+  for (var i = 1; i <= this.digdigCount_; i++) {
+    var pin1 = block.getFieldValue('PINDD1_' + i);
+    var pin2 = block.getFieldValue('PINDD2_' + i);
+    parseInput(block, 'DIGDIG' + i, [pin1, pin2]);
+  }
+  
+  return '';
+};
diff --git a/blockly/generators/arduino/io.js b/blockly/generators/arduino/io.js
index 0c3bce5ff6..a00e470202 100644
--- a/blockly/generators/arduino/io.js
+++ b/blockly/generators/arduino/io.js
@@ -167,3 +167,171 @@ Blockly.Arduino['io_pulsetimeout'] = function(block) {
 
   return [code, Blockly.Arduino.ORDER_ATOMIC];
 }; 
+
+/**
+ * The analogsensor setup block
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['analogsensor_config_hub'] = function(block) {
+  var SensorName = block.getFieldValue('SENSORNAME');
+  //the hub saved the connector in the attached block
+  var hubconnector = block['connector'] || ['0', '1']
+  //compute the pins, normally only possible to attach at valid pins
+  var pin = hubconnector[0];
+
+  Blockly.Arduino.reservePin(
+      block, pin, Blockly.Arduino.PinTypes.INPUT, 'Analogue Read');
+
+  //SensorName is a variable containing the used pins
+  Blockly.Arduino.addVariable(SensorName,
+      'int ' + SensorName + ' = ' + pin + ';', true);
+  
+  var pinSetupCode = 'pinMode(' + SensorName + ', INPUT);';
+  Blockly.Arduino.addSetup('io_' + SensorName, pinSetupCode, false);
+
+  return '';
+};
+
+/**
+ * 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['analogsensor_read'] = function(block) {
+  var pin = block.getFieldValue('SENSORNAME');
+
+  var code = 'analogRead(' + pin + ')';
+  return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+/**
+ * The digitalinput setup block
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['digitalinput_config_hub'] = function(block) {
+  var SensorName = block.getFieldValue('SENSORNAME');
+  //the hub saved the connector in the attached block
+  var hubconnector = block['connector'] || ['0', '1']
+  //compute the pins, normally only possible to attach at valid pins
+  var pin = hubconnector[0];
+
+  Blockly.Arduino.reservePin(
+      block, pin, Blockly.Arduino.PinTypes.INPUT, 'Digital Read');
+
+  //SensorName is a variable containing the used pins
+  Blockly.Arduino.addVariable(SensorName,
+      'int ' + SensorName + ' = ' + pin + ';', true);
+  
+  var pinSetupCode = 'pinMode(' + SensorName + ', INPUT);';
+  Blockly.Arduino.addSetup('io_' + SensorName, pinSetupCode, false);
+
+  return '';
+};
+
+/**
+ * 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['digitalinput_read'] = function(block) {
+  var pin = block.getFieldValue('SENSORNAME');
+
+  var code = 'digitalRead(' + pin + ')';
+  return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
+/**
+ * The digitaloutput setup block
+ * Arduino code: setup { pinMode(X, OUTPUT); }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['digitaloutput_config_hub'] = function(block) {
+  var OutputName = block.getFieldValue('OUTPUTNAME');
+  //the hub saved the connector in the attached block
+  var hubconnector = block['connector'] || ['0', '1']
+  //compute the pins, normally only possible to attach at valid pins
+  var pin = hubconnector[0];
+
+  Blockly.Arduino.reservePin(
+      block, pin, Blockly.Arduino.PinTypes.OUTPUT, 'Digital Write');
+
+  //OutputName is a variable containing the used pins
+  Blockly.Arduino.addVariable(OutputName,
+      'int ' + OutputName + ' = ' + pin + ';', true);
+  
+  var pinSetupCode = 'pinMode(' + OutputName + ', OUTPUT);';
+  Blockly.Arduino.addSetup('io_' + OutputName, pinSetupCode, false);
+
+  return '';
+};
+
+/**
+ * Function for 'set pin' (X) to a state (Y).
+ * Arduino code: loop  { digitalWrite(X, Y); }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['digitaloutput_write'] = function(block) {
+  var pin = block.getFieldValue('OUTPUTNAME');
+  var stateOutput = Blockly.Arduino.valueToCode(
+      block, 'STATE', Blockly.Arduino.ORDER_ATOMIC) || 'LOW';
+
+  var code = 'digitalWrite(' + pin + ', ' + stateOutput + ');\n';
+  return code;
+};
+
+/**
+ * The pwmoutput setup block
+ * Arduino code: setup { pinMode(X, OUTPUT); }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['pwmoutput_config_hub'] = function(block) {
+  var OutputName = block.getFieldValue('OUTPUTNAME');
+  //the hub saved the connector in the attached block
+  var hubconnector = block['connector'] || ['0', '1']
+  //compute the pins, normally only possible to attach at valid pins
+  var pin = hubconnector[0];
+
+  Blockly.Arduino.reservePin(
+      block, pin, Blockly.Arduino.PinTypes.OUTPUT, 'Analogue Write');
+
+  //OutputName is a variable containing the used pins
+  Blockly.Arduino.addVariable(OutputName,
+      'int ' + OutputName + ' = ' + pin + ';', true);
+  
+  var pinSetupCode = 'pinMode(' + OutputName + ', OUTPUT);';
+  Blockly.Arduino.addSetup('io_' + OutputName, pinSetupCode, false);
+
+  return '';
+};
+
+/**
+ * Function for setting the state (Y) of an analogue output (X).
+ *               loop  { analogWrite(X, Y);  }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['pwmoutput_write'] = function(block) {
+  var pin = block.getFieldValue('OUTPUTNAME');
+  var stateOutput = Blockly.Arduino.valueToCode(
+      block, 'NUM', Blockly.Arduino.ORDER_ATOMIC) || '0';
+
+  // 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;
+};
diff --git a/blockly/generators/arduino/light.js b/blockly/generators/arduino/light.js
new file mode 100644
index 0000000000..31bfcb53ea
--- /dev/null
+++ b/blockly/generators/arduino/light.js
@@ -0,0 +1,217 @@
+/**
+ * @license Licensed under the Apache License, Version 2.0 (the "License"):
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @fileoverview Generating Microduino code for procedure (function) blocks.
+ *
+ */
+'use strict';
+
+goog.provide('Blockly.Arduino.light');
+
+goog.require('Blockly.Arduino');
+
+
+function hexToRgb(hex) {
+  if (hex.lastIndexOf('rgb', 0) === 0) {
+    var rgb = hex.substring(4, hex.length-1)
+         .replace(/ /g, '')
+         .split(',');
+    return {r: parseInt(rgb[0], 10),
+            g: parseInt(rgb[1], 10),
+            b: parseInt(rgb[2], 10),
+           }
+  } else {
+    var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? {
+        r: parseInt(result[1], 16),
+        g: parseInt(result[2], 16),
+        b: parseInt(result[3], 16)
+    } : {
+        r: 0,
+        g: 0,
+        b: 0
+    };
+  }
+}
+
+
+/**
+ * The led setup block
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['led_config_hub'] = function(block) {
+  var LEDName = block.getFieldValue('LEDNAME');
+  var polarity = block.getFieldValue('POLARITY');
+  var LEDon = 'HIGH';
+  if (polarity == 'neg') {
+    LEDon = 'LOW';
+  }
+  //the hub saved the connector in the attached block
+  var hubconnector = block['connector'] || ['0', '1']
+  //compute the pins, normally only possible to attach at valid pins
+  var pin = hubconnector[0];
+
+  Blockly.Arduino.reservePin(
+      block, pin, Blockly.Arduino.PinTypes.OUTPUT, 'Digital Write to LED');
+
+  //LEDName is a variable containing the used pins
+  Blockly.Arduino.addVariable(LEDName,
+      'int ' + LEDName + ' = ' + pin + 
+      ';\nboolean ' + LEDName + '_ON = ' + LEDon + ';', true);
+  
+  var pinSetupCode = 'pinMode(' + LEDName + ', OUTPUT);';
+  Blockly.Arduino.addSetup('io_' + LEDName, pinSetupCode, false);
+
+  return '';
+};
+
+/**
+ * Function for writing a LED.
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['led_digitalwrite'] = function(block) {
+  var LEDName = block.getFieldValue('LEDNAME');
+  var stateOutput = Blockly.Arduino.valueToCode(
+      block, 'STATE', Blockly.Arduino.ORDER_ATOMIC) || 'LOW';
+  
+  var code = 'digitalWrite(' + LEDName + ', ' + stateOutput + ');\n';
+  return code;
+};
+
+
+/**
+ * Function for writing a LED.
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['led_digitalwrite_onoff'] = function(block) {
+  var LEDName = block.getFieldValue('LEDNAME');
+  var stateOutput = block.getFieldValue('STATE');
+  var stateval = LEDName + '_ON';
+  if (stateOutput == 'off') {
+    stateval = '! (' + stateval + ')';
+  }
+  
+  var code = 'digitalWrite(' + LEDName + ', ' + stateval + ');\n';
+  return code;
+};
+
+/**
+ * The neopixel setup block
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['neopixel_config_hub'] = function(block) {
+  var NeoPixelName = block.getFieldValue('LEDNAME');
+  var number = Blockly.Arduino.valueToCode(
+      block, 'NUMBER', Blockly.Arduino.ORDER_ATOMIC) || '1';
+  var KHz = block.getFieldValue('KHZ');
+  var NeoType = block.getFieldValue('NEOPIXEL_TYPE');
+  
+  //the hub saved the connector in the attached block
+  var hubconnector = block['connector'] || ['0', '1']
+  //compute the pins, normally only possible to attach at valid pins
+  var pin = hubconnector[0];
+
+  Blockly.Arduino.reservePin(
+      block, pin, Blockly.Arduino.PinTypes.OUTPUT, 'Digital Write to Neopixel');
+
+  //NeoPixelName is a variable containing the used pins
+  Blockly.Arduino.addVariable(NeoPixelName,
+      'int ' + NeoPixelName + ' = ' + pin + ';', true);
+  
+  var NeoName = 'myNeo_' + NeoPixelName;
+  
+  var decl_code = '#include <Adafruit_NeoPixel.h>\n' +
+        'Adafruit_NeoPixel ' + NeoName + ' = Adafruit_NeoPixel(' + number +
+        ', ' +pin + ', ' + NeoType + ' + ' + KHz + ');';
+        
+  Blockly.Arduino.addDeclaration(NeoName, decl_code);
+  
+  var setupCode = NeoName + '.begin();\n' +
+                  '  ' + NeoName + '.show();';
+  Blockly.Arduino.addSetup('io_' + NeoName, setupCode, false);
+  
+  return '';
+
+};
+
+/**
+ * Function for writing to a neopixel strip.
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['neopixel_write'] = function(block) {
+  var LEDName = block.getFieldValue('NEONAME');
+  var LEDPixel = Blockly.Arduino.valueToCode(
+      block, 'LEDPIXEL', Blockly.Arduino.ORDER_ATOMIC) || '0';
+  var Red = Blockly.Arduino.valueToCode(
+      block, 'RED', Blockly.Arduino.ORDER_ATOMIC) || '255';
+  var Green = Blockly.Arduino.valueToCode(
+      block, 'GREEN', Blockly.Arduino.ORDER_ATOMIC) || '255';
+  var Blue = Blockly.Arduino.valueToCode(
+      block, 'BLUE', Blockly.Arduino.ORDER_ATOMIC) || '255';
+
+  var code = 'myNeo_' + LEDName + '.setPixelColor(' + LEDPixel + '-1, myNeo_' + LEDName + '.Color(' + Red + ',' + Green + ',' + Blue + '));\n';
+  code += 'myNeo_' + LEDName + '.show();\n';
+
+  return code;
+};
+
+/**
+ * Function for writing to a neopixel strip.
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['neopixel_colourpick_write'] = function(block) {
+  var LEDName = block.getFieldValue('NEONAME');
+  var LEDPixel = Blockly.Arduino.valueToCode(
+      block, 'LEDPIXEL', Blockly.Arduino.ORDER_ATOMIC) || '0';
+  var Colour = block.getFieldValue('COLOUR');
+  //Colour = Colour.substring(4, Colour.length-1)
+  //               .replace(/ /g, '')
+  //               .split(',');
+  Colour = hexToRgb(Colour);
+  var Red = Colour.r;
+  var Green = Colour.g;
+  var Blue = Colour.b;
+
+  var code = 'myNeo_' + LEDName + '.setPixelColor(' + LEDPixel + '-1, myNeo_' + LEDName + '.Color(' + Red + ',' + Green + ',' + Blue + '));\n';
+  code += 'myNeo_' + LEDName + '.show();\n';
+
+  return code;
+};
+
+/**
+ * Function for writing to a neopixel strip.
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['neopixel_colourpick_dim_write'] = function(block) {
+  var LEDName = block.getFieldValue('NEONAME');
+  var LEDPixel = Blockly.Arduino.valueToCode(
+      block, 'LEDPIXEL', Blockly.Arduino.ORDER_ATOMIC) || '0';
+  var Brightness = Blockly.Arduino.valueToCode(
+      block, 'BRIGHTNESS', Blockly.Arduino.ORDER_ATOMIC) || '100';
+  
+  var Colour = block.getFieldValue('COLOUR');
+  //Colour = Colour.substring(4, Colour.length-1)
+  //               .replace(/ /g, '')
+  //               .split(',');
+  Colour = hexToRgb(Colour);
+  var Red = Colour.r;
+  var Green = Colour.g;
+  var Blue = Colour.b;
+
+  var code = 'myNeo_' + LEDName + '.setPixelColor(' + LEDPixel + '-1, myNeo_' + LEDName + '.Color(constrain(int(' + Red   + '*'+Brightness+'/100.0),0,255), ' + 
+                   'constrain(int(' + Green + '*'+Brightness+'/100.0),0,255), ' + 
+                   'constrain(int(' + Blue  + '*'+Brightness+'/100.0),0,255) ));\n';
+  code += 'myNeo_' + LEDName + '.show();\n';
+
+  return code;
+};
diff --git a/blockly/generators/arduino/servo.js b/blockly/generators/arduino/servo.js
index add65167fe..d8abf17b51 100644
--- a/blockly/generators/arduino/servo.js
+++ b/blockly/generators/arduino/servo.js
@@ -69,3 +69,78 @@ Blockly.Arduino['servo_read'] = function(block) {
   var code = servoName + '.read()';
   return [code, Blockly.Arduino.ORDER_ATOMIC];
 };
+
+
+/**
+ * The servo setup block
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['servo_config_hub'] = function(block) {
+  var servo = block.getFieldValue('NAMESERVO');
+  var servoType = block.getFieldValue('SERVOTYPE');
+  
+  //the hub saved the connector in the attached block
+  var hubconnector = block['connector'] || ['0', '1']
+  //compute the pins, normally only possible to attach at valid pins
+  var pin = hubconnector[0];
+
+  var servoName = 'myServo' + servo;
+  //servo is a variable containing the used pins
+  Blockly.Arduino.addVariable(servo,
+    'int ' + servo + ' = ' + pin + ';', true);
+  
+  Blockly.Arduino.addInclude('servo', '#include <Servo.h>');
+  Blockly.Arduino.addDeclaration('servo_' + servoName, 'Servo ' + servoName + ';');
+  Blockly.Arduino.reservePin(block, pin, Blockly.Arduino.PinTypes.SERVO, 'Servo Write');
+
+  var setupCode = servoName + '.attach(' + pin + ');';
+  Blockly.Arduino.addSetup('servo_' + servoName, setupCode, true);
+
+  return '';
+};
+
+/**
+ * Code generator to set an angle (Y) value to a servo PWM pin (X).
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['servohub_write'] = function(block) {
+  var servoInstanceName = block.getFieldValue('SERVO_NAME');
+  var servoAngle = Blockly.Arduino.valueToCode(
+      block, 'SERVO_ANGLE', Blockly.Arduino.ORDER_ATOMIC) || '90';
+  var servoName = 'myServo' + servoInstanceName;
+
+  var code = servoName + '.write(' + servoAngle + ');\n';
+  return code;
+};
+
+/**
+ * Code generator to set a speed value to a servo PWM pin.
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Completed code.
+ */
+Blockly.Arduino['servohub_write2'] = function(block) {
+  var servoInstanceName = block.getFieldValue('SERVO_NAME');
+  var servoSpeed = Blockly.Arduino.valueToCode(
+      block, 'SERVO_SPEED', Blockly.Arduino.ORDER_ATOMIC) || '0';
+  var servoName = 'myServo' + servoInstanceName;
+
+  //convert -100 .. 100 to 0..180 
+  var code = servoName + '.write(constrain(map(' + servoSpeed + ', -100, 100, 0, 180), 0, 180));\n';
+  return code;
+};
+
+/**
+ * Code generator to read an angle value from a servo PWM pin (X).
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {array} Completed code with order of operation.
+ */
+Blockly.Arduino['servohub_read'] = function(block) {
+  var servoInstanceName = block.getFieldValue('SERVO_NAME');
+  var servoName = 'myServo' + servoInstanceName;
+
+  var code = servoName + '.read()';
+  return [code, Blockly.Arduino.ORDER_ATOMIC];
+};
+
diff --git a/blockly/generators/arduino/stepper.js b/blockly/generators/arduino/stepper.js
index 7c1b66b3c0..a604d8690f 100644
--- a/blockly/generators/arduino/stepper.js
+++ b/blockly/generators/arduino/stepper.js
@@ -28,11 +28,16 @@ Blockly.Arduino['stepper_config'] = function(block) {
   var pin1 = block.getFieldValue('STEPPER_PIN1');
   var pin2 = block.getFieldValue('STEPPER_PIN2');
   var pinType = Blockly.Arduino.PinTypes.STEPPER;
-  var stepperName = block.getStepperSetupInstance();
+  var stepperName = block.getFieldValue('STEPPER_NAME');
   var stepperSteps = Blockly.Arduino.valueToCode(block, 'STEPPER_STEPS',
       Blockly.Arduino.ORDER_ATOMIC) || '360';
   var stepperSpeed = Blockly.Arduino.valueToCode(block, 'STEPPER_SPEED',
       Blockly.Arduino.ORDER_ATOMIC) || '90';
+  
+  //stepper is a variable containing the used pins
+  Blockly.Arduino.addVariable(stepperName,
+      'int ' + stepperName + '[2] = {' + pin1 + ', ' + pin2 + '};', true);
+  stepperName = 'stepper_' + stepperName
 
   Blockly.Arduino.reservePin(block, pin1, pinType, 'Stepper');
   Blockly.Arduino.reservePin(block, pin2, pinType, 'Stepper');
@@ -41,10 +46,53 @@ Blockly.Arduino['stepper_config'] = function(block) {
 
   var globalCode = 'Stepper ' + stepperName + '(' + stepperSteps + ', ' +
       pin1 + ', ' + pin2 + ');';
-  Blockly.Arduino.addDeclaration('stepper_' + stepperName, globalCode);
+  Blockly.Arduino.addDeclaration(stepperName, globalCode);
 
   var setupCode = stepperName + '.setSpeed(' + stepperSpeed + ');';
-  Blockly.Arduino.addSetup('stepper_' + stepperName, setupCode, true);
+  Blockly.Arduino.addSetup(stepperName, setupCode, true);
+
+  return '';
+};
+
+/**
+ * Code generator for the stepper generator configuration. Nothing is added
+ * to the 'loop()' function. Sets the pins (X and Y), steps per revolution (Z),
+ * speed(A) and instance name (B).
+ * Arduino code: #include <Stepper.h>
+ *               Stepper B(Z, X, Y);
+ *               setup() { B.setSpeed(A); }
+ * @param {!Blockly.Block} block Block to generate the code from.
+ * @return {string} Empty string as no code goes into 'loop()'.
+ */
+Blockly.Arduino['stepper_config_hub'] = function(block) {
+  
+  //the hub saved the connector in the attached block
+  var hubconnector = block['connector'] || ['0', '1']
+  var pin1 = hubconnector[0];
+  var pin2 = hubconnector[1];
+  var pinType = Blockly.Arduino.PinTypes.STEPPER;
+  var stepperName = block.getFieldValue('STEPPER_NAME');
+  var stepperSteps = Blockly.Arduino.valueToCode(block, 'STEPPER_STEPS',
+      Blockly.Arduino.ORDER_ATOMIC) || '360';
+  var stepperSpeed = Blockly.Arduino.valueToCode(block, 'STEPPER_SPEED',
+      Blockly.Arduino.ORDER_ATOMIC) || '90';
+  
+  //stepper is a variable containing the used pins
+  Blockly.Arduino.addVariable(stepperName,
+      'int ' + stepperName + '[2] = {' + pin1 + ', ' + pin2 + '};', true);
+  stepperName = 'stepper_' + stepperName
+
+  Blockly.Arduino.reservePin(block, pin1, pinType, 'Stepper');
+  Blockly.Arduino.reservePin(block, pin2, pinType, 'Stepper');
+
+  Blockly.Arduino.addInclude('stepper', '#include <Stepper.h>');
+
+  var globalCode = 'Stepper ' + stepperName + '(' + stepperSteps + ', ' +
+      pin1 + ', ' + pin2 + ');';
+  Blockly.Arduino.addDeclaration(stepperName, globalCode);
+
+  var setupCode = stepperName + '.setSpeed(' + stepperSpeed + ');';
+  Blockly.Arduino.addSetup(stepperName, setupCode, true);
 
   return '';
 };
@@ -58,7 +106,7 @@ Blockly.Arduino['stepper_config'] = function(block) {
  * @return {array} Completed code with order of operation.
  */
 Blockly.Arduino['stepper_step'] = function(block) {
-  var stepperInstanceName = block.getFieldValue('STEPPER_NAME');
+  var stepperInstanceName = 'stepper_' + block.getFieldValue('STEPPER_NAME');
   var stepperSteps = Blockly.Arduino.valueToCode(block, 'STEPPER_STEPS',
       Blockly.Arduino.ORDER_ATOMIC) || '0';
   var code = stepperInstanceName + '.step(' + stepperSteps + ');\n';
diff --git a/blockly/media/arduino/Button.png b/blockly/media/arduino/Button.png
new file mode 100644
index 0000000000..e399b56f7a
Binary files /dev/null and b/blockly/media/arduino/Button.png differ
diff --git a/blockly/media/arduino/Led.png b/blockly/media/arduino/Led.png
new file mode 100644
index 0000000000..ce5ef97672
Binary files /dev/null and b/blockly/media/arduino/Led.png differ
diff --git a/blockly/media/arduino/Servo.png b/blockly/media/arduino/Servo.png
new file mode 100644
index 0000000000..c39b4b3a47
Binary files /dev/null and b/blockly/media/arduino/Servo.png differ
diff --git a/blockly/msg/js/nl.js b/blockly/msg/js/nl.js
index a19f51fb37..4ec9a380fa 100644
--- a/blockly/msg/js/nl.js
+++ b/blockly/msg/js/nl.js
@@ -72,6 +72,7 @@ Blockly.Msg.ARD_SPI_TRANS_TIP = "Stuurt een SPI bericht naar het opgegeven slaaf
 Blockly.Msg.ARD_SPI_TRANS_VAL = "stuur";
 Blockly.Msg.ARD_SPI_TRANS_WARN1 = "Een Defenitie blok voor %1 moet toegevoegd worden aan de canvas om dit blok te gebruiken!";
 Blockly.Msg.ARD_SPI_TRANS_WARN2 = "Oude pin waarde %1 is niet langer beschikbaar.";
+Blockly.Msg.ARD_STEPPER_DEFAULT_NAME = "MijnStappenMotor";
 Blockly.Msg.ARD_STEPPER_MOTOR = "stappenmotor:";
 Blockly.Msg.ARD_STEPPER_PIN1 = "pin1#";
 Blockly.Msg.ARD_STEPPER_PIN2 = "pin2#";
@@ -491,4 +492,4 @@ Blockly.Msg.LISTS_CREATE_WITH_ITEM_TITLE = Blockly.Msg.VARIABLES_DEFAULT_NAME;
 Blockly.Msg.TEXT_APPEND_VARIABLE = Blockly.Msg.VARIABLES_DEFAULT_NAME;
 Blockly.Msg.TEXT_CREATE_JOIN_ITEM_TITLE_ITEM = Blockly.Msg.VARIABLES_DEFAULT_NAME;
 Blockly.Msg.LISTS_INDEX_OF_INPUT_IN_LIST = Blockly.Msg.LISTS_INLIST;
-Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT = Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT;
\ No newline at end of file
+Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT = Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT;
diff --git a/blockly/msg/json/nl.json b/blockly/msg/json/nl.json
index f1fccd9b80..93361af7c7 100644
--- a/blockly/msg/json/nl.json
+++ b/blockly/msg/json/nl.json
@@ -329,7 +329,7 @@
 	"VARIABLES_SET_TOOLTIP": "Verandert de waarde van de variabele naar de waarde van de invoer.",
 	"VARIABLES_SET_CREATE_GET": "Maak 'opvragen van %1'",
 	"PROCEDURES_DEFNORETURN_HELPURL": "https://nl.wikipedia.org/wiki/Subprogramma",
-	"PROCEDURES_DEFNORETURN_TITLE": "om",
+	"PROCEDURES_DEFNORETURN_TITLE": "opdracht",
 	"PROCEDURES_DEFNORETURN_PROCEDURE": "doe iets",
 	"PROCEDURES_BEFORE_PARAMS": "met:",
 	"PROCEDURES_CALL_BEFORE_PARAMS": "met:",
@@ -366,6 +366,8 @@
 	"ARD_TYPE_NULL": "Geen Type",
 	"ARD_TYPE_UNDEF": "Ongedefineerd",
 	"ARD_TYPE_CHILDBLOCKMISSING": "ChildBlockMissing",
+        "ARD_BOARD": "Platform",
+        "ARD_BOARD_WARN": "Dit blok vereist als chip %1, maar een ander blok is aanwezig welke een andere Arduino chip vereist",
 	"ARD_HIGH": "HOOG",
 	"ARD_LOW": "LAAG",
 	"ARD_ANALOGREAD": "lees analoge pin#",
@@ -389,9 +391,11 @@
 	"ARD_MAP": "Herschaal",
 	"ARD_MAP_VAL": "waarde naar [0-",
 	"ARD_MAP_TIP": "Herschaalt een getal in interval [0-1024] naar een ander getal in de gegeven schaal.",
+	"ARD_FUN_RUN_DECL": "Arduino definieer vooraf:",
 	"ARD_FUN_RUN_SETUP": "Arduino doe eerst:",
 	"ARD_FUN_RUN_LOOP": "Arduino herhaal voor altijd:",
 	"ARD_FUN_RUN_TIP": "Definieer de Arduino setup() en loop() functies.",
+	"ARD_FUN_RUN_DECL_TIP": "Code die je vooraf wil declareren (gebruik dit bv. voor variabelen die je nodig zult hebben in de setup).",
 	"ARD_PIN_WARN1": "Pin %1 is nodig voor %2 als pin %3. Al gebruikt als %4.",
 	"ARD_SERIAL_SETUP": "Start",
 	"ARD_SERIAL_SPEED": ":  zet snelheid op",
@@ -407,6 +411,12 @@
 	"ARD_SERVO_WRITE_TIP": "Positioneer een Servo motor naar de gegeven hoek",
 	"ARD_SERVO_READ": "lees Servo met pin",
 	"ARD_SERVO_READ_TIP": "Lees de hoek van een Servo motor die met de gegeven pin connecteert",
+        "ARD_SERVOHUB": "Servo motor",
+        "ARD_SERVO_DEFAULT_NAME": "Servo1",
+        "ARD_SERVO_TYPE": "Type:",
+        "ARD_180SERVO": "0~180 graden Servo (hoek)",
+        "ARD_360SERVO": "0~360 graden Servo (rotatie)",
+        "ARD_SERVOHUB_TIP": "Servo Motor Connectie, welke je kan verbinden aan een PWM pin. Je moet de servo een naam geven, en aangeven welk type het is (een 180 graden servo of een 360 graden servo.)",
 	"ARD_SPI_SETUP": "Definieer",
 	"ARD_SPI_SETUP_CONF": "configuratie:",
 	"ARD_SPI_SETUP_SHIFT": "data shift",
@@ -426,8 +436,9 @@
 	"ARD_SPI_TRANS_WARN1": "Een Defenitie blok voor %1 moet toegevoegd worden aan de canvas om dit blok te gebruiken!",
 	"ARD_SPI_TRANS_WARN2": "Oude pin waarde %1 is niet langer beschikbaar.",
 	"ARD_SPI_TRANSRETURN_TIP": "Stuur een SPI bericht naar het opgegeven slaaf toestel en krijg data terug.",
-	"ARD_STEPPER_SETUP": "Definieer",
-	"ARD_STEPPER_MOTOR": "stappenmotor:",
+	"ARD_STEPPER_SETUP": "Definieer stappenmotor ",
+	"ARD_STEPPER_MOTOR": "",
+        "ARD_STEPPER_DEFAULT_NAME": "MijnStappenMotor",
 	"ARD_STEPPER_PIN1": "pin1#",
 	"ARD_STEPPER_PIN2": "pin2#",
 	"ARD_STEPPER_REVOLVS": "aantal stappen per omwenteling",
@@ -436,9 +447,15 @@
 	"ARD_STEPPER_STEP": "beweeg stappenmotor",
 	"ARD_STEPPER_STEPS": "stappen",
 	"ARD_STEPPER_STEP_TIP": "Draait de stappenmotor een opgegeven aantal stappen",
-	"ARD_STEPPER_STEP_WARN1": "Een Stappenmotor start Definieer blok moet toegevoegd worden om dit blok te gebruiken!",
-	"ARD_STEPPER_STEP_WARN2": "Een naam input moet toegevoegd worden aan een stappenmotor Definieer blok!",
-	"ARD_STEPPER_STEP_WARN3": "De geselecteerde stappenmotor bestaat niet meer, kies een nieuwe.",
+        "ARD_STEPPER_COMPONENT": "stappenmotor",
+        "ARD_SERVO_COMPONENT": "servo",
+        "ARD_SERVO_ROTATE360": "Roteer 360 graden Servo",
+        "ARD_SERVO_ROTATESPEED": "met snelheid",
+        "ARD_SERVO_ROTATEPERC": "% (-100 tot 100)",
+        "ARD_SERVO_ROTATE_TIP": "Draai een Servo aan een bepaalde snelheid",
+        "ARD_SERVOHUB_WRITE": "Positioneer 180 graden Servo ",
+        "ARD_SERVOHUB_READ": "lees Servo ",
+	"ARD_COMPONENT_WARN1": "Een %1 Definieer blok met dezelfde %1 naam moet toegevoegd worden om dit blok te gebruiken!",
 	"ARD_TIME_DELAY": "wacht",
 	"ARD_TIME_MS": "milliseconden",
 	"ARD_TIME_DELAY_TIP": "Wacht de opgegeven tijd in milliseconden (duizendsten van een seconde)",
@@ -452,6 +469,35 @@
 	"ARD_TIME_INF_TIP": "Wacht voor altijd, stopt het programma waar deze lijn staat.",
 	"ARD_VAR_AS": "als",
 	"ARD_VAR_AS_TIP": "Wijzigt de waarde in het gegeven type",
+	"ARD_AS_BOOL_NUMBER": "als boolean",
+	"ARD_AS_INTEGER_NUMBER": "als geheel getal",
+	"ARD_AS_UINT_NUMBER": "als positief geheel getal",
+	"ARD_AS_LONG_NUMBER": "als lang geheel getal",
+	"ARD_AS_ULONG_NUMBER": "als lang positief geheel getal",
+	"ARD_AS_FLOAT_NUMBER": "als decimaal getal",
+	"ARD_AS_BOOL_NUMBER_TIP": "Definieer een variabele als boolean getal met waarde waar of vals",
+	"ARD_AS_INTEGER_NUMBER_TIP": "Definieer een variabele als geheel getal, -32768 to 32767",
+	"ARD_AS_UINT_NUMBER_TIP": "Definieer een variabele als positief geheel getalr, 0 to 65535",
+	"ARD_AS_LONG_NUMBER_TIP": "Definieer een variabele als lang geheel getal, -2,147,483,648 to 2,147,483,647",
+	"ARD_AS_ULONG_NUMBER_TIP": "Definieer een variabele als positief lang geheel getal, 0 to 4,294,967,295",
+	"ARD_AS_FLOAT_NUMBER_TIP": "Definieer een variabele als decimaal getal, vb 3.6 of 5e4 of -3.14",
+	
+	"ARD_AS_DIGINPUT_PIN": "als digitale input",
+	"ARD_AS_DIGINPUT_PIN_TIP": "Definieer een variabele als een pin voor digitale input",
+	"ARD_AS_DIGOUTPUT_PIN": "als digitale output",
+	"ARD_AS_DIGOUTPUT_PIN_TIP": "Definieer een variabele als een pin voor digitale output",
+	"ARD_AS_ANAINPUT_PIN": "als analoge input",
+	"ARD_AS_ANAINPUT_PIN_TIP": "Definieer een variabele als een pin voor analoge input",
+	"ARD_AS_ANAOUTPUT_PIN": "als analoge output",
+	"ARD_AS_ANAOUTPUT_PIN_TIP": "Definieer een variabele als een pin voor analoge PWM output",
+	"ARD_DIGITALWRITEVAR_TIP": "Schrijf digitale waarde HOOG of LAAG naar een gegeven PIN, de waarde en de pin kunnen berekende variabelen zijn",
+	
+	"ARD_PIN_AN": "analoge pin",
+	"ARD_PIN_DIG": "digitale pin",
+	"ARD_PIN_PWM": "PWM pin",
+	"ARD_PIN_AN_TIP": "Een van de analoge pinnen van de Arduino",
+	"ARD_PIN_DIG_TIP": "Een van de digitale pinnen van de Arduino",
+	"ARD_PIN_PWM_TIP": "Een van de Puls Breedte Modulatie (PWM) pinnen van de Arduino",
 	"ARD_PULSEREAD": "Lees een",
 	"ARD_PULSEON": "puls op pin #",
 	"ARD_PULSETIMEOUT": "wacht maximaal",
@@ -463,5 +509,82 @@
 	"ARD_TONE_TIP": "Speelt een noot op de gegeven pin met de opgegeven frequentie binnen interval 31 - 65535",
 	"ARD_TONE_WARNING": "Frequentie moet in het interval 31 - 65535 liggen",
 	"ARD_NOTONE": "Stop afspelen noot op pin#",
-	"ARD_NOTONE_TIP": "Stopt met een noot af te spelen op de gegeven pin"
+	"ARD_NOTONE_TIP": "Stopt met een noot af te spelen op de gegeven pin",
+        "ARD_LEDLEG_COMPONENT": "LED",
+        "ARD_LEDLEG_DEFAULT_NAME": "Led_1",
+        "ARD_LEDLEG": "LED",
+        "ARD_LEDLEGPOL": "been polariteit",
+        "ARD_LEDLEGPOS": "plus",
+        "ARD_LEDLEGNEG": "min",
+        "ARD_LEDLEG_TIP": "Een LED licht, een van de beentjes (de positieve of de negatieve) is verbonden aan de Arduino. Kan AAN of UIT zijn.",
+        "ARD_LEDLEG_SET": "Zet LED",
+        "ARD_LEDLEG_ON": "AAN",
+        "ARD_LEDLEG_OFF": "UIT",
+        "ARD_NEOPIXEL": "NeoPixel LED licht",
+        "ARD_NEOPIXEL_STRIP": "Strip met",
+        "ARD_NEOPIXEL_PIXELS": "Pixels.",
+        "ARD_NEOPIXEL_HZ": "Frequentie:",
+        "ARD_NEOPIXEL_TYPE": "Type:",
+        "ARD_NEOPIXEL_TIP": "Een NEOPIXEL LED licht of een strip met meerdere neopixels.",
+        "ARD_NEOPIXEL_SET": "Zet Neopixel",
+        "ARD_NEOPIXEL_PIXEL": "pixel",
+        "ARD_NEOPIXEL_ONCOLOUR": "op kleur",
+        "ARD_NEOPIXEL_BRIGHTNESS": " helderheid (%)",
+        "ARD_NEOPIXEL_ONCOLOURVALRED": "op kleur (0-255) rood:",
+        "ARD_NEOPIXEL_ONCOLOURVALGREEN": "groen:",
+        "ARD_NEOPIXEL_ONCOLOURVALBLUE": "blauw:",
+        "ARD_NEOPIXEL_COMPONENT": "Neopixel strip",
+        "ARD_NEOPIXEL_DEFAULT_NAME": "NeoPixel_1",
+        "ARD_BLOCKS": "Je hebt twee keer dit blok staan. Dat is 1 keer teveel!",
+        "ARD_BUTTON_COMPONENT": "Drukknop",
+        "ARD_BUTTON_DEFAULT_NAME": "Drukknop1",
+        "ARD_BUTTON_IFPUSHED": "Als ingedrukt meten we waarde",
+        "ARD_BUTTON_TIP": "Een drukknop die AAN of UIT kan zijn",
+        "ARD_BUTTON_READ": "Lees waarde knop",
+        "ARD_BUTTON_INPUT_IF": "Als knop",
+        "ARD_BUTTON_INPUT_CLICK": " geklikt wordt",
+        "ARD_BUTTON_INPUT_THEN": "dan",
+        "ARD_BUTTON_INPUT_LONGCLICK": "lang geklikt wordt",
+        "ARD_BUTTON_INPUT_PRESSED": "ingedrukt wordt",
+        "ARD_BUTTON_INPUT_WAIT": "wacht tot een klik gebeurt",
+        "ARD_BUTTON_INPUT_TIP": "Controleer de input ontvangen op de knop, en reageer erop. Deze functie blokkeert je programma niet als je niet aanvinkt dat er moet gewacht worden op een klik. Klikken is drukken en loslaten, lang klikken is drukken en wat wachten voor loslaten, indrukken is zodra de knop ingedrukt is.",
+        "ARD_ANASENSOR": "Analoge Sensor",
+        "ARD_ANASENSOR_TIP": "Connecteer een analoge sensor aan een analoge pin op een hub, en lees zijn waarde. Bij een Arduino UNO verkrijg je bij lezen een waarde tussen 0 en 1024, welke overeenkomt met een gemeten waarde tussen 0 en 5V. Bv.: een LDR sensor, een potmeter, ...",
+        "ARD_ANASENSOR_DEFAULT_NAME": "AnaSensor1",
+        "ARD_ANASENSOR_READ": "Lees analoge sensor",
+        "ARD_ANASENSOR_COMPONENT": "Analoge Sensor",
+        "ARD_DIGINPUT": "Digital Input",
+        "ARD_DIGINPUT_TIP": "Connecteer een digitale input aan een digitale pin op een hub, en lees zijn waarde. Bij een Arduino UNO verkrijg je bij lezen een waarde HIGH of LOW wat overeenkomt met 0 en 5V.",
+        "ARD_DIGINPUT_DEFAULT_NAME": "DigInput1",
+        "ARD_DIGINPUT_READ": "Lees digitale input",
+        "ARD_DIGINPUT_COMPONENT": "Digitale Input",
+        "ARD_DIGOUTPUT": "Digitale output",
+        "ARD_DIGOUTPUT_TIP": "Connecteer een digitale output aan een digitale pin op een hub, en schrijf naar die pin. De digitale toestend kan LOW of HIGH zijn, welke overeenkomt met 0V en 5V op die pin voor een Arduino UNO.",
+        "ARD_DIGOUTPUT_DEFAULT_NAME": "DigOutput1",
+        "ARD_DIGOUTPUT_WRITE": "Schrijf naar digital output",
+        "ARD_DIGOUTPUT_COMPONENT": "Digitale Output",
+        "ARD_PWMOUTPUT": "PWM output",
+        "ARD_PWMOUTPUT_TIP": "Connecteer een generieke PWM (Pulse Width Modulation) ouput aan een PWM pin, zodat je een analoge waarde kunt schrijven naar die pin. De waarde die je schrijft moet een nummer zijn tussen 0 en 255, en zal een blok puls genereren over de pin.",
+        "ARD_PWMOUTPUT_DEFAULT_NAME": "PWMOutput1",
+        "ARD_PWMOUTPUT_WRITE": "Schrijf naar PWM output",
+        "ARD_PWMOUTPUT_COMPONENT": "PWM Output",
+        "ARD_OUTPUT_WRITE_TO": "waarde",
+        "ARD_CONTROLS_EFFECT_TOOLTIP_1": "Aan de start van een effect doen we enkele opdrachten",
+        "ARD_CONTROLS_EFFECT_TOOLTIP_2": "Aan de start van een effect doen we enkele opdrachten, en aan het einde ook",
+        "ARD_CONTROLS_EFFECT_TOOLTIP_3": "Aan de start van een effect doen we enkele opdrachten, als de effect tijd groter wordt dan de gegeven waarde, worden de volgende opdrachten uitgevoerd.",
+        "ARD_CONTROLS_EFFECT_TOOLTIP_4": "Aan de start van een effect doen we enkele opdrachten, als de effect tijd groter wordt dan de gegeven waarde, worden de volgende opdrachten uitgevoerd. Aan het einde worden de laatste opdrachten uitgevoerd.",
+        "ARD_CONTROLS_EFFECT_MSG_FIRST1": "Effect",
+        "ARD_CONTROLS_EFFECT_MSG_FIRST2": "met totale duurtijd (ms) =",
+        "ARD_CONTROLS_EFFECT_MSG_IF": "bij start doe",
+        "ARD_CONTROLS_EFFECT_MSG_ELSEIF": "als effect tijd groter wordt dan",
+        "ARD_CONTROLS_EFFECT_MSG_ELSE": "op einde doe",
+        "ARD_CONTROLS_EFFECT_ELSEIF_TOOLTIP": "Voeg een extra effect tijd toe om opdrachten bij uit te voeren",
+        "ARD_CONTROLS_EFFECT_ELSE_TOOLTIP": "Voeg een blok toe voor als effect gedaan is",
+        "ARD_COMPONENT_BOARD": "een bepaald Arduino Bord",
+        "ARD_COMPONENT_BOARD_TIP": "Defineer welk Arduino bord je gebruikt, en connecteer componenten met de pinnen van de Arduino.",
+        "ARD_COMPONENT_BOARD_HUB_TIP": "Defineer welk Arduino bord je gebruikt, en met wat het geconnecteerd is.",
+        "ARD_PIN_DIGDIG": "digitale pin1 en pin2",
+        "ARD_PIN_DIGDIG_TIP": "Component welke twee digitale pinnen vereist, pin1 en pin2",
+        "ARD_PIN_DIGDIG1": "digitale pin1#",
+        "ARD_PIN_DIGDIG2": "digitale pin2#"
 }
diff --git a/blockly/msg/messages.js b/blockly/msg/messages.js
index 586b273740..cbf6bdd7b2 100644
--- a/blockly/msg/messages.js
+++ b/blockly/msg/messages.js
@@ -1111,6 +1111,8 @@ Blockly.Msg.ARD_TYPE_ARRAY = 'Array';
 Blockly.Msg.ARD_TYPE_NULL = 'Null';
 Blockly.Msg.ARD_TYPE_UNDEF = 'Undefined';
 Blockly.Msg.ARD_TYPE_CHILDBLOCKMISSING = 'ChildBlockMissing';
+Blockly.Msg.ARD_BOARD = 'Board';
+Blockly.Msg.ARD_BOARD_WARN = 'This block requires as board %1, but another block is present that requires another Arduino board!';
 Blockly.Msg.ARD_HIGH = 'HIGH';
 Blockly.Msg.ARD_LOW = 'LOW';
 Blockly.Msg.ARD_ANALOGREAD = 'read analog pin#';
@@ -1135,9 +1137,11 @@ Blockly.Msg.ARD_NOTONE_PIN_TIP = 'Stop generating a tone on a pin';
 Blockly.Msg.ARD_MAP = 'Map';
 Blockly.Msg.ARD_MAP_VAL = 'value to [0-';
 Blockly.Msg.ARD_MAP_TIP = 'Re-maps a number from [0-1024] to another.';
+Blockly.Msg.ARD_FUN_RUN_DECL = 'Arduino define up front:';
 Blockly.Msg.ARD_FUN_RUN_SETUP = 'Arduino run first:';
 Blockly.Msg.ARD_FUN_RUN_LOOP = 'Arduino loop forever:';
 Blockly.Msg.ARD_FUN_RUN_TIP = 'Defines the Arduino setup() and loop() functions.';
+Blockly.Msg.ARD_FUN_RUN_DECL_TIP = 'Code you want to declare up front (use this e.g. for variables you need in setup)';
 Blockly.Msg.ARD_PIN_WARN1 = 'Pin %1 is needed for %2 as pin %3. Already used as %4.';
 Blockly.Msg.ARD_SERIAL_SETUP = 'Setup';
 Blockly.Msg.ARD_SERIAL_SPEED = ':  speed to';
@@ -1153,6 +1157,12 @@ Blockly.Msg.ARD_SERVO_WRITE_DEG_180 = 'Degrees (0~180)';
 Blockly.Msg.ARD_SERVO_WRITE_TIP = 'Set a Servo to an specified angle';
 Blockly.Msg.ARD_SERVO_READ = 'read SERVO from PIN#';
 Blockly.Msg.ARD_SERVO_READ_TIP = 'Read a Servo angle';
+Blockly.Msg.ARD_SERVOHUB = 'Servo motor';
+Blockly.Msg.ARD_SERVO_DEFAULT_NAME = 'Servo1';
+Blockly.Msg.ARD_SERVO_TYPE = 'Type:';
+Blockly.Msg.ARD_180SERVO = '0~180 degree Servo (angle)';
+Blockly.Msg.ARD_360SERVO = '0~360 degree Servo (rotation)';
+Blockly.Msg.ARD_SERVOHUB_TIP = 'Servo Motor Connection, which can attach to a PWM pin. You have to give the servo a name, and what type it is (a 180 degree servo or a 360 degree servo.)';
 Blockly.Msg.ARD_SPI_SETUP = 'Setup';
 Blockly.Msg.ARD_SPI_SETUP_CONF = 'configuration:';
 Blockly.Msg.ARD_SPI_SETUP_SHIFT = 'data shift';
@@ -1172,8 +1182,9 @@ Blockly.Msg.ARD_SPI_TRANS_TIP = 'Send a SPI message to an specified slave device
 Blockly.Msg.ARD_SPI_TRANS_WARN1 = 'A setup block for %1 must be added to the workspace to use this block!';
 Blockly.Msg.ARD_SPI_TRANS_WARN2 = 'Old pin value %1 is no longer available.';
 Blockly.Msg.ARD_SPI_TRANSRETURN_TIP = 'Send a SPI message to an specified slave device and get data back.';
-Blockly.Msg.ARD_STEPPER_SETUP = 'Setup';
-Blockly.Msg.ARD_STEPPER_MOTOR = 'stepper motor:';
+Blockly.Msg.ARD_STEPPER_SETUP = 'Setup stepper motor';
+Blockly.Msg.ARD_STEPPER_MOTOR = '';
+Blockly.Msg.ARD_STEPPER_DEFAULT_NAME = 'MyStepper';
 Blockly.Msg.ARD_STEPPER_PIN1 = 'pin1#';
 Blockly.Msg.ARD_STEPPER_PIN2 = 'pin2#';
 Blockly.Msg.ARD_STEPPER_REVOLVS = 'how many steps per revolution';
@@ -1182,9 +1193,15 @@ Blockly.Msg.ARD_STEPPER_SETUP_TIP = 'Configures a stepper motor pinout and other
 Blockly.Msg.ARD_STEPPER_STEP = 'move stepper';
 Blockly.Msg.ARD_STEPPER_STEPS = 'steps';
 Blockly.Msg.ARD_STEPPER_STEP_TIP = 'Turns the stepper motor a specific number of steps.';
-Blockly.Msg.ARD_STEPPER_STEP_WARN1 = 'A STEPPER configuration block must be added to use this block!';
-Blockly.Msg.ARD_STEPPER_STEP_WARN2 = 'A Name input must be added to the Stepper configuration block!';
-Blockly.Msg.ARD_STEPPER_STEP_WARN3 = 'Selected stepper does not exist any more, please select a new one.';
+Blockly.Msg.ARD_STEPPER_COMPONENT = 'stepper';
+Blockly.Msg.ARD_SERVO_COMPONENT = 'servo';
+Blockly.Msg.ARD_SERVO_ROTATE360 = 'Rotate 360 degree Servo';
+Blockly.Msg.ARD_SERVO_ROTATESPEED = 'with speed';
+Blockly.Msg.ARD_SERVO_ROTATEPERC = '% (-100 to 100)';
+Blockly.Msg.ARD_SERVO_ROTATE_TIP = 'Turn a Servo with a specific speed';
+Blockly.Msg.ARD_SERVOHUB_WRITE = 'set 180 degree Servo ';
+Blockly.Msg.ARD_SERVOHUB_READ = 'read Servo ';
+Blockly.Msg.ARD_COMPONENT_WARN1 = 'A %1 configuration block with the same %1 name must be added to use this block!';
 Blockly.Msg.ARD_TIME_DELAY = 'wait';
 Blockly.Msg.ARD_TIME_MS = 'milliseconds';
 Blockly.Msg.ARD_TIME_DELAY_TIP = 'Wait specific time in milliseconds';
@@ -1200,6 +1217,48 @@ Blockly.Msg.ARD_VAR_AS = 'as';
 Blockly.Msg.ARD_VAR_AS_TIP = 'Sets a value to a specific type';
 Blockly.Msg.REPLACE_EXISTING_BLOCKS = 'Replace existing blocks? "Cancel" will merge.';
 
+//Arduino blocks define as a specific type
+Blockly.Msg.ARD_AS_BOOL_NUMBER = 'as boolean';
+//Arduino blocks define as a specific type
+Blockly.Msg.ARD_AS_INTEGER_NUMBER = 'as integer number';
+//Arduino blocks define as a specific type
+Blockly.Msg.ARD_AS_UINT_NUMBER = 'as positive integer number';
+//Arduino blocks define as a specific type
+Blockly.Msg.ARD_AS_LONG_NUMBER = 'as long integer number';
+//Arduino blocks define as a specific type
+Blockly.Msg.ARD_AS_ULONG_NUMBER = 'as long positive integer number';
+//Arduino blocks define as a specific type
+Blockly.Msg.ARD_AS_FLOAT_NUMBER = 'as decimal number';
+Blockly.Msg.ARD_AS_BOOL_NUMBER_TIP = 'Declare a variable as boolean with value true or false';
+//Arduino blocks define as a specific type tip
+Blockly.Msg.ARD_AS_INTEGER_NUMBER_TIP = 'Declare a variable as integer, -32768 to 32767';
+//Arduino blocks define as a specific type tip
+Blockly.Msg.ARD_AS_UINT_NUMBER_TIP = 'Declare a variable as a positive integer, 0 to 65535';
+//Arduino blocks define as a specific type tip
+Blockly.Msg.ARD_AS_LONG_NUMBER_TIP = 'Declare a variable as a long integer, -2,147,483,648 to 2,147,483,647';
+//Arduino blocks define as a specific type tip
+Blockly.Msg.ARD_AS_ULONG_NUMBER_TIP = 'Declare a variable as a long positive integer, 0 to 4,294,967,295';
+//Arduino blocks define as a specific type tip
+Blockly.Msg.ARD_AS_FLOAT_NUMBER_TIP = 'Declare a variable as a decimal number, eg 3.6 or 5e4 or -3.14';
+
+Blockly.Msg.ARD_AS_DIGINPUT_PIN = 'as digital input';
+Blockly.Msg.ARD_AS_DIGINPUT_PIN_TIP = 'Declare a variable as a digital input pin';
+Blockly.Msg.ARD_AS_DIGOUTPUT_PIN = 'as digital output';
+Blockly.Msg.ARD_AS_DIGOUTPUT_PIN_TIP = 'Declare a variable as a digital output pin';
+Blockly.Msg.ARD_AS_ANAINPUT_PIN = 'as analog input';
+Blockly.Msg.ARD_AS_ANAINPUT_PIN_TIP = 'Declare a variable as a analog input pin';
+Blockly.Msg.ARD_AS_ANAOUTPUT_PIN = 'as analg output';
+Blockly.Msg.ARD_AS_ANAOUTPUT_PIN_TIP = 'Declare a variable as a analog PWM output pin';
+
+
+Blockly.Msg.ARD_DIGITALWRITEVAR_TIP = 'Write digital value to a Port, the value and port can be computed variables';
+
+Blockly.Msg.ARD_PIN_AN = 'analog pin';
+Blockly.Msg.ARD_PIN_DIG = 'digital pin';
+Blockly.Msg.ARD_PIN_PWM = 'PWM pin';
+Blockly.Msg.ARD_PIN_AN_TIP = 'One of the analog pins of the Arduino Board';
+Blockly.Msg.ARD_PIN_DIG_TIP = 'One of the digital pins of the Arduino Board';
+Blockly.Msg.ARD_PIN_PWM_TIP = 'One of the Pulse Width Modeling (PWM) pins of the Arduino Board';
 Blockly.Msg.ARD_PULSEREAD = 'Read';
 Blockly.Msg.ARD_PULSEON = 'pulse on pin #';
 Blockly.Msg.ARD_PULSETIMEOUT = 'timeout after';
@@ -1212,3 +1271,88 @@ Blockly.Msg.ARD_TONE_TIP = 'Sets tone on pin to specified frequency within range
 Blockly.Msg.ARD_TONE_WARNING = 'Frequency must be in range 31 - 65535';
 Blockly.Msg.ARD_NOTONE = 'Turn off tone on pin #';
 Blockly.Msg.ARD_NOTONE_TIP = 'Turns the tone off on the selected pin';
+
+Blockly.Msg.ARD_LEDLEG_COMPONENT = 'LED';
+Blockly.Msg.ARD_LEDLEG_DEFAULT_NAME = 'Led1';
+Blockly.Msg.ARD_LEDLEG = 'LED';
+Blockly.Msg.ARD_LEDLEGPOL = 'leg polarity';
+Blockly.Msg.ARD_LEDLEGPOS = 'plus';
+Blockly.Msg.ARD_LEDLEGNEG = 'minus';
+Blockly.Msg.ARD_LEDLEG_TIP = 'A LED light, on of the legs (the positive or negative) is connected to the Arduino. Can be ON or OFF.';
+Blockly.Msg.ARD_LEDLEG_SET = 'Set LED';
+Blockly.Msg.ARD_LEDLEG_ON = 'ON';
+Blockly.Msg.ARD_LEDLEG_OFF = 'OFF';
+Blockly.Msg.ARD_NEOPIXEL = 'NeoPixel LED light';
+Blockly.Msg.ARD_NEOPIXEL_STRIP = 'Strip with';
+Blockly.Msg.ARD_NEOPIXEL_PIXELS = 'Pixels.';
+Blockly.Msg.ARD_NEOPIXEL_HZ = 'Frequency:';
+Blockly.Msg.ARD_NEOPIXEL_TYPE = 'Type:';
+Blockly.Msg.ARD_NEOPIXEL_TIP = 'A NEOPIXEL LED light or a strip with multiple neopixels.';
+Blockly.Msg.ARD_NEOPIXEL_SET = 'Set Neopixel';
+Blockly.Msg.ARD_NEOPIXEL_PIXEL = 'pixel';
+Blockly.Msg.ARD_NEOPIXEL_ONCOLOUR = 'on colour';
+Blockly.Msg.ARD_NEOPIXEL_BRIGHTNESS = ' brightness (%)';
+Blockly.Msg.ARD_NEOPIXEL_ONCOLOURVALRED = 'on colour (0-255) red:';
+Blockly.Msg.ARD_NEOPIXEL_ONCOLOURVALGREEN = 'green:';
+Blockly.Msg.ARD_NEOPIXEL_ONCOLOURVALBLUE = 'blue:';
+Blockly.Msg.ARD_NEOPIXEL_COMPONENT = 'Neopixel strip';
+Blockly.Msg.ARD_NEOPIXEL_DEFAULT_NAME = 'NeoPixel1';
+Blockly.Msg.ARD_BLOCKS = 'You have this block twice on the canvas. That is once too many!';
+Blockly.Msg.ARD_BUTTON_COMPONENT = 'Push Button';
+Blockly.Msg.ARD_BUTTON_DEFAULT_NAME = 'PushButton1';
+Blockly.Msg.ARD_BUTTON_IFPUSHED = 'If pushed we measure value';
+Blockly.Msg.ARD_BUTTON_TIP = 'Een drukknop die AAN of UIT kan zijn';
+Blockly.Msg.ARD_BUTTON_READ = 'Read value button';
+Blockly.Msg.ARD_BUTTON_INPUT_IF = 'If button';
+Blockly.Msg.ARD_BUTTON_INPUT_CLICK = ' is clicked';
+Blockly.Msg.ARD_BUTTON_INPUT_THEN = 'do';
+Blockly.Msg.ARD_BUTTON_INPUT_LONGCLICK = 'is undergoing a long click';
+Blockly.Msg.ARD_BUTTON_INPUT_PRESSED = 'is being pressed';
+Blockly.Msg.ARD_BUTTON_INPUT_WAIT = 'wait for a click to happen';
+Blockly.Msg.ARD_BUTTON_INPUT_TIP = 'Check the input received on a button, and react to it. This function does not block your program if you do not check the checkbox to wait for a click. A click is a press and a release of the button, a long press a click and holding long time before you release, press is active as soon as the button is pressed down.';
+Blockly.Msg.ARD_ANASENSOR = 'Analog Sensor';
+Blockly.Msg.ARD_ANASENSOR_TIP = 'Connect an analog sensor to an analog pin, so as to read its value. On an Arduino UNO a value between 0 and 1024 is returned, corresponding to a measured value between 0 and 5V. Eg.: an LDR sensor, a potmeter, ...';
+Blockly.Msg.ARD_ANASENSOR_DEFAULT_NAME = 'AnaSensor1';
+Blockly.Msg.ARD_ANASENSOR_READ = 'Read analog sensor';
+Blockly.Msg.ARD_ANASENSOR_COMPONENT = 'Analog Sensor';
+Blockly.Msg.ARD_DIGINPUT = 'Digital input';
+Blockly.Msg.ARD_DIGINPUT_TIP = 'Connect a digital input to a digital pin, so as to read its value. The digital state can then be read, corresponding to 0V or 5V on the pin for an Arduino UNO.';
+Blockly.Msg.ARD_DIGINPUT_DEFAULT_NAME = 'DigInput1';
+Blockly.Msg.ARD_DIGINPUT_READ = 'Read digital input';
+Blockly.Msg.ARD_DIGINPUT_COMPONENT = 'Digital Input';
+Blockly.Msg.ARD_DIGOUTPUT = 'Digital output';
+Blockly.Msg.ARD_DIGOUTPUT_TIP = 'Connect a generic digital ouput to a digital pin, so as to write to that pin. The digital state can be set to LOW or HIGH, corresponding to 0V and 5V on the pin for an Arduino UNO.';
+Blockly.Msg.ARD_DIGOUTPUT_DEFAULT_NAME = 'DigOutput1';
+Blockly.Msg.ARD_DIGOUTPUT_WRITE = 'Write to digital output';
+Blockly.Msg.ARD_DIGOUTPUT_COMPONENT = 'Digital Output';
+Blockly.Msg.ARD_PWMOUTPUT = 'PWM output';
+Blockly.Msg.ARD_PWMOUTPUT_TIP = 'Connect a generic PWM (Pulse Width Modulation) ouput to a pwm pin, so as to write an analog value to that pin. The value written should be a number between 0 and 255, and will generate a block pulse over this pin.';
+Blockly.Msg.ARD_PWMOUTPUT_DEFAULT_NAME = 'PWMOutput1';
+Blockly.Msg.ARD_PWMOUTPUT_WRITE = 'Write to PWM output';
+Blockly.Msg.ARD_PWMOUTPUT_COMPONENT = 'PWM Output';
+Blockly.Msg.ARD_OUTPUT_WRITE_TO = 'value';
+
+//effect block
+Blockly.Msg.ARD_CONTROLS_EFFECT_TOOLTIP_1 = 'At the start of an effect, do some statements';
+Blockly.Msg.ARD_CONTROLS_EFFECT_TOOLTIP_2 = 'At the start of an effect, do some statements, and at the end of the effect too';
+Blockly.Msg.ARD_CONTROLS_EFFECT_TOOLTIP_3 = 'At the start of an effect, do some statements, if the effect time becomes larger than the given time, do the next statements.';
+Blockly.Msg.ARD_CONTROLS_EFFECT_TOOLTIP_4 = 'At the start of an effect, do some statements, if the effect time becomes larger than the given time, do the next statements. Ath end of the effect the final statements are done.';
+Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_FIRST1 = 'Effect';
+Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_FIRST2 = 'with total duration (ms) =';
+Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_IF = 'at the start do';
+Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_ELSEIF = 'if effect time becomes greater than';
+Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_ELSE = 'at the end do';
+Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_THEN = Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;
+Blockly.Msg.ARD_CONTROLS_EFFECT_IF_TITLE_IF = Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_IF;
+Blockly.Msg.ARD_CONTROLS_EFFECT_IF_TOOLTIP = Blockly.Msg.CONTROLS_IF_IF_TOOLTIP;
+Blockly.Msg.ARD_CONTROLS_EFFECT_ELSEIF_TITLE_ELSEIF = Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_ELSEIF;
+Blockly.Msg.ARD_CONTROLS_EFFECT_ELSEIF_TOOLTIP = 'Add an extra effect time at which statements must be done';
+Blockly.Msg.ARD_CONTROLS_EFFECT_ELSE_TITLE_ELSE = Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_ELSE;
+Blockly.Msg.ARD_CONTROLS_EFFECT_ELSE_TOOLTIP = 'Add a block for statements when the effect is finished.';
+Blockly.Msg.ARD_COMPONENT_BOARD = 'a specific Arduino Board';
+Blockly.Msg.ARD_COMPONENT_BOARD_TIP = 'Set which Arduino board you work with, and connect components to the pins.';
+Blockly.Msg.ARD_COMPONENT_BOARD_HUB_TIP = 'Set the Arduino board you work with, and to what it connects';
+Blockly.Msg.ARD_PIN_DIGDIG = 'digital pin1 and pin2';
+Blockly.Msg.ARD_PIN_DIGDIG_TIP = 'Component requiring two digital pins, pin1 and pin2';
+Blockly.Msg.ARD_PIN_DIGDIG1 = 'digital pin1#';
+Blockly.Msg.ARD_PIN_DIGDIG2 = 'pin2#';