Perhaps because of resources crisis that we live, finally, a growing awareness about the materials is rising.  

 In my opinion, there are three kinds of considerations we can do when talking about fair trade and, in general, when we talk of components built or including what we usually call “rare earths”.

Conflicts

The first consideration is related to the conflicts that often take place in areas from which these materials are extracted: this issue has been known for a long time already and we’re doing something already.

Few days ago, while interviewing Limor Fried (you can read the interview here), she told us:

“It’s already happening (fairer electronics), while I can’t speak for other companies, at Adafruit we are trying. It’s certainly true that right now most electronics contain metals that could come from a conflict-area. Unfortunately there is no way to know whether the components you are purchasing contain conflict-metals. For that reason, we try to avoid using tantalum capacitors and use ceramics when possible instead. It would be great if components were rated not only for RoHS-compliance but also conflict-avoidance.”

This gives a glimpse of how, *fairness* certifications – a bit like the ones we have already become accustomed to see on coffee, spices, or on many other products – may soon b featured for resistors, capacitors and allow companies to create supply chains in a more conscientious manner.

And if we think that conflicts could just be relegated to small and forgotten corners of Africa, and that we can close our eyes on them as we did for many other conflicts that have bloodied the African continent – for diamonds, oil and everything else – maybe this time we’re wrong.

China, a more and more global superpower in strong development phase, with increasing domestic needs, has a monopoly or certain, many of these “rare earths”. What will happen when we need those materials? What will be the conditions of the agreement? That’s why many are looking for new ways to identify new mining fields – even if underwater – like the Telegraph reported days ago.

Obviously, what individual companies can do remains little: Adafruit for example, is for now still a small company with limited production, and much of its value added is in education and community. It’s certainly more difficult to see this approach applied in large-scale manufacturing industries where thanks to large productions and an approach that is thirsty for profit, each penny counts.

Few positive sign, however, it also sees in this sense.

Labour

Days ago, a post on the Silicon Valley Watcher talked about HP moving towards electronic supplies that are more fair. In particular the article and HP announcement were referring to another key aspect: fair work and respect for workers.

In fact, it’s not only those living in military conflict areas in Africa that suffer inhumane working conditions: it’s been often reported in Shenzhen FoxConn factories and everybody knows that China is not a champion in respecting working rights.

An interesting passage of the piece on SVW, shows how, in essence,

HP’s rules will be difficult to monitor or enforce. However, all journeys begin with a small step and the eventual outcome will be a type of “Fair Trade” standard for electronics products.

The eventual rise of unions and living standards in China and other countries will also help tackle the problem of young workers being exploited, and unsustainable working conditions in factories.

Any rise in labor costs due to better working conditions, would likely be minimal and partly offset by the continuing decline in prices for chips and other electronic components.

Showing how, in reality, an investment effort towards more *fairness* would be just a small drop in the ocean of profits that consumer electronics companies still manage to take home.

Apple itself has been recently reported evaluating an attempt to force its suppliers to meet higher safety standards.

The Cupertino giant is considering the idea to bring home some parts of the manufacturing process of its products. This option would certainly mean a lot and would discourage price competition to the detriment of the labor rights. On the other hand, Chinese unions show better results every day, in recent years, and in tandem with the economic growth – wages are rising in the East, making it less interesting – the practices of extreme reduction of product costs through offshoring make less sense each day.

Reset production and sourcing of resources on a local basis – moving it again closer to design and consumption – is a very hopeful idea that is finally gaining a bit of visibility and that brings us to another major theme of the Fair Trade Electronics. Well, the impact on the environment.

Sustainability

Sustainability is another central point indeed, not only the resources and materials “themselves” can be scarce and under depletion, but the processes used to access, extract and market them can have a huge carbon footprint.

See this nice video I saw months ago, in May 2012: it’s by my friend Morgan, founder of http://fairtradeelectronic.org/

Very agreeable. But luckily the coming months made ​​me realize that something is moving:

The future

With an even greater ambition in fact, a few months ago, following a spectacular ted talk:

http://www.ted.com/talks/bandi_mbubi_demand_a_fair_trade_cell_phone.html

A team of dreamers created the Fair Phone project with the aim of creating a Phone that is fair in all its building process. The team actually documented the whole process on this beautiful blog that I suggest you follow http://www.fairphone.com/blog/ and is now preparing to enter the final stages of production, which will end up with few thousand pieces (halfway between industrial production and a DIY for now).

To prove that, already today, a Fair Phone is possible, could be a major step forward.

In case you lost it, Autodesk announced they’ve signed a deal to acquire Tinkercad and revive the popular web-based 3D design tool and its growing community of makers and educators.

via MAKE | Tinkercad is Back! Autodesk is Buying It.

MakerCase is a website where you can generate files for laser cut boxes and cases.

Pretty cool!

MakerCase – Easy Laser Cut Case Design.

Some months ago we came across the RGB Shield from Open Electronics and our first thought was to use it building some cool stuff with our framework, Souliss.

The future of lights goes through LEDs because compared to standard lights they’re tiny, easy to control and consume low power. But what we were missing until now was a powerful yet straightforward hardware controller for everyone willing to use LEDs and strips on Arduino compatible boards, especially if planning to use many of them. Also, You cannot spend your time pointing an IR remote to every corner, looking for the IR receivers that you may have placed around your home; using a lot of remote controllers is messy, too. Finally, we think that an Android tablet or smartphone is the best remote controller available, as it is always with you; also, they’re becoming pretty cheap.

Deploying a simple Souliss environment is easy, an Arduino with an Ethernet Shield and a RGB Shield will do, out of an LED Strip and a 12V power supply. Then download Souliss and load ready-to-use sketches, finally install SoulissApp from Google Play market on your device. You are now ready to control lights, colours and brightnesses manually or play music to let your LEDs follow the rhythm.

The setup is build over two wireless nodes, bridged to Ethernet with a third one

Souliss is a framework for the IoT and smart home solutions, you can have many nodes around the home with their strips connected altogether and get all of them in your smartphone directly, even controlling everything at same time. Basically, Souliss offers an infrastructure to build your automations over objects in a few tens lines of code; it includes all that you need starting from the low level communication protocol to the Android application, including drivers for the media controller (Ethernet, Wireless 2.4 GHz or WiFi) and routing/bridging facilities.

Colours weren’t funny enough, so we let them to be controlled from the music that your smartphone imay be playing, too. Anyway, LEDs are just one example; anything that can be remotely controlled may become a Thing, interacting with other nodes and devices that runs over Souliss.

Got excited about it? Get the library to be loaded on your Arduino board and the Android application, have a look to our wiki and to the introduction to the examples and you will be ready to go, is open source. The video in this post is based on ssOpenElectronics_ex01_RGBStrip.inoavailable in the sketch folder of the Soulis library, underhardware → OpenElectronics.

Once your stuff is built, please share it and let people know about Souliss. Follow us at@soulissteamor on G+.

With our mill, you can produce custom circuit boards quickly and cheaply. You can make all your projects light up, beep, and move. Wearable circuits, custom guitar effects pedals, and quadcopter electronics are all within reach – without waiting for boards to come back from the manufacturer. Even though the Othermill is optimized for cutting circuit boards, it can also cut metal, wood, wax, and plastic. It is great for engraving and milling 3D shapes for jewelry or mold making.

The Othermill was designed with PCBs in mind, and they were the very first thing we tested when we had a working machine. The precision and accuracy of the Othermill allows you to reliably cut 10 mil trace and space on FR-1 PCB stock. You can create custom circuits that fit into odd 3Dprinted parts, seamlessly integrate electronics into your clothing, and free up your Arduinos for other applications.

As Massimo Menichinelli noted it’s a slightly  modified and commercialized version of the MTM Snap created at MIT.

Here’s the Kickstarter page!

Othermill: kickstarting a desktop 3D computer-controlled mill for circuit-boards, jewelry and more – Boing Boing.

Collaborative Production

- 3D Hubs enables everyone with a 3D printer to join building the largest production network in the world…

Earn money with your 3D printer

- How often is your 3D printer not printing? Use this overcapacity to make parts for local 3D Hubs users

Fast & affordable 3D printing

- Need something 3D printed? With local desktop 3D printers at your disposal, production and shipping

via Local & Social 3D Printing | 3D Hubs.

Interesting! Seems that the Airbnb of 3Dprinting is born!

Whether it’s a personal, store or product page, popularity at today is measured in Likes: the number of users who liked your page, photo or any other content you posted on

Facebook is a key metric of customer engagement and potential success for your venture.

That’s why we decided to put together some clever ideas (and few circuits) to create a giant sized display, based on Arduino, that is able to display the number Like collected for a specific page, without being connected on a computer.

Just try a little search

When it comes to applications with Arduino, the chance that someone already created something similar (at least related) to what you want to create is quite high.

After few simple web searches we discovered an interesting piece of work, posted on SkoltiLab blog dubbed “Facebook Like Box” (http://www.skolti.com/lab/exp8/).

The program – written by David Alcubierre – uses Facebook APIs. Among many other features, these APIs allow developers to send queries and get XML responses – one of the calls actually returns the information about the number of likes related to a specified page.

David’s project outputs on an LCD display with two lines of 20 characters: the classic LCD screen mounted on display shield available from various suppliers; unfortunately, we wanted something more impressive and visible and this was far too small and discreet.

With this in mind, we created a display in which each single digit has its own printed circuit board and is connected to the others in a series. This setup communicates with Arduino using the I2C protocol: the chip used in the display is a PCF8574, an I/O expander that is controllable via I2C and addressable thanks to three bits. This setup is ideal for connecting to an Arduino board.

Furthermore, we decided to add a beep playing a short tune at any time the like number increases.

The hardware ingredients

While you probably don’t need information about Arduino and the ethernet board, few words are worth spending on the I/O expander and the I2C communication protocol used to manage a significant number of lines of two-way communication.

The internal block diagram of PCF8574 taken from its datasheet shows a very straightforward and easy to understand structure, where the serial input data on the SDA are converted in parallel data by a shift register and vice versa.

The I/O ports have some special features and, when on high level don’t support more than one milliampere, while at low level they can support up to 25 mA. The operating range of the chip ranges from 2.5 to 6 V.

With these characteristics, the use of this integrated circuit for our display inevitably requires a transistor for each of the seven segments we want to create with the 4 red LEDs. Moreover, using a single integrated for each digit is only an ingenious solution that transforms the eight bits available in seven segments plus a dot. Through the definition of a bitmap for each specific integer number we have the transformation of a byte sent to the circuit into a displayed digit with the ignition of the relevant segments.

The definition of each chip address is made via the appropriate three-way dip switch available in each display base: simply check the appropriate address in the sketch to correctly identify each digit.

The entire circuit is 12 volts powered: Arduino supplies the power to the PCF8574 through its own regulator which converts the 12V input to the 5V required; the Ethernet shield is powered through the Arduino board as well.

Refer to the wiring diagram for all the information on the various links between the boards.

The sketch

/*
 Facebook Like Box

 This sketch connects to Facebook using an Ethernet shield.

 created in 8 Aug 2012
 by David Alcubierre

modified by Boris Landoni

 This code is in the public domain.

 */
#include <SPI.h>
#include <Ethernet.h>

#include <Wire.h>

#define EXPANDER_4 0B00111000  //PCF8574A 
#define EXPANDER_3 0B00111001  //PCF8574A 
#define EXPANDER_2 0B00111010  //PCF8574A 
#define EXPANDER_1 0B00111011  //PCF8574A 
#define EXPANDER_0 0B00111100  //PCF8574A 

int length = 15; // the number of notes
char notes[] = "ccggaagffeeddc "; // a space represents a rest
int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };
int tempo = 100;

int num[10];

int speakerPin = 5;

//LiquidCrystal lcd( 8, 9, 4, 5, 6, 7 );

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,0,99);

// initialize the library instance:
EthernetClient client;

const unsigned long requestInterval = 20000;  // delay between requests

char serverName[] = "api-read.facebook.com";  // facebook URL

boolean requested;                   // whether you've made a request since connecting
unsigned long lastAttemptTime = 0;            // last time you connected to the server, in milliseconds

String currentLine = "";            // string to hold the text from server
String fbcount = "";                  // string to hold the tweet
long  fbcountlold;                  // string to hold the tweet
long  fbcountl;
char fbcountA[6];
boolean readingFbcount = false;       // if you're currently reading the tweet

void setup() {
  num[0]= B10101111;
  num[1]= B00000011;
  num[2]= B10110110;
  num[3]= B10010111;
  num[4]= B00011011;
  num[5]= B10011101;
  num[6]= B10111101;
  num[7]= B00000111;
  num[8]= B10111111;
  num[9]= B10011111;
  pinMode(speakerPin, OUTPUT);  
  // reserve space for the strings:
  currentLine.reserve(256);
  fbcount.reserve(100);

  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  Wire.begin();

  PCFwrite(EXPANDER_0, 255);
  PCFwrite(EXPANDER_1, 255);
  PCFwrite(EXPANDER_2, 255);
  PCFwrite(EXPANDER_3, 255);
  PCFwrite(EXPANDER_4, 255);
  delay(2000);

  // attempt a DHCP connection:
//  Serial.println("Attempting to get an IP address using DHCP:");
  if (!Ethernet.begin(mac)) {
    // if DHCP fails, start with a hard-coded address:
    Serial.println("failed to get an IP address using DHCP, trying manually");
    Ethernet.begin(mac, ip);
  }
  Serial.print("My address:");
  Serial.println(Ethernet.localIP());
  // connect to Twitter:
  connectToServer();
  //delay(2000);

  for (int i=0;i<10;i++){
    PCFwrite(EXPANDER_0, num[i]);
    PCFwrite(EXPANDER_1, num[i]);
    PCFwrite(EXPANDER_2, num[i]);
    PCFwrite(EXPANDER_3, num[i]);
    PCFwrite(EXPANDER_4, num[i]);
    delay(500);
  }

  PCFwrite(EXPANDER_0, 0);
  PCFwrite(EXPANDER_1, 0);
  PCFwrite(EXPANDER_2, 0);
  PCFwrite(EXPANDER_3, 0);
  PCFwrite(EXPANDER_4, 0);

}

void loop()
{

  if (client.connected()) {
    if (client.available()) {
      //Serial.println("read incoming bytes");
      char inChar = client.read();
      //Serial.print(inChar);
      // add incoming byte to end of line:
      currentLine += inChar; 

      // if you get a newline, clear the line:
      if (inChar == '\n') {
        currentLine = "";
      } 
      // the current line ends with <fan_count>
      if ( currentLine.endsWith("<fan_count>")) {
        readingFbcount = true; 
        fbcount = "";
      }

      if (readingFbcount) {
        if (inChar != '<')  {
          if (inChar != '>'){
            fbcount += inChar;
          }
        } 
        else {
          // if you got a "<" character,
          // you've reached the end of the facebook:
          readingFbcount = false;
          fbcountl = StrToFloat(fbcount);
          Serial.print("Open Electronics has reached ");
          Serial.print(fbcountl); 
          Serial.println(" Fans");
          if (fbcountlold<fbcountl){
            play();
            Serial.print("Open Electronics has ");
            Serial.print(fbcountl-fbcountlold); 
            Serial.println(" more Fan");
          }
          fbcountlold=fbcountl;

          //fbcount.toCharArray(fbcountA, 6); 

          int i = fbcount[0];
          i=i-48;        
          PCFwrite(EXPANDER_0, num[i]);
          if (fbcountl>9){
            i = fbcount[1];
            i=i-48;
            PCFwrite(EXPANDER_1, num[i]);
          }  

          if (fbcountl>99){
            i = fbcount[2];
            i=i-48;
            PCFwrite(EXPANDER_2, num[i]);
          }

          if (fbcountl>999){
            i = fbcount[3];
            i=i-48;
            PCFwrite(EXPANDER_3, num[i]);
          }

          if (fbcountl>9999){
            i = fbcount[4];
            i=i-48;
            PCFwrite(EXPANDER_4, num[i]);
          }

          // close the connection to the server:
          client.stop(); 
        }
      }
    }   
  }
  else if (millis() - lastAttemptTime > requestInterval) {
    // if you're not connected, and two minutes have passed since
    // your last connection, then attempt to connect again:
    connectToServer();
  }
}

void connectToServer() {
  // attempt to connect, and wait a millisecond:
  //Serial.println("connecting to server...");
  String content = "";
  if (client.connect(serverName, 80)) {
//    Serial.println("making HTTP request...");
    // make HTTP GET request to Facebook:
    client.println("GET /restserver.php?format=xml&method=fql.multiquery&pretty=0&queries={%22page_info%22%3A%22select%20name%2Cfan_count%20from%20page%20where%20page_id%20IN%20(169319619774700)%22}&sdk=joey HTTP/1.1");
    // declare correct server
    client.println("HOST: api-read.facebook.com" );// + content.concat(serverName));
    client.println();
  }
  // note the time of this connect attempt:
  lastAttemptTime = millis();
  //Serial.println("OUT making HTTP request...");
//  Serial.println(lastAttemptTime);
}

float StrToFloat(String str){
  char carray[str.length() + 1]; //determine size of the array
  str.toCharArray(carray, sizeof(carray)); //put str into an array
  return atof(carray);
}

void PCFwrite(int addr, int data) {
/*  Serial.print("addr ");
  Serial.println(addr);
  Serial.print("data ");
  Serial.println(data);
*/  
  Wire.beginTransmission(addr);
  Wire.write(data);
  Wire.endTransmission(); 

}

void playTone(int tone, int duration) {
  for (long i = 0; i < duration * 1000L; i += tone * 2) {
    digitalWrite(speakerPin, HIGH);
    delayMicroseconds(tone);
    digitalWrite(speakerPin, LOW);
    delayMicroseconds(tone);
  }
}

void playNote(char note, int duration) {
  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
  int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };

  // play the tone corresponding to the note name
  for (int i = 0; i < 8; i++) {
    if (names[i] == note) {
      playTone(tones[i], duration);
    }
  }
}

void play(){
  for (int i = 0; i < length; i++) {
    if (notes[i] == ' ') {
      delay(beats[i] * tempo); // rest
    } else {
      playNote(notes[i], beats[i] * tempo);      
    }

    // pause between notes
    delay(tempo / 2); 
  }
}

Given that all starts from Tom Igoe’s Twitter Client plus the Facebook query API tweak made by David, we still need to code to add the display replacement and the counter increase jingle tone.

With regards to the library, the Ethernet functions and facebook APIs query code, plu XML parsing, you can refer to the “Twitter Client with Strings” example provided with the core installation of Arduino1.0.x.

But, let’s see he parts we added to existing material.

First we must necessarily include the SPI and Ethernet libraries, plus the Wire library for I2C communication.

At the beginning of the sketch we find the defines that combine the five panels with the relative addresses through the “EXPANDER_n” constants with “n” ranging from 0 to 4; use of integrated PCF8574A is assumed in the sketch, then the bit mask is “0B0011xxx”. In case of PCF8574 type integrated circuits we should have used “0B0000xxx”.

The chosen jingle is “Twinkle Twinkle Little Star” with a usual “PlayNote” procedure found towards the end the sketch. In this first part we define the vectors with the notes and their duration, along with the time and length. The pin to connect the audio circuitry is D5.

For networking we chosen the fixed IP configuration through IPAddress ip (192,168,0,99), but you can also use a method based on DHCP.

Following lines instantiate the Ethernet client and create the variables that we will use during execution.

The setup () part is used it to place numbers the bitmap array – the one containing the segments to be lighted to represent each digit – the appropriate values: let’s remember  that the “0″ bits holds the segment off and that when the PCF8574 is reset this activates all their outputs with the high level.

Before finishing setup() we turn on all segments for two seconds, then we display simultaneously on each display the digits from 0 to 9. At the end of this cycle, we turn all digits off by sending to all 5 displays a 0 value.

The main loop checks that the client is connected to the server declared as a string at the beginning of the sketch with

char serverName[] = “api-read.facebook.com”;

and begins to parse the xml received, searching for the Like value with this simple routine

if ( currentLine.endsWith(“<fan_count>”)) {

       readingFbcount = true;

       fbcount = “”;

     }

     if (readingFbcount) {

       if (inChar != ‘<’)  {

         if (inChar != ‘>’){

           fbcount += inChar;

         }

       }

The data is loaded character by character into the fbcount variable is used by subsequent statements that, for five times, read a character and transfer it on the corresponding display with the function defined at the end of PCFwrite scketch.

Before displaying the fbcount value a comparison is also made ​​with the numerical value that was previously read, so that, in case of increase the jingle is played. This routine makes reference to the two additional routines playTone and playNote allowing for the generation of the frequency corresponding to the letter representing the note in the array, for the period specified in the vector beats.

The server connection is performed by the code that is outside the main loop containing the call to the server as defined in the initial part of the sketch. The call sends a http GET with the query string.

To ensure the data are those related to the right page you need to insert the correct ID (check our XML and see our site and our ID). The string is very long so we abbreviated it in order to highlight the place where you enter the ID.

client.println(“GET /restserver .…  %20IN%20(169319619774700)%22}&sdk=joey HTTP/1.1″);

The ID is in brackets and is located near the end of the string.

To recover your ID can be done by accessing your page and then editing the URL replacing “www” with “graph”. For clarity:

http://www.facebook.com/OpenElectronics -> displays the Facebook page

http://graph.facebook.com/OpenElectronics -> Show the card with various information including the ID, as shown:

{
   "id": "169319619774700",
   "about": "Open-electronics.org is the brainchild of a world leader in hobby electronics Futura Elettronica. http://www.open-electronics.org",
   "app_id": "0",
   "can_post": false,
   "category": "Computers/internet website",
   "checkins": 0,
   "cover": {
      "cover_id": 570038313036160,
      "source": "http://sphotos-a.ak.fbcdn.net/hphotos-ak-prn1/524790_570038313036160_1715750447_n.jpg",
      "offset_y": 62,
      "offset_x": 0
   },
   "general_info": "Open Electronics is the brainchild of a world leader in hobby electronics Futura Elettronica.\nOur technicians will support you in designing circuits, writing firmware, making prototypes, choosing components, so as to help you project your idea.",
   "has_added_app": false,
   "is_community_page": false,
   "is_published": true,
   "likes": 49454,
   "link": "https://www.facebook.com/OpenElectronics",
   "mission": "Open Electronics wants to become the reference open source site with ideas and feedback aimed to enrich the community. Beginners can find all the aid needed to improve their skills in electronics.",
   "name": "Open Electronics",
   "products": "Open source electronic projects",
   "release_date": "12/11/2010",
   "talking_about_count": 1660,
   "username": "OpenElectronics",
   "website": "http://www.open-electronics.org",
   "were_here_count": 0
}

http://api-read.facebook.com/restserver.php?format=xml&method=fql.multiquery&pretty=0&queries={%22page_info%22%3A%22select%20name%2Cfan_count%20from%20page%20where%20page_id%20IN%20(>>ID<<)%22}&sdk=joey

You must use the ID that before the “name” field while ignoring other ids that may be found within the data displayed. You can test the data that you retrieved by putting in your browser the string that we reported, replacing >>ID<< with the number you just retrieved.

For open-electronics.org:

http://api-read.facebook.com/restserver.php?format=xml&method=fql.multiquery&pretty=0&queries={%22page_info%22%3A%22select%20name%2Cfan_count%20from%20page%20where%20page_id%20IN%20(169319619774700)%22}&sdk=joey

Here the answer is a little shorter, since we simplified the query string.

The other routines contained in the sketch are used for displaying and for converting from strings to numbers, followed by the parts that are related to the jingle, already described.

Compiling the sketch

Before compiling and loading the code on the board, you need to change the IP according to the one assigned to your Arduino on your LAN and set the addresses of the display according to their actual configuration. The ID is inserted into the sketch before compiling and after having “tested” it through the browser. If you do not take care of all this, before loading the firmware on your Arduino, you’ll have a good chance of having a non-working system or simply a system displaying Likes from someone else’s page.

Once the firmware is compiled and loaded you can do a first test: the debug strings print instructions on the serial port allow you to check the software without connecting the LED display, but only by mounting the Ethernet shield and making the connection to your LAN. For each server query you’ll have the current Likes output on the IDE console – which of course you must activate -if there is an increase, you will also see the new Likes number.

Final testing

Even in the absence of a network connection, the firmware has a display initialization routine that first turns on all segments in sequence and then composes numbers from 0 to 9 simultaneously on the digits. During this step keeping the IDE console open can be useful (check that the once the network cable is connected, after resetting the Arduino, you receive the message My address: <IP of address of the board> that should be followed by the Like count)

If you have a particularly successful website and five digits for Likes are not enough, this is not a problem: just physically add one or more digits to the series and proportionally adapt the defines and the code blocks writing one digit after another for each display.

“Open Tech Forever (OTF) is dedicated to developing new and improved, open source versions of modern and cutting-edge technologies. In the open source spirit, we create free, online, high quality educational resources demonstrating how to understand, redesign, and replicate our products. We cover not only the skills, designs and the train of thought behind the development process but also the facilities, tools, and materials that it takes to really make a variety of technologies. We develop and document open hardware, manufacture products for sale, and host public workshops to provide a hands-on learning experience for improved skill development and retention.”

Open Tech Forever.

During my internship at Fablab Amsterdam, I came across a device that fascinated me a lot. It  was a freaky looking headset called the Emotive EPOC that promised to be able to read one’s mind using EEG. When you wear it, it can separate 16 different thoughts, all based on a direction or a movement (for example: left, rotate forward, push, etc.). In this document I will describe the process I went through connecting the EPOC to a wireless controllable robot. By connecting two actions (push and pull) to two directions of the robot (relatively forward and backward) through Flash, I am able to control with my mind. It is an example of one of the many applications that one can think of when using such a revolutionary device.

via Using the Emotive EPOC as a robot-controlling device | Fablab Amsterdam.

Amazing hack!

Open Source Ecology is launching the 6 in 60 Campaign: Building out 6 of our open source Global Village Construction Set machines in 60 days. And we’re inviting you to participate.

OSE Design Sprint – Open Source Ecology.

Do you want to support Open Source Ecology but don’t know why? Maybe you know how to use sketchup or you can learn it and get involved!

The plastic, capable of dramatic changes in shape and size, makes it possible for objects to transform themselves entirely. Hence a small, compressed package can become a full-grown armchair, whose first life-size version will be presented during this year’s Furniture Fair in Milan.

via Smart polymers hunting for makers.

Picture taken from domus website original post

I was very impressed in the last days of the much talk that has been done around the Liberator, the first 3D printable gun, available for download on Defcad.

The amateur, DIY guns, are not new, it is not the 3D printing today to make a difference: even if the team is working on a version of the liberator that is available for printing on RepRap printers, today print the Liberator is still complicated and may not work.

In a sense, however, we see the beginning of a process of guerrillas democratization, as already someone has pointed out in the past. John Robb, studying Global Guerrilla and resilient communities for years now, wrote a post a few days ago, at the time of the Boston attacks. It was on Open-source warfare:

The grievances and motivations  for attacks never die.  They can always find a corner of the Web to fester and grow, in groups too tiny to ever control.

The information needed to conduct attacks will always be available, and with each round of incidents, the information improves through testing.

[...]

Due to technological and behavioral factors, the quality of the attacks can better very quickly once a a conflict ignites.  Weeks can yield significant progress instead of years.

If we face the question from a perspective that is solely about how much information will be available to criminals, for sure this gets quite frightening.

Is the next bomb going to be open source?

 As the US government proceeds with the DefCad downloads cancellation I’m not sure of how much open and accessible information we will be having access in the future.

This sounds a bit like an emotional crackdown that is not worried that the files have already been downloaded and will continue circulating on p2p networks and may appear online on foreign servers with relevant ease.

The point here is not preventing the files to be downloaded, it’s merely about avoiding a public discussion on open source warfare. Nothing actually prevents these websites and information to thrive in the so called “dark web” but we are prevented as a society to discuss publicly about that topic. I’m really not sure this is going to be a good decision.

In fact, If we look at  the situation from the perspective of how much information will be available to society, how much discussion will be made about this, we may arrive to different conclusions.

A comment on engadget few days ago brought the point to the surface with a clever consideration:

“If some psycho wants to make a plastic gun, with plastic bullets, no metal parts, and try to hijack a plane, there is no stopping them. It is better for the population to understand the limitations of this type of weapon than try to outlaw it. If the people on a plane know he only has one shot, it only takes one hero out of a plane full of people to rush the guy and use up that shot. Also, there is a high probability it wont even be lethal, more bark than bite. 

If we outlaw anything it should be the decisions made on emotion instead of logic.”

Knowing how this kind of objects appear (or work) could be highly beneficial to safety as the public may be informed about how to recognize, spot and report (or even sabotage or break) thanks to the publicly available information. Gun hackers might be soon inventing the next trick to do all kind of exploit to the gun, as long as this information is available.

This sounds interesting with a gun but it’s even more interesting and hard to manage if you think to a bomb, mine or who knows what. Shall we be really advocating public disclosure in that case? Isn’t it that we are not much concerned with guns only because guns are quite common in our experience (and the Liberator seems like a toy)? What is the exact point where we shall start to be concerned if information is available to the people?

This turns back to the Wikileaks debate, even if it’s more direct: people can’t get access to information because it’s better for society to keep it proprietary.

If the discussion has been interesting to you until this point, you might find extremely important the fact that the arms market is a $1,000 billion business.

Is it again about censorship?

The true point here is that we should advocate for opensourcing data about arms that are already on the market and not just ask the possibility to create open source versions.

The open source warfare is not going away, only the public discussion is being turned off at this point. I’m sure that the next innovation in arms in not going to be open source, will be a proprietary technology and a big business as often.

I’m skeptikal we are going to have an open source bazooka anytime soon as much as about the future of a honest and open discussion on arms and defense.