OCTOPUS

The OCTOPUS IoT Badge limited developer edition – getting started:

First congratulations to your all-in-one education and innovation kit for your
Internet of Things #IoT applications!

The kit is based in its core around the famous ESP8266 (SoC) from Esperiff
and uses the latest ESP8266-12F module. More details you can find while
checking the schematic. As the hardware is open – we like you to have a look
into details, and make your modifications while referencing to the www.fab-lab.eu
source. If your like the boards and need any custom design e.g. your company/
lab/organization logo … or a different PCB color – please let us know!

Please be aware this kit is for education and  lab use only. As it is made
by Maker for Maker please let us know about any add ons or improvements
you might find out. The section below might include external links which we
are not maintaining nor are responsible for. Code samples are as they are, might
include third party work and resources.

(why to we need all these disclosures!?!? anyway we trust you that you are not going to
burn your fingers!)
– Now let’s get it running!

Frist you do need to decide what power source you might want to use:

a. ready-to-run: USB and an external 3xAAA or 3xAA battery pack, no modification needed
    -> just start, have fun! There might be code already on the board if the right NeoPixel is green,
    you are lucky, breath on to the sensor (BME280) and it will detect high humidity! Make sure
    you got the USB driver and Arduino IDE running:
https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/using-arduino-ide
http://www.silabs.com/products/mcu/pages/usbtouartbridgevcpdrivers.aspx

b. professionals only: LiPo with charging via USB or solar panel
c. professionals only: use only 2xAAA batteries on the board, this is a hack!

Options b. and c. are requiring modifications and can NOT be used in
parallel, nevertheless you might change during the time and reverse
the modifications.

Safety note: if you are going to use a LiPo please make sure you understand
the safety instructions handling LiPo batteries,
 specially while charing always
keep an eye on it, don’t short cut or overheat
 LiPo batteries. Work on your own risk!
We suggest only Pros to be using the LiPo
 option.

When completed you are ready to run the OCTOPUS. Plug it to your computers
USB port – the port is protected by an fuse max. 500mA and a reverse power diode.
If you are using the 2xAAA hack – there is no reverse power protection – the USB
power is not used, so make sure you always follow the printed battery orientation
while insertion the batteries.

Now have fun!

All you do need to deploy your first application, follow these great tutorials – and
if you like them consider Adafruit as a source for your supplies too! (we love them)

https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/overview
https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/using-arduino-ide
https://learn.adafruit.com/adafruit-oled-featherwing/overview
https://learn.adafruit.com/adafruit-15×7-7×15-charlieplex-led-matrix-charliewing-featherwing
https://learn.adafruit.com/adafruit-neopixel-featherwing/overview
https://learn.adafruit.com/adafruit-neopixel-uberguide/overview
https://learn.adafruit.com/adafruit-bme280-humidity-barometric-pressure-temperature-sensor-breakout/wiring-and-test

MacOS might not recognize the USB/UART driver CP210x you can manually install:
http://www.silabs.com/products/mcu/pages/usbtouartbridgevcpdrivers.aspx

Our list of tested add on components:

Useful parts:
https://www.adafruit.com/products/2975
https://www.adafruit.com/products/2884 (breakout)
https://www.adafruit.com/products/790 (GPS, requires virtual serial for ESP8266!)

https://www.adafruit.com/products/2940 (using the short header for a slim design)
https://www.adafruit.com/products/3002 (using the short header for a slim design)

Displays:
https://www.adafruit.com/products/2965 (LED Matrix Display)
https://www.adafruit.com/products/2900 (OLED)
https://www.adafruit.com/products/2945 (NeoPixel Matrix, read modification for ESP8266,
found here: https://learn.adafruit.com/adafruit-neopixel-featherwing/pinouts #16 pin!)
https://www.adafruit.com/products/3108 (7-Segment, for a watch face or digital multi meter)
https://www.adafruit.com/products/3130 (Alpha-Segment)
https://www.adafruit.com/products/3315 (TFT / Touch)

Controls:
https://www.adafruit.com/products/2928 (PWM 8x)
https://www.adafruit.com/products/2927 (Motor 4x / Stepper 2x)

https://www.adafruit.com/products/3231 (LoRa)

SeeedStudio Grove:
AirQuality, Dust Sensor, Speech Recognizer (virtual serial!), … most analog or I2C sensor with
support for 3V (!)

FAQ:

  • using NeoPixel with RGBW support, that means there is a true „white“,
    make sure you are setting RGBW when initializing it (see adafruit NeoPixel Uberguide)
  • you can run NeoPixel (as we do on the PCB) with 3.3V, even it is out of spec it
    works, if you add external stripes make sure you monitor the current(!) – THIS is
    a hack but works only limit we do see is the strength of the blue LED (as it forward
    voltage is close to 3V)

 

a. Ready-to-run setup – USB power and external Batterie support (e.g. 3xAA, 3xAAA)

img_1658

Parts you got with the kit

img_1679

Solder Rotary Encoder

img_1684

Solder Headers – we recommend the short headers, for a flat design

img_1694

Solder Groove Headers

img_1692

b. Enable LiPo Option: Please be sure you understand how to safely Charge LiPos (see tutorials of Sparkfun or Adafruit). Never leave the unit unattended during charging. Use only LiPos with build in protection circuit (current, voltage). Based on the current configuration use at least a capacity of >=350mAh. See schematics for details. Tip: you can attach a slider switch S1 to switch of the LiPo: before remove R22 and D2

img_1672

Solder 2-pin JST (SMD) not included in the kit (polarity is marked with a „+“ on the PCB)

img_1673

Close this solder jumper – enabling charging (if you are lucky there is a Zero-Ohm resistor in the kit,
otherwise just use a short wire to bridge the two pads)

img_1686

If you do want to charge the LiPo via a solar panel you can use a micro USB plug to connect to your solar panel (<=6V max!), here is what we tested with:
https://www.adafruit.com/product/1390 (Micro USB shell)
http://www.exp-tech.de/seeed-studio-0-5w-solar-panel (smallest, use larger if needed)

more details on solar power and ESP8266 tuning on here:
https://www.hackster.io/fablabeu/esp8266-thing-by-sparkfun-982bc6

Tip: there are couple of traces on the PCB that you can cut to reduce over all power consumption (NeoPixel, USB/UART bridge), with that you can get down to 20uA sleep current (see also deep-
sleep code)

c. Batterie only option – this is a hack just feeding power from 2xAAA batteries, no LiPo no USB power

img_1702

Close this solder jumper (left)

img_1705

Cut this trace (right)

img_1707

Mount battery holder clips – not soldering needed ! – yes and we us NiMH rechargeable AAA with a 1.2V level, they are working great (on your own risk as out of spec, but as said it is a nice hack!)

img_1716

Attention in this hack there is NO reverse polarity check,
make sure you insert the batteries right way!

d. adding GPS module for trace and trace applications:

It is simple just need the Adafruit ultimate GPS a listed in the parts section,
will add picture with orientation soon!

 

More resources:

Btw there is a hackathon, which is going to use OCTOPUS with some more instructions on coding and Arduino(TM) IDE examples:

Your first example, using the BME280 and NeoPixel to detect humidity!

#define PIN 13 //NeoPixl

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME280 bme; // I2C
Adafruit_NeoPixel strip = Adafruit_NeoPixel(1, PIN, NEO_GRB + NEO_KHZ800);


// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}

void setup() {
  Serial.begin(9600);

  strip.begin();
  strip.show(); // Initialize all pixels to 'off'

  delay(1000);
  
  Serial.println(F("BME280 test"));
  if (!bme.begin()) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }

  delay(1000);
  
}

void loop() {
  
    Serial.print("Temperature = ");
    Serial.print(bme.readTemperature());
    Serial.println(" *C");

    Serial.print("Pressure = ");

    Serial.print(bme.readPressure() / 100.0F);
    Serial.println(" hPa");

    Serial.print("Approx. Altitude = ");
    Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
    Serial.println(" m");

    Serial.print("Humidity = ");
    Serial.print(bme.readHumidity());
    Serial.println(" %");

  if (bme.readHumidity() < 30) { colorWipe(strip.Color(255, 0, 0), 50); // Red} } if (bme.readHumidity() > 30 && bme.readHumidity() < 50) { colorWipe(strip.Color(0, 255, 0), 50); // Red} } if (bme.readHumidity() > 50) {
    colorWipe(strip.Color(0, 0, 255), 50); // Green}
  }

    Serial.println();
}

A more advanced sample using the Wifi connect and talking to the Blynk App!


#define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <Adafruit_NeoPixel.h>
#include <SimpleTimer.h>

#include <stdint.h>
#include "SparkFunBME280.h"
//Library allows either I2C or SPI, so include both.
#include "Wire.h"
#include "SPI.h"

//Global sensor object
BME280 mySensor;

SimpleTimer timer;

////////////////////
// Blynk Settings //
////////////////////
char BlynkAuth[] = "YOURBLYNKKEY";
char WiFiNetwork[] = "YOURSSID";
char WiFiPassword[] = "YOURPWD";

///////////////////////
// Hardware Settings //
///////////////////////
#define WS2812_PIN 13 // Pin connected to WS2812 LED
#define BUTTON_PIN 0
#define LED_PIN    0
Adafruit_NeoPixel rgb = Adafruit_NeoPixel(1, WS2812_PIN, NEO_GRB + NEO_KHZ800);

BLYNK_WRITE(V0) // Handle RGB from the zeRGBa
{
  if (param.getLength() < 5)
    return;

  byte red = param[0].asInt();
  byte green = param[1].asInt();
  byte blue = param[2].asInt();

  uint32_t rgbColor = rgb.Color(red, green, blue);
  rgb.setPixelColor(0, rgbColor);
  rgb.show();
}

// This function sends Arduino's up time every second to Virtual Pin (5).
// In the app, Widget's reading frequency should be set to PUSH. This means
// that you define how often to send data to Blynk App.
void myTimerEvent()
{
  // You can send any value at any time.
  // Please don't send more that 10 values per second.
  Blynk.virtualWrite(V5, mySensor.readTempC());
}

void setup()
{
  // Initialize hardware
  Serial.begin(9600); // Serial
  rgb.begin(); // RGB LED
  pinMode(BUTTON_PIN, INPUT); // Button input
  pinMode(LED_PIN, OUTPUT); // LED output

  // Initialize Blynk
  Blynk.begin(BlynkAuth, WiFiNetwork, WiFiPassword);

  // Setup a function to be called every second
  timer.setInterval(1000L, myTimerEvent);

  //***Driver settings********************************//
  mySensor.settings.commInterface = I2C_MODE;
  mySensor.settings.I2CAddress = 0x77;
  mySensor.settings.runMode = 3; //Normal mode
  mySensor.settings.tStandby = 0;
  mySensor.settings.filter = 0;
  mySensor.settings.tempOverSample = 1;
  mySensor.settings.pressOverSample = 1;
  mySensor.settings.humidOverSample = 1;
  
  Serial.print("Program Started\n");
  Serial.print("Starting BME280... result of .begin(): 0x");
  
  //Calling .begin() causes the settings to be loaded
  delay(10);  //Make sure sensor had enough time to turn on. BME280 requires 2ms to start up.
  Serial.println(mySensor.begin(), HEX);

  Serial.print("Displaying ID, reset and ctrl regs\n");
  
  Serial.print("ID(0xD0): 0x");
  Serial.println(mySensor.readRegister(BME280_CHIP_ID_REG), HEX);
  Serial.print("Reset register(0xE0): 0x");
  Serial.println(mySensor.readRegister(BME280_RST_REG), HEX);
  Serial.print("ctrl_meas(0xF4): 0x");
  Serial.println(mySensor.readRegister(BME280_CTRL_MEAS_REG), HEX);
  Serial.print("ctrl_hum(0xF2): 0x");
  Serial.println(mySensor.readRegister(BME280_CTRL_HUMIDITY_REG), HEX);
}

void loop()
{
  // Execute Blynk.run() as often as possible during the loop
  Blynk.run();
  timer.run(); // Initiates SimpleTimer 
}

If you want to become even more advanced look into sleep mode, specially interesting when running on batteries or solar power. Also this one is important when you are running on LiPo and want to charge it fully, give headroom during sleep.

unsigned int deepSleepSeconds = 30;      // Number of seconds for the ESP8266 chip to deepsleep for.  GPIO16 needs to be tied to RST to wake from deepSleep http://esp8266.github.io/Arduino/versions/2.0.0/doc/libraries.html
void setup() {
pinMode(0, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
delay(1000);              // wait for a second
digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
delay(1000);              // wait for a second
ESP.deepSleep(1000000 * deepSleepSeconds, WAKE_RF_DEFAULT); // GPIO16 needs to be tied to RST to wake from deepSleep. Execute restarts from beginning of sketch
}

Here is an example with the Adafruit 7-Segment FeatherWing, and NTP -> Building a clock!

#include <SPI.h>                              // SPI interface API
#include <Wire.h>                             // Wire support library
#include <ESP8266WiFi.h>
#include "Adafruit_LEDBackpack.h"             // Support for the LED Backpack FeatherWing
#include "Adafruit_GFX.h"                     // Adafruit's graphics library
#include <WiFiUdp.h>

//###############################################################################
// Globals
//###############################################################################

char ssid[] = "YOURSSID";
char pass[] = "YOURPWD";

#define TIME_24_HOUR    true
#define DISPLAY_ADDRESS 0x70

// Create display object
Adafruit_7segment clockDisplay = Adafruit_7segment();

int hours = 0;                      // Track hours
int minutes = 0;                    // Track minutes
int seconds = 0;                    // Track seconds
int tzOffset = +1;                  // Time zone offset

bool blinkColon = false;            // Track the status of the colon to blink every second

unsigned int localPort = 2390;      // Local port to listen for UDP packets
IPAddress timeServer(129,6,15,28);  // time.nist.gov NTP server
const int NTP_PACKET_SIZE = 48;     // NTP time stamp is in the first 48 bytes
byte packetBuffer[NTP_PACKET_SIZE]; // Buffer for incoming and outgoing UDP packets

WiFiUDP EthernetUdp;

//###############################################################################
// Functions
//###############################################################################


// send an NTP request to the time server at the given address
unsigned long sendNTPpacket(IPAddress& address)
{
  //Serial.println("1");
  // set all bytes in the buffer to 0
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialize values needed to form NTP request
  // (see URL above for details on the packets)
  //Serial.println("2");
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12]  = 49;
  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;

  //Serial.println("3");

  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp:
  EthernetUdp.beginPacket(address, 123); //NTP requests are to port 123
  //Serial.println("4");
  EthernetUdp.write(packetBuffer, NTP_PACKET_SIZE);
  //Serial.println("5");
  EthernetUdp.endPacket();
  //Serial.println("6");
}

void setup() {

  Serial.begin(115200);                           // Start the serial console
  Serial.println("Clock starting!");              // Start the clock message.

  // Set up the display.
  clockDisplay.begin(DISPLAY_ADDRESS);
    clockDisplay.writeDisplay();

  WiFi.mode(WIFI_STA);

  // Attempt to conect to the WiFi network.
  Serial.println("Connecting to WiFi netowrk.");
  while (WiFi.status() != WL_CONNECTED) {
    WiFi.begin(ssid, pass);              // Connect to WPA2 network
    uint8_t timeout = 10;                         // Set a timeout variable
    while (timeout && (WiFi.status() != WL_CONNECTED)) {
      timeout--;                                  // Decrement timeout
      delay(1000);                                // Delay for one second
    }
  }

  Serial.println("Connected to network.");

  EthernetUdp.begin(localPort);                           // Open the UDP port for comms
}

//###############################################################################
// Loop - main
//###############################################################################

// This is one of the two standard functions for every Arduino program, with the
// other being setup(). This one runs continuously, forever, and executes the
// Arduino program code.

void loop() {
  // Refresh the time at the top of every hour, or every five minutes because
  // the clock drift on the bare Feather M0 is pretty wicked.
  if ((minutes == 0) || ((minutes % 5) == 0)) {
    sendNTPpacket(timeServer); // send an NTP packet to a time server
   // wait to see if a reply is available
   delay(1000);
   if ( EthernetUdp.parsePacket() ) {
     Serial.println("packet received");
     // We've received a packet, read the data from it
    EthernetUdp.read(packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer

     //the timestamp starts at byte 40 of the received packet and is four bytes,
     // or two words, long. First, esxtract the two words:

     unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
     unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
     // combine the four bytes (two words) into a long integer
     // this is NTP time (seconds since Jan 1 1900):
     unsigned long secsSince1900 = highWord << 16 | lowWord;
     Serial.print("Seconds since Jan 1 1900 = " );
     Serial.println(secsSince1900);

          // now convert NTP time into everyday time:
     Serial.print("Unix time = ");
     // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
     const unsigned long seventyYears = 2208988800UL;
     // subtract seventy years:
     unsigned long epoch = secsSince1900 - seventyYears;
     // print Unix time:
     Serial.println(epoch);

     // print the hour, minute and second:
     Serial.print("The UTC time is ");       // UTC is the time at Greenwich Meridian (GMT)
     hours = ((epoch  % 86400L) / 3600);     // print the hour (86400 equals secs per day)
      hours += tzOffset;                     // Calculate the time zone offset
      if (hours < 0) { hours = 24 + hours; } if (hours > 23) {
        hours = hours - 23;
      }
     Serial.print(hours); // print the hour
     Serial.print(':');
     minutes = ((epoch % 3600) / 60);
     if (minutes < 10 ) {
       // In the first 10 minutes of each hour, we'll want a leading '0'
       Serial.print('0');
     }
     Serial.print(minutes);                 // print the minute (3600 equals secs per minute)
     Serial.print(':');
     seconds = (epoch % 60);               // print the second
     if ( seconds < 10 ) { // In the first 10 seconds of each minute, we'll want a leading '0' Serial.print('0'); } Serial.println(seconds); } } // Display the time int displayValue = hours*100 + minutes; if (!TIME_24_HOUR) { if (hours > 12) {
      displayValue -= 1200;
    }
    else if (hours == 0) {
      displayValue += 1200;
    }
  }

  // Print the time on the display
  clockDisplay.print(displayValue, DEC);

  // Add zero padding when in 24 hour mode and it's midnight.
  // In this case the print function above won't have leading 0's
  // which can look confusing.  Go in and explicitly add these zeros.
  if (TIME_24_HOUR && hours == 0) {
    // Pad hour 0.
    clockDisplay.writeDigitNum(1, 0);
    // Also pad when the 10's minute is 0 and should be padded.
    if (minutes < 10) { clockDisplay.writeDigitNum(2, 0); } } // Blink the colon by flipping its value every loop iteration // (which happens every second). blinkColon = !blinkColon; clockDisplay.drawColon(blinkColon); // Now push out to the display the new values that were set above. clockDisplay.writeDisplay(); // Pause for a second for time to elapse. This value is in milliseconds // so 1000 milliseconds = 1 second. delay(1000); // Now increase the seconds by one. seconds += 1; // If the seconds go above 59 then the minutes should increase and // the seconds should wrap back to 0. if (seconds > 59) {
    seconds = 0;
    minutes += 1;
    // Again if the minutes go above 59 then the hour should increase and
    // the minutes should wrap back to 0.
    if (minutes > 59) {
      minutes = 0;
      Serial.println("Minutes set to zero - should query NTP on next loop()");
      hours += 1;
      // Note that when the minutes are 0 (i.e. it's the top of a new hour)
      // then the start of the loop will read the actual time from NTP
      // again.  Just to be safe though we'll also increment the hour and wrap
      // back to 0 if it goes above 23 (i.e. past midnight).
      if (hours > 23) {
        hours = 0;
      }
    }
  }
}

kontur_octopus

If you want to pimp up the Octopus you can download a laster cut profile for a plexi housing!

Schematic for your reference. PCB can be found on oshpark.com (external)

16 commenti su “OCTOPUS
  1. Hallo Octopus-Team,

    kann ich den bestehenden „Neopixels-Strip aus zwei LEDs“ verlängern? Ansonsten ist der Neopixels-Anschluss, wenn ich es richtig sehe, wegen der 3,3V (Octopus/ESP8266) vs. 5V (Neopixels) nicht ganz trivial, oder?

    Vielen Dank, Philipp

    • FabLab sagt:

      … ganz einfach auf dem Grove (z.B. rechts) die 3.3V und GND anzapfen und an I/O (Kroko, Bananenbuchse) den IN der NeoPixel Kette anschliessen! funktioniert … der Hinweis: ist ausserhalb der Spezifikation der WS2812B und eigenes Risiko, verbraucht dabei (3.3V statt 5V) ziemlich wenig Strom 😉 trotzdem immer auch den Stromverbrauch achten, sonst ggfs extern 3.3V beisteuern, erstaunlich auch wie viele NeoPixel mit 2xAAA Batterien leuchten … Trade off bei 3.3V leuchtet die blaue LED naturgemäß nicht so kräftig!

  2. Martin SIpek sagt:

    Wie bekommt man es fertig bestückt??

  3. Jacek Jakubowski sagt:

    Hallo,

    ich habe mit Begeisterung im Make-Heft über den IoT.Octopus gelesen. Nun will ich für meinen Neffen (10J) ein Experimentierset zusamenstellen. Das Board habe ich bereits und ich kann es mit Arduino-IDE prgrammieren. Allerings würde ich meinem Neffen gerne die Scratch Programmierung mit Ardublocks anbieten. Finde aber niergendwo die ardublockIoT.jar. Ist jemandem hier die Quelle dafür bekannt? Ausserdem ist auch niergendwo ein Schaltplan aufzutreiben. Hätte das vielleicht jemand?

    Danke schon mal

  4. Elke sagt:

    Schade, alles in englisch.
    Ich bin auf der Suche für unsere Schule nach geeigneter Hardware für den leichten Einstieg in Programmierung, Elektronik, Digitalisierung. Lego Mindstorm, Arduino … oder könnte es der Octopus werden? Etwa ab Klasse 7 für interessierte Schüler.
    Mir ist klar, dass in der Informatik die Hauptsprache Englisch ist, insbesondere bei der Suche nach Informationen im Internet. Aber gerne würde ich den Schülern Material zum selbständigen Einlesen geben. Einige durchaus interessierte Schüler wären dann leider sicherlich abgeschreckt, wenn komplizierte Sachverhalte sofort nur in der Sprache Englisch präsentiert werden.
    Da in der neuen Make-Zeitschrift stand, in Deutschland entwickelt und produziert habe ich auch mehr deutschsprachige Unterstützung erhofft, gerade auch, weil im Artikel der Focus auf guter Ausbildung und Heranführung zum Thema und nicht der reine Kommerz stand. Der notwendige englischsprachige Hintergrund kommt dann von ganz alleine.
    Frage: Wird es von den deutschsprachigen Entwicklern auch deutschsprachige Anleitungen geben?
    Vielleicht habe ich sie auch nur noch nicht gefunden.
    Mit herzlichen Grüßen und ein schönes Jahr 2017

  5. Jens Stolze sagt:

    Moin moin, ich hätte auch Interesse, den Octopus im Unterricht einzusetzen. Für meine SchülerInnen bräuchte ich aber die Ardublockumgebung. Leider funktioniert der obige Link zum Download nicht richtig, bei 314 von 551 MB ist Schluss ;-( Könnten wir vielleicht einen Link nur auf die Datei ardublockIoT.jar bekommen, die ist ja nur einige MB groß.

    cu, Jens


    IoT2016Final.zip
    https://dl.dropboxusercontent.com/content_link/xxv4lMvwhzc7HlWIW0uosoyxDy7Z6PZ5sjePLzxF3reZaH9tQPtrtMCDeEVALug3/file?dl=1
    0 Byte/s – 314 MB von 551 MB

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *

*