Upcycle It

[Upcycle It] Interactive Race Car Driver - What next?

messages@element14.com — Thu, 29 Jun 2017 21:27:53 GMT

Despite a lack of posts there's actually been quite a bit going on over the last couple of weeks. Now that the challenge is over, I've been reviewing car and electronics.

Electronics

There's been a few recurrent problems with the solution mostly around the fragile wiring and power issues. The subsystems have all been tested and checked over the last couple of weeks in an attempt to get a better demo video. It's quite a complex design with multiple batteries, power convertors, grove connector breakout boards and level shifters. The results is that I've not actually had driver and car working at the same time from battery.

Many of the design features were only there for the benefits of the challenge. Now that those restrictions have been lifted I will simplify the electronics and wiring.

Car

The wooden parts of the car will be dropped and I'll be printing replacements. The single extruder replacement heads for the Cel Robox are quite expensive and also no-one seems to have them in stock. So I'm saving up and looking around for suppliers.

The car is a little back heavy and rather tall. This does mean that it likes to pull wheelies which is kind of cool but probably not good for the driver. So the battery will be moving to the middle of the car and electronics lowered.

Software

I've also been working through the software getting it all working together, I had trouble with DNS and security but resolved all that, last week. https://github.com/Workshopshed/UpcyclingDesignChallenge

The web page for driving the car is really just there to test things. What I would really like to have is a UI that my daughter can use to learn basic programming concepts. I've been looking at various things and Blockly looks good, it's open source, multi-platform and is easily customised. Blockly basically allows you to drag blogs onto a design area and when you run the code it compiles those into a language of your choice such as JavaScript. It's possible to create custom blocks with code which would send the same messages to MQTT as I currently do with my buttons. I can customise and add to the UI as she and the car evolve.

So this not the last of the interactive race car driver, there will be more to come.

Interview | Carmelito Andrade, Creator of the Upcycled Clock

messages@element14.com — Wed, 28 Jun 2017 19:22:37 GMT

We invited engineers, DIY hobbyists, and tinkerers to upcycle an obsolete item, computer, piece of electronic equipment, or appliance and make a cool new electronics project built around the Intel® Edison Kit for Arduino. element14 member Carmelito Andrade took an old clock given to him by his mother and turned it into an intelligent home device that can give him the weather, traffic, updates on his email and Twitter accounts, and much more. His outstanding Upcycled Clock was selected as the winner of the Design Challenge, and I reached out to him with some questions about the project.

Q: How did you decide on the clock as your device to upcycle? It seems like it has some sentimental value for you, was that part of your decision?

Carmelito: With analog wrist watches now moving towards smartwatches, when I first heard about the Upcycle It Design Challenge on The Ben Heck Show, and saw a boombox being upcycled, a few ideas crossed my mind. So I thought, "Why not upcycle my mom’s old clock to make it smart?" Obviously, I only did it after getting her permission.

Q: Did you run into any unexpected challenges in assembling the clock, and how did you go about solving them?

Carmelito: Ah yes, I think I ran into a lot of challenges! Here are a couple that bothered me the most:

1) Deciding on the LED strip - when I first started I had planned to use NeoPixel (WS2812), which was one of the most important parts of the build for the LED diffusion panels, but reading a couple of posts on the Intel forums and searching the web for a possible solution, I decided to buy an APA102 LED strip, which already had a library and sample code on Intel's UPM github repository.

2) I had a nozzle jam on my 3D printer multiple times, because I was printing with wood filament.

Q: You posted an introduction for the clock laying out what features you intended to add; did any of the features you ultimately wound up adding come from some inspiration you had over the course of the Design Challenge?

Carmelito: Yes, there were quite a few features that I did not plan for originally, but I thought would be good additions. For example:

1) I live in Los Angeles, California, and the traffic is pretty bad out here. I think it's in the top 10 cities in the world for the worst traffic, in fact. So, the idea I had was to implement something which would give me the estimated travel time to get to work. To achieve this, I used the Google Maps distance matrix API. But, frankly, most days I see the traffic panel light up orange (which means a medium amount of traffic), although that's better than a few weeks back when it was all red, which I am guessing was because schools had vacations.

2) For the alarm feature, to show data on the LCD, I was not planning to add the button and potentiometer originally to the panel, but after a couple of comments by Mark Beckett (username: mcb1) on my intro blog, I decided to sort this out. And while I was waiting for my package I had the button and POT panel sorted out.

3) The LED strip I added at the back of the clock was also something that was not planned. Here the idea was to show critical things on the LED strip, for example, if it's raining then have the strip light up blue. I still need to improve this feature, and a couple of my friends suggested that I should connect a mic input/sensor and use it like a VU meter when I have music playing at home.

4) I also made it possible to turn on and off the HUE lights at home from the clock. Though I rarely use this feature, the idea here is that you can turn on and off all of your Philips HUE lights at home using an IFTTT recipe.

Q: Are there any future capabilities you’d like to add to the upcycled clock?

Carmelito: Yes, there are two features in particular that I have wanted to add:

1) Make the clock speak as soon as I get back home in the evening, which I partly added in a blog post after the challenge ended. But in addition to reading the weather and tweets, I also want the clock to read out the top 5 news headlines. For this I still need to figure out if I can use an RSS feed to download those headlines.

2) Make it trigger my air conditioner when I get back in the evening if the temperature is above a certain threshold, maybe above 23C degrees, since I live in an old apartment building which has air conditioning units mounted on its walls. I need another ESP8266, which I plan to connect to a power tail switch to trigger switching on the air conditioner, and then switching it off if the temperature gets below around 20C.

Q: You seem to have drawn on a number of different skills in constructing your clock; in what discipline do you feel you most improved over the course of the challenge?

Carmelito: I would say the skill I most improved was using Autodesk Fusion 360 to design and 3D print. And I would also like to mention that I am happy with how the replacement panels on the clock turned out, and I'm glad that my mother found the clock interesting and liked the overall aesthetic when I demonstrated the features to her via video chat.

In addition, it was interesting to see most of my fellow challengers using node.js in their Design Challenge entries, and this has motivated me to learn node.js.

Check out the rest of the entries for the Upcycle It Design Challenge!

Final Blog for Team_fastcar (Which apparently was not submitted)

messages@element14.com — Thu, 22 Jun 2017 19:23:00 GMT

Firstly, we would like to apologize for turning in our final blog late. Personal schedule conflicts and time management issues lead us to complete the project at a slower pace than anticipated. Our project’s latency was also in part caused the fact that we did not receive our Edison kit, which pressed us for time when it came to completing the clock’s systems that relied on use of the Edison. Nevertheless, we learned a lot about the Edison chip while making an attempt to create our own clock. Overall, we greatly enjoyed the experience of being able to participate in this competition. If we can work together again, I would hope that we would be able to connect the buttons we made to the Raspberry pi for audio/recording control rather than having to connect it to a computer. In addition, we would probably have used interrupts to make it so the clock hand doesn't just go around in circles to reset.

This is how we connected the stepper motor to the calibration pin with set screw couplers. It can reliably turn the pin when secured to the back half of the clock.

Final Arduino Code:

#include <Dhcp.h>

#include <Dns.h>

#include <WiFi.h>

#include <WiFiClient.h>

#include <WiFiServer.h>

#include <WiFiUdp.h>

#include <Stepper.h>

const int stepsPerRevolution=60;

#include <SPI.h>

// create an instance of the stepper class, specifying

// the number of steps of the motor and the pins it's

// attached to

Stepper mystepper(stepsPerRevolution, 5, 4, 3, 2);

int stepCount=0;

// the previous reading from the analog input

int status = WL_IDLE_STATUS;

char ssid[] = "SSID"; // network SSID

char pass[] = "Passcode"; // network password

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 of the message

byte packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets

// A UDP instance to let us send and receive packets over UDP

WiFiUDP Udp;

void setup() {

// Open serial communications and wait for port to open:

Serial.begin(9600);

while (!Serial) {

; // wait for serial port to connect. Needed for native USB port only

}

// check for the presence of the shield:

if (WiFi.status() == WL_NO_SHIELD) {

Serial.println("WiFi shield not present");

// don't continue:

while (true);

}

String fv = WiFi.firmwareVersion();

if (fv != "1.1.0") {

Serial.println("Please upgrade the firmware");

}

// attempt to connect to Wifi network:

while (status != WL_CONNECTED) {

Serial.print("Attempting to connect to SSID: ");

Serial.println(ssid);

// Connect to WPA/WPA2 network. Change this line if using open or WEP network:

status = WiFi.begin(ssid, pass);

// wait 10 seconds for connection:

delay(10000);

}

Serial.println("Connected to wifi");

printWifiStatus();

Serial.println("\nStarting connection to server...");

Udp.begin(localPort);

}

void loop() {

myStepper.setSpeed(motorSpeed);

// step 1/100 of a revolution:

myStepper.step(stepsPerRevolution / 100);

delay(59000);

if( digitalRead(0)==LOW && digitalRead(1)==LOW)

{

sendNTPpacket(timeServer); // send an NTP packet to a time server

// wait to see if a reply is available

delay(1000);

if (Udp.parsePacket()) {

Serial.println("packet received");

// We've received a packet, read the data from it

Udp.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, extract 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

unsigned long secsSince1900 = highWord << 16 | lowWord;

unsigned long epoch = secsSince1900 - 2208988800UL;

Serial.print("The UTC time is "); // UTC is the time at Greenwich Meridian (GMT)

Serial.print((epoch % 86400L) / 3600);

// print the hour (86400 equals secs per day)

Serial.print(':');

if (((epoch % 3600) / 60) < 10) {

// In the first 10 minutes of each hour, we'll want a leading '0'

Serial.print('0');

}

Serial.print((epoch % 3600) / 60); // print the minute (3600 equals secs per minute)

Serial.print(':');

if ((epoch % 60) < 10) {

// In the first 10 seconds of each minute, we'll want a leading '0'

Serial.print('0');

}

Serial.println(epoch % 60); // print the second

}

if((epoch%86400L/3600)==12&&((epoch % 3600) / 60)==0){

while(digitalRead(0)==LOW && digitalRead(1)==LOW)

{

myStepper.setSpeed(100);

myStepper.step(10);

}

// 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:

Udp.beginPacket(address, 123); //NTP requests are to port 123

Udp.write(packetBuffer, NTP_PACKET_SIZE);

Udp.endPacket();

}

Admittedly, the above code has a flaw where instead of calibrating, it merely waits until the conditions are met at midnight. There are pins connecting to the hour and minute hand that form a switch with the arduino (0 and 1 pins).

Raspberry Pi

We set up a system which requires one to be connected to a computer in order to use it…. But it can record and playback audio.

Arecord filename.wav -record function\

Hit ctrl-c to stop recording

Mpv filename.wav to play the recorded audio

Upcycle It - Washing Machine Hydroponic Grower - #11 Planting

messages@element14.com — Wed, 21 Jun 2017 04:43:17 GMT

Preparing the growing baskets

The seeds are placed in a cut on the foam.

I am testing Lettuce, Parsley, Rocket and Spinach all in one go.

So far this is what we got. I will place them in the drum as soon as I have most of them germinated.

I will be using the following nutrient solution on the first cycle testing. They say this is the brand chosen by NASA and Antarctica Scientists to grow their experimental crops... Can't go wrong!

Upcycled Clock - Detect door opening (post challenge)

messages@element14.com — Wed, 14 Jun 2017 04:14:36 GMT

As part of the this blog post, the idea is to implement something that would allow the clock to detect the opening of my front door in the evening, when I get back home from work, which then reads out the temperature, weather condition and tweets. After looking into my components box, I found two thing that would help me achieve this, that is an ESP8266 board and Magnetic contact switch aka a door sensor. Basically as part of the setup, I am using MQTT to publish a message from the ESP8266 when the door is opened, which is then received by the Intel Edison attached at the back of the clock , which then reads out the weather condition and tweets via a speaker connected to a USB soundcard. Here is a quick video demo of the setup -

As part of the circuit, I have a Magnetic contact switch connected to pin#13, and I am also using the inbuilt LED on pin#2 of the Adafuit's Huzzah ESP8266 breakout board, to light up when the door opens, this acts as an indicator for testing the setup.

Here is the Arduino code uploaded to ESP8266 breakout board. For more details on how to setup Arduino IDE for ESP8266, check out the guide at - https://learn.adafruit.com/adafruit-huzzah-esp8266-breakout

/*
 Create by Carmelito for the Upcycled Clock project to send an MQTT message from ESP8266 to the Intel Edison
 Date :06-08-2017
 For more details on setting up ESP8266 breakout board checkout -https://learn.adafruit.com/adafruit-huzzah-esp8266-breakout 
*/

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// Update your WiFi router details below
const char* ssid = "xxxxxxxxxxxxx";
const char* password = "xxxxxxxxxxxxxx";
const char* mqtt_server = "test.mosquitto.org";


WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0; //time before last message was sent
char msg[50];
int value = 0;
int doorPin = 13; //Magnetic contact switch
int ledPin =2; //Blue Led on the ESP8266 Huzzah board

void setup_wifi() {
  delay(10);
  //connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  randomSeed(micros());
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Create a random client ID
    String clientId = "ESP8266Client-";
    clientId += String(random(0xffff), HEX);
    //Attempt to connect
    if (client.connect(clientId.c_str())) {
      Serial.println("connected");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}


void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(doorPin, INPUT_PULLUP);
  Serial.begin(115200); 
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  digitalWrite(ledPin, LOW); 
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();


  long now = millis();
  if (now - lastMsg > 30000) { //30 seconds for between door opening and closing
    lastMsg = now;
    ++value;
      if(digitalRead(13) == LOW) //door is open
      {
      digitalWrite(ledPin, HIGH); 
      Serial.println("Publish message: closed ");
      client.publish("door", "closed");
      }
      else //door is closed - disable the else section after testing is done.
      {
        digitalWrite(ledPin, LOW); 
       Serial.println("Publish message:open ");
       client.publish("door", "open");
      }
      
  }
}

If you plan to run a test before the setting up the Intel Edison you can use chrome app called MQTT Lens which you can download using the chrome web-store. Basically, as you see in the screenshot below, I have subscribed to a topic called – door , which receives message every 30 seconds from the program above uploaded on the ESP8266.

But as part of the final setup, a message will be received by the Edison only when the door is opened.

Now since the circuit needs to be mounted on door I 3D printed a case, which I can then nail just above the door as you see in the picture below.

{gallery} ESP8266
3D print an enclosure
ESP8266 - Door Closed
ESP8266 - Door Open

{gallery} ESP8266

3D print an enclosure

ESP8266 - Door Closed

ESP8266 - Door Open

Now, to setup eSpeak on the Edison check out the blog post at - Upcycled Clock - Reading out the weather using eSpeak

And once you have completed the setup for eSpeak and OpenWeatherMap API using the link above , you will have to install paho-mqtt package using pip

$pip install paho-mqtt

Once done, copy paste the python code below and run a quick test using MQTT lens to publish messages to the door topic

Here is the python code used for testing

#Create for the Upcycle clock project using the Intel Edison -- test recive message from the ESP8266 connected to door on the topic- door
#Author : @CarmelitoA 06/09/2017
import paho.mqtt.client as mqtt

def on_connect(client, userdata, flags, rc):
    print("Connected to server. Connection code: "+str(rc))
    #subscribe to "door" topic
    client.subscribe("door")

def on_message(client, userdata, msg):
   #print message on the topic,in this case door published from ESP8266
    #possible values msg.payload - connected, open and closed
    print("Topico: "+msg.topic+" -message recived: "+str(msg.payload))




client = mqtt.Client()
client.on_connect = on_connect   
client.on_message = on_message  


client.connect("test.mosquitto.org", 1883, 60) 
client.loop_forever()

Once you have completed your testing, for the final setup download the folder from the github repo and create a systemd service on the Intel Edison - https://github.com/CJAndrade/Upcycled-Clock/tree/master/DoorMQTT

Upcycle It - Washing Machine Hydroponic Grower - #12 Summing Up

messages@element14.com — Mon, 05 Jun 2017 00:43:21 GMT

The Challange

Upcycle It

To upcycle an obsolete item, computer, piece of electronic equipment or appliance and make a cool new electronics project built around the Intel® Edison Kit for Arduino.

Proposal

Upcycle It - Washing Machine Hydroponic Grower - #1 Introduction

To use an old front load washing machine to be the main assembly of the rotary hydroponic system controlled by the Intel® Edison Kit for Arduino.

Controller to monitor temperature, humidity, nutrient solution PH and control grower light, drum motor and water pump. Values to be published and parameters to be adjusted remotely using MQTT protocol.

Washing Machine Modifications

Upcycle It - Washing Machine Hydroponic Grower - #2 Preparation

Upcycle It - Washing Machine Hydroponic Grower - #3 Preparation II

Concrete ballast and some of the panels were removed. Also, most of the internal parts and wiring were stripped, leaving only the tumbler and the structure to hold it in place.

Grow Light Fitting

Upcycle It - Washing Machine Hydroponic Grower - #4 Preparation III

Upcycling also an old table lamp, the grow light fitting was mounted on a bracket off the drum. Having a flexible goose nose, it can be easily bent away and returned to the position when loading and unloading the plants in the drum.

Stepper Motor

A printer stepper motor was mounted roughly at the same position where the original motor was so the original pulley and belt system was kept to turn the drum. The driver was mounted next to the stepper.

Drum Modification

Upcycle It - Washing Machine Hydroponic Grower - #6 Drum Modification

We added spring loaded rails to secure hydroponic baskets in place once the drum starts spinning.

Nutrient Solution System

Upcycle It - Washing Machine Hydroponic Grower - #8 Nutrient Solution System

A reservoir was placed under the drum so the nutrient solution can be pumped to keep the required level inside the drum.

Sensors and Interfacing

Upcycle It - Washing Machine Hydroponic Grower - #9 Interfacing Edison X Grower

Temperature/Humidity and Light sensors were fixed on the light mounting facing the inside of the drum. The PH probe was fixed on the return pipe so the probe is constantly submerged in the reservoir. The relays that switch the light and water pump were mounted inside a junction box.

Preparing the growing baskets

Upcycle It - Washing Machine Hydroponic Grower - #11 Planting

The seeds are placed in a cut on the foam and left on a tray to germinate before going to the drum.

Testing the Rotary Growing System

This is the final apparency of the Rotary Growing System

Below is a video of the starting of the rotary grower, showing the sensor values and status on the display.

Unfortunately, I didn't have enough time to have the seeds germinating for the final post but I will keep posting photos and videos as it goes.

I also will add more functions on it such as a fan to refresh the air inside the drum, an air pump to aerate the solution and automate the solution PH control and nutrient feeding.

I would like to thank Intel, element14, all community members that gave their suggestions and motivation, my friend Brent bpapesh who gave a good hand on this project and my wife Camila (who hate electronics) for being so patience on the last weeks as I dedicated most of my free time to this project than to her.

Upcycle It - Washing Machine Hydroponic Grower - #10 Programming

messages@element14.com — Mon, 05 Jun 2017 00:42:55 GMT

We started assembling and flashing the board following Intel instructions at https://software.intel.com/en-us/get-started-edison-windows

As the idea is to get feeds from the rotary grower and be able to change settings such as drum rotation and grow light time on/off periods we have to run MQTT broker and client.

At this stage, the broker will be only accessible on the local network but later I will set up a DNS server so we can access it from everywhere.

Building and Running Mosquitto* MQTT on the Intel® Edison board

There are some tips on how to install it on the link below; however, the current version is mosquitto-1.4.12.tar.gz

https://software.intel.com/en-us/blogs/2015/02/20/building-and-running-mosquitto-mqtt-on-intel-edison

To have the sketch running from boot and initialize the mosquitto broker I used the script below

#File: /etc/init.d# vi automateSketch.sh
exec /sketch/./sketch.elf foo bar &
 exec mosquitto -d

Make the script executable by changing the permissions with chmod

root@edison:/etc/init.d# chmod +x /etc/init.d/automateSketch.sh

root@edison:/etc/init.d# chmod +x automateSketch.sh

To have the script executed every time Linux boots

root@edison:/etc/init.d# update-rc.d automateSketch.sh defaults

Below are the library files I used to have the MQTT running. I got those files from https://software.intel.com/en-us/blogs/2015/04/06/using-edison-securely-connect-iot-sensor-to-the-internet-with-mqtt

// File: MQTTClient.cpp
#include "MQTTClient.h"
#include <fcntl.h>
 
 
/*======================================================================
  Constructor/Destructor
========================================================================*/
MQTTClient::MQTTClient()
{
}
MQTTClient::~MQTTClient()
{
  close();
}
void MQTTClient::close()
{
  if (spipe) {
    fclose(spipe);
  }
}
/*========================================================================
  Initialization. Store variables to be used for subscribe/publish calls
==========================================================================*/
void MQTTClient::begin(char *broker, int port, security_mode smode, 
                       char* cafile, char *user, char *psk)
{
  strcpy(mqtt_broker, broker);
  serverPort = port;
  mode = smode;
  if (mode == SSL) {
    strcpy(certificate_file, cafile);
  }
  else if (mode == PSK) {
    strcpy(psk_identity, user);
    strcpy(psk_password, psk);
  }
  Serial.println("MQTTClient initialized");
  Serial.print("Broker: "); Serial.println(mqtt_broker);
  Serial.print("Port:   "); Serial.println(serverPort);
  Serial.print("Mode:   "); Serial.println(mode);
}
/*=======================================================================
  Subscribe to a topic, (*callback) is a function to be called when client
  receive a message
=========================================================================*/
boolean MQTTClient::subscribe(char* topic, 
                              void (*callback)(char* topic, char* message))
{
  char cmdString[256];
  
  if (mqtt_broker == NULL) {
    return false;
  }
  if (topic == NULL) {
    return false;
  }
  
  callback_function = callback;
  switch(mode) {
    case OPEN:
      sprintf(cmdString, 
              "mosquitto_sub -h %s -p %d -t %s -v",
              mqtt_broker, serverPort, topic);
      break;
    case SSL:
      sprintf(cmdString, 
              "mosquitto_sub -h %s -p %d -t %s -v --cafile %s", 
               mqtt_broker, serverPort, topic, certificate_file);
      break;
    case PSK:
      sprintf(cmdString, 
              "mosquitto_sub -h %s -p %d -t %s -v --psk-identity %s --psk %s",
              mqtt_broker, serverPort, topic, psk_identity, psk_password);
      break;
    default:
      break;
  }
  if ((spipe = (FILE*)popen(cmdString, "r")) != NULL) {
    // we need to set the pipe read mode to non-blocking
    int fd    = fileno(spipe);
    int flags = fcntl(fd, F_GETFL, 0);
    flags |= O_NONBLOCK;
    fcntl(fd, F_SETFL, flags);
    strcpy(topicString, topic);
    return true;
  }
  else {
    return false;
  }
}
/*====================================================================
  Check if there is data in the pipe, 
  if true, parse topic and message and execute callback function
  return if pipe is empty
======================================================================*/
boolean MQTTClient::loop()
{
  if (fgets(dataBuffer, sizeof(dataBuffer), spipe)) {    
    parseDataBuffer();    
    callback_function(topic, message);
  }
}
/*====================================================================
  Publish a message on the given topic
======================================================================*/
boolean MQTTClient::publish(char *topic, char *message)
{
  FILE*   ppipe;
  char    cmdString[256];
  boolean retval = false;
  if (this->mqtt_broker == NULL) {
    return false;
  }
  if (topic == NULL) {
    return false;
  }
  switch (this->mode) {
    case OPEN:
      sprintf(cmdString,
              "mosquitto_pub -h %s -p %d -t %s -m \"%s\" %s",
              mqtt_broker, serverPort, topic, message, retain_flag?"-r":"");
      break;
    case SSL:
      sprintf(cmdString,
              "mosquitto_pub -h %s -p %d --cafile %s -t %s -m \"%s\" %s",
               mqtt_broker, serverPort, certificate_file, 
               topic, message, retain_flag?"-r":"");
      break;
    case PSK:
      sprintf(cmdString,
          "mosquitto_pub -h %s -p %d --psk-identity %s --psk %s -t %s -m \"%s\" %s",
              mqtt_broker, serverPort, psk_identity, psk_password, 
              topic, message, retain_flag?"-r":"");
      break;
  }
  if (!(ppipe = (FILE *)popen(cmdString, "w"))) {
    retval = false;
  }
  if (fputs(cmdString, ppipe) != EOF) {
    retval = true;
  }
  else {
    retval = false;
  }
  fclose(ppipe);
  return retval;
}
/*======================================================================
  Parse data in the data buffer to topic and message buffer
  delimiter is the first space
  if there is only one recognizable string, it is assumed a message 
  string and topic is set to NULL
========================================================================*/
void MQTTClient::parseDataBuffer()
{
  topic   = dataBuffer;
  message = dataBuffer;
  while((*message) != 0) {
    if ((*message) == 0x20) {
      // replace the first space with the NULL character
      (*message) = 0;
      message++;
      break;
    }
    else {
      message++;
    }
  }
  if (strlen(message) == 0) {
    topic   = NULL;
    message = dataBuffer;
  }  
}

// File: MQTTClient.h
/*
  Minimalist MQTT Client using mosquitto_sub and mosquitto_pub
  Assume Mosquitto MQTT server already installed and mosquitto_pub/sub 
  are in search path
*/


#ifndef __MQTTClient_H__
#define __MQTTClient_H__


#include <Arduino.h>
#include <stdio.h>


enum security_mode {OPEN = 0, SSL = 1, PSK = 2};


class MQTTClient {


  public:
    MQTTClient();
    ~MQTTClient();
    void    begin(char * broker, int port, security_mode mode, 
                  char* certificate_file, char *psk_identity, char *psk);
    boolean publish(char *topic, char *message);
    boolean subscribe(char* topic, void (*callback)(char *topic, char* message));
    boolean loop();
    boolean available();
    void    close();


  private:
    void           parseDataBuffer();
    FILE*          spipe;
    char           mqtt_broker[32];
    security_mode  mode;
    char           topicString[64];
    char           certificate_file[64];
    char           psk_identity[32];
    char           psk_password[32];
    int            serverPort;
    char           *topic;
    char           *message;
    boolean         retain_flag;
    void           (*callback_function)(char* topic, char* message);
    char           dataBuffer[256];
};
#endif

Main Sketch

This sketch is basically running only the basic functions but I will keep updating as I implement more sensors and features.

//Rotary Growing System


// MQTT
#include <stdio.h>
#include <Arduino.h>


#include "MQTTClient.h"


#define SECURE_MODE     0
// 0 = No security
// 1 = SSL security
// 2 = TLS-PSK security


MQTTClient     mqttClient;
unsigned long  mqttPubInterval_1 = 1000;  // interval for publishing critical values
unsigned long  mqttPubInterval_2 = 5000;  // interval for publishing non-critical values
unsigned long  previousMqttMillis = 0;        
char           fmtString[256];            // utility string
char           topicString[64];           // topic for publishing
char           msgString[14];             // message
bool           autoManual = 1;            // mode initially set to automatic




unsigned long  currentMillis;


//Stepper Motor
int             drumRPH = 5;                // default drum rotation set at 5 Rotation per Hour
const int       stepperPin = 3;             // stepper pulse pin
const int       stepperENA = 4;             // stepper enable pin
int             stepperInterval;            // interval at which to pulse (milliseconds) calculated  dividing 2400 / required drum RPH
unsigned long   previousStepperMillis = 0;  // for stepper motor pulse
bool            remoteDrum = 0;             // value received from MQTT pub to set drum ON or OFF remotely, default OFF "0"


//Grow Light
const int   growLight = 5;                // growLight pin
int         set_on = 8;                   // default on time
int         set_off = 20;                 // default off time
char        date[100];                    // date display format
bool        remoteGrowLight = HIGH;       // value received from MQTT pub to set light ON or OFF remotely, default OFF "HIGH"


//Water Pump
const int     waterPump = 6;                  // water pump relay pin
unsigned long pumpInterval = 1800000;         // interval pump will switch on (every 30 min)
unsigned long pumpOnTime = 10000;             // default time pump stays on every cycle (10 seconds)
unsigned long previousPumpMillis = 0;         // for water pump timer
bool          remoteWaterPump = HIGH;         // value received from MQTT pub to set water pump ON or OFF remotely, default OFF "HIGH"


//Temperature Sensor
const int       pinTempSen = A0;            // pin of temperature sensor
float           temp;




//Light Sensor
const int       pinLightSen = A3;             // pin of light sensor
int             lightSensor = 0;
int             lux;


//LCD DISPLAY
#include <rgb_lcd.h>
#include <Wire.h>
rgb_lcd lcd;


int           screen = 0;
int           screenMax = 5;
bool          screenChanged = true;              // initially we have a new screen,  by definition
unsigned long previousLCDMillis = 0;             // for LCD screen update
unsigned long lcdInterval = 4000;                // LCD change interval
char          timenow[50];


// defines of the screens to show
#define TEMPERATURE 0
#define LUX         1
#define RPH         2
#define TIME        3
#define HUMIDITY    4
#define PH          5




void setup()
{
  pinMode(growLight, OUTPUT);         // light pin
  digitalWrite (growLight, HIGH);     // relay switches off at HIGH            
  pinMode(waterPump, OUTPUT);         // waterPump pin
  digitalWrite (waterPump, HIGH);     // relay switches off at HIGH
  pinMode(stepperENA, OUTPUT);        // stepper Enable pin
  digitalWrite (stepperENA, LOW);     // stepper Enable OFF
  pinMode(stepperPin, OUTPUT);        // stepper motor pulse pin  
  
  Serial.begin(9600);                 //initialize serial communications at 9600 bps
  Serial.println ("\n Initialising Rotary Growing System");
  
  lcd.begin(16, 2);                   // set up the LCD's number of columns and rows
  lcd.clear();
  lcd.setCursor(0, 0);                // set the cursor to column 0, line 0
  lcd.print("Initialising...");
  delay(2000);
  lcd.clear();
  lcd.setCursor(1, 0);               // set the cursor to column 1, line 0
  lcd.print("Rotary Growing");
  lcd.setCursor(5, 1);               // set the cursor to column 5, line 1
  lcd.print("System");
  delay(3000);


  // initializing MQTTClient
  #if ( SECURE_MODE == 0 )
    Serial.println("No security");
    mqttClient.begin("localhost", 1883, OPEN, NULL, NULL, NULL);
  #elif ( SECURE_MODE == 1 )
    Serial.println("SSL security");
    mqttClient.begin("localhost", 1994, SSL, "/home/mosquitto/certs/ca.crt", NULL, NULL);
  #elif ( SECURE_MODE == 2 )
   Serial.println("TLS-PSK security");
   mqttClient.begin("localhost", 1995, PSK, NULL, "user", "deadbeef");
  #endif


  // subscribe to all topics published under edison
  mqttClient.subscribe("edison/#", mqttCallback);
  mqttClient.publish("edison/sysMsg", "Rotary Growing System Booted");
  mqttClient.publish("edison/autoManual", "A");      // publish default Mode to sincronise remote values
  sprintf(msgString, "%d", drumRPH);                 // read default drumRPH value
  mqttClient.publish("edison/drumRPH", msgString);   // publish default drumRPH to sincronise remote values
  sprintf(msgString, "%d", set_on);                  // read default set_on value
  mqttClient.publish("edison/set_on", msgString);    // publish default light set_on time to sincronise remote values
  sprintf(msgString, "%d", set_off);                 // read default set_off value
  mqttClient.publish("edison/set_on", msgString);    // publish default light set_off time to sincronise remote values
}


// MQTT Callback function


void mqttCallback(char* topic, char* message)
{
  sprintf(fmtString, "mqttCallback(), topic: %s, message: %s", topic, message);
  Serial.print(fmtString);


  // Setting Drum RPH
  if (strcmp(topic, "edison/drumRPH") == 0) {     //check the topic then execute command as appropriate
   drumRPH = atoi(message);
  }


  //Seting grow light time ON
  if (strcmp(topic, "edison/set_on") == 0) {     //check the topic then execute command as appropriate
    set_on = atoi(message);
  }


    //Seting grow light time OFF
  if (strcmp(topic, "edison/set_off") == 0) {     //check the topic then execute command as appropriate
    set_off = atoi(message);
  }




  //Set Auto or Manual Mode
  if (strcmp(topic, "edison/autoManual") == 0) {  //check the topic then execute command as appropriate
    if (message[0] == 'A') {                      //set mode to 1 if Automatic
      autoManual = 1;
    }
    else {
      autoManual = 0;                                   //set mode to 0 if Manual
    }
  }


  // Switching Drum ON / OFF
  if (strcmp(topic, "edison/remoteDrum") == 0) {
    // then execute command as appropriate
    if (strncmp(message, "ON", 2) == 0) {
      remoteDrum = 1;
    }
    else {
      remoteDrum = 0;
    }
  }
  
    
  //Grow Light remote control
  if (strcmp(topic, "edison/remoteGrowLight") == 0) {
    // then execute command as appropriate
    if (strncmp(message, "ON", 2) == 0) {
      remoteGrowLight = LOW;
    }
    else {
      remoteGrowLight = HIGH;
    }
  }




  //Water Pump remote control
  if (strcmp(topic, "edison/remoteWaterPump") == 0) {
      // then execute command as appropriate
    if (strncmp(message, "ON", 2) == 0) {
      remoteWaterPump = LOW;
    }
    else {
      remoteWaterPump = HIGH;
    }
  }


  
}




void loop()
{
  mqttClient.loop();            // check for any new message from mqtt_sub
  currentMillis = millis();
  stepperMotor();  
  lightTimer();
  waterPumpTimer();
  grooveTempSen();
  grooveLightSen();
  grooveLCD();
  edisonMQTT();


}


//========================================================================================================================================


void stepperMotor()
{
  // check to see if it's time to pulse; that is, if the
  // difference between the current time and last pulse time
  // is bigger than the interval at which you want to pulse
  
  stepperInterval = 2400/drumRPH;
  bool pulseState;                 // pulseState used to set the stepperPin
  
  if (autoManual == 1 || (autoManual == 0 && remoteDrum == 1)){
        digitalWrite(stepperENA, LOW);
    if (currentMillis - previousStepperMillis >= stepperInterval) {
      previousStepperMillis = currentMillis;       // save the last Pulse time
  
      // if the Pulse is off turn it on and vice-versa:
      if (pulseState == LOW) {
        pulseState = HIGH;
      } else {
        pulseState = LOW;
      }
      // set the stepperPin with the pulseState of the variable:
      digitalWrite(stepperPin, pulseState);
    }
  }
  else {
    pulseState = LOW;
    digitalWrite(stepperENA, HIGH);
  }
}


//========================================================================================================================================


void lightTimer() {


  time_t t = time(NULL);
  struct tm tm = *localtime(&t);
  sprintf(date, "%02d/%02d/%04d %02d:%02d:%02d", tm.tm_mday, tm.tm_mon + 1, tm.tm_year + 1900, tm.tm_hour, tm.tm_min, tm.tm_sec);
  sprintf(timenow, "%02d:%02d:%02d", tm.tm_hour, tm.tm_min, tm.tm_sec);
  Serial.println(timenow);




  //if(set_on == set_off){
  //   digitalWrite(growLight, HIGH);            //HIGH sets light relay off
  //   Serial.println("Same On and OFF hours. Set at least 1h difference");
  //}
  //
  //if(set_on >23){
  //   digitalWrite(growLight, HIGH);            //HIGH sets light relay off
  //   Serial.println("Invalid hour value, choose from 0 until 23");
  //}
  //
  //if(set_off >23){
  //   digitalWrite(growLight, HIGH);           //HIGH sets light relay off
  //   Serial.println("Invalid hour value, choose from 0 until 23");
  //}




  if (autoManual == 1) {
    if (tm.tm_hour >= set_on && tm.tm_hour < set_off)    //Start timer
    {
      digitalWrite(growLight, LOW);       //LOW sets light relay on
    }
    else {
      digitalWrite(growLight, HIGH);      //HIGH sets light relay off
    }
  }
  else {
    Serial.println("Manual Mode Selected");
    digitalWrite(growLight, remoteGrowLight);
  }
}


//========================================================================================================================================


void waterPumpTimer() {
  // check to see if it's time to switch the water pump; if the
  // difference between the current time and last time the pump was on
  // is bigger than the interval set on pumpInterval
  // than switch it on for the time set on pumpOnTime
  
  if (autoManual == 1) {
    if (currentMillis - previousPumpMillis >= pumpInterval) {
      previousPumpMillis = currentMillis;       // save the last pump interval on time
      unsigned long previousPumpOnMillis;
      if (currentMillis - previousPumpOnMillis >= pumpOnTime) {
      previousPumpOnMillis = currentMillis;       // save the last pump time on time
      digitalWrite(waterPump, LOW);               // turn water pump ON
      }
      else {
      digitalWrite(waterPump, HIGH);              // turn water pump OFF
      }
    }
    else {
      digitalWrite(waterPump, HIGH);              // turn water pump OFF
    }
  }
  else {
    digitalWrite(waterPump, remoteWaterPump);
  }


}


//========================================================================================================================================


void grooveTempSen()                                    // grove temperature sensor
{
  int B = 3975;                                        // B value of the thermistor
  float resistance;
  int val = analogRead(pinTempSen);                    // get analog value
  resistance = (float)(1023 - val) * 10000 / val;      // get resistance
  temp = 1 / (log(resistance / 10000) / B + 1 / 298.15) - 273.15;  // calc temperature
  //    Serial.print("Temp: ");
  //    Serial.print(temp);
  //    Serial.println(" ºC");


}


//========================================================================================================================================


void grooveLightSen()                                  // grove light sensor
{
  lightSensor = analogRead(pinLightSen);
  lux = lightSensor;
  //    Serial.print("Light: ");
  //    Serial.print(lux);
  //    Serial.println(" LUX");
}


//========================================================================================================================================


void grooveLCD() {                                    // groove LCD RGB display


  unsigned long currentLCDMillis = millis();


  char number[4];


  { if (currentLCDMillis - previousLCDMillis > lcdInterval)             // save the last time you changed the display
    {
      previousLCDMillis = currentLCDMillis;
      screen++;
      if (screen > screenMax) screen = 0;  // all screens done? => start over
      screenChanged = true;
    }


    // debug Serial.println(screen);




    // DISPLAY CURRENT SCREEN
    if (screenChanged)   // only update the screen if the screen is changed.
    {
      screenChanged = false; // reset for next iteration
      switch (screen)
      {
        case TEMPERATURE:
          //print temperature
          lcd.clear();
          lcd.print("Temperature");
          lcd.setCursor(0, 1);
          sprintf(number, "%02.01f", temp);
          lcd.setCursor(3, 1);
          lcd.print(number);
          lcd.print(" C");
          break;


        case LUX:
          //print light
          lcd.clear();
          lcd.print("Light");
          lcd.setCursor(0, 1);
          sprintf(number, "%d", lux);
          lcd.setCursor(3, 1);
          lcd.print(number);
          lcd.print(" LUX");
          break;


        case RPH:
          //print RPM       // drum rotation per hour
          lcd.clear();
          lcd.print("Drum Speed");
          lcd.setCursor(0, 1);
          sprintf(number, "%d", (drumRPH));
          lcd.setCursor(3, 1);
          lcd.print(number);
          lcd.print(" RPH");
          break;


        case TIME:
          //print TIME
          lcd.clear();
          lcd.print(timenow);
          lcd.setCursor(0, 1);
          lcd.print("GROW LIGHT: ");
          lcd.setCursor(13, 1);
          if (digitalRead (growLight) == LOW) {
            lcd.print("ON");
          }
          else {
            lcd.print("OFF");
          }
          break;


        case HUMIDITY:
          //print humidity
          lcd.clear();
          lcd.print("Humidity");
          lcd.setCursor(0, 1);
          //sprintf(number,"%d",humid);
          lcd.setCursor(3, 1);
          lcd.print(38);
          lcd.print(" %");
          break;


        case PH:
          //print PH
          lcd.clear();
          lcd.print("PH");
          lcd.setCursor(0, 1);
          //sprintf(number,"%02.01f",ph);
          lcd.setCursor(3, 1);
          lcd.print(6.5);




        default:
          // cannot happen -> showError() ?
          break;
      }


    }
  }
}


//========================================================================================================================================


void edisonMQTT() {


  
  //critical information publishes immediately
  if (currentMillis - previousMqttMillis >= mqttPubInterval_1) {            
    previousMqttMillis = currentMillis;       // save the last Pulse time
   
    // publish drum Stopped
    if (stepperENA == HIGH){
    mqttClient.publish("edison/sysMsg", "DRUM STOPPED");
    }
    
    // publish light issue
    if ((digitalRead (growLight) == LOW) && (lux < 500)) {
    mqttClient.publish("edison/sysMsg", "FAULTY LIGHT");
    }


    // publish Auto/Manual mode change
    bool modeState;                      // indicates toggle on mode state
    if (modeState == LOW &&  autoManual == 1) {
        mqttClient.publish("edison/sysMsg", "MODE SET TO: AUTO");
        modeState = HIGH;
    }
    if (modeState == HIGH &&  autoManual == 0) {
    mqttClient.publish("edison/sysMsg", "MODE SET TO: MANUAL");
    modeState = LOW;
    }

    // publish grow light switching on or off
    bool lightState;                      // indicates toggle on light state
    if (lightState == LOW &&  (digitalRead (growLight) == HIGH)) {
        mqttClient.publish("edison/growLight", "OFF");    
        lightState = HIGH;
    }
    if (lightState == HIGH &&  (digitalRead (growLight) == LOW)) {
        mqttClient.publish("edison/growLight", "ON");
        lightState = HIGH;
    }
    
    // publish grow light switching on or off
    bool waterPumpState;                      // indicates toggle on water pump state
    if (waterPumpState == LOW &&  (digitalRead (waterPump) == HIGH)) {
        mqttClient.publish("edison/waterPump", "OFF");    
        waterPumpState = HIGH;
    }
    if (waterPumpState == HIGH &&  (digitalRead (waterPump) == LOW)) {
        mqttClient.publish("edison/waterPump", "ON");
        waterPumpState = HIGH;
    }
    
   }
  
  
  //non-critical information publishes every 10 minutes
  if (currentMillis - previousMqttMillis >= mqttPubInterval_2) {
    previousMqttMillis = currentMillis;       // save the last Pulse time
    
    // publish temperature
    sprintf(msgString, "%02.01f", temp);
    mqttClient.publish("edison/temperature", msgString);


    // publish light sensor reading
    sprintf(msgString, "%d", lux);
    mqttClient.publish("edison/lightSensor", msgString);


//    // publish hunidity sensor reading
//    sprintf(msgString, "%d", humid);
//    mqttClient.publish("edison/humidity", msgString);
//
//    // publish PH
//    sprintf(msgString, "%02.01f", ph);
//    mqttClient.publish("edison/ph", msgString);


    
  }
  
}


//END

On my mobile, I installed MQTT Dashboard so we can get the feeds and publish values such as Light Time Set On/Off and Drum RPH (Rotations per hour)

Upcycle It - Washing Machine Hydroponic Grower - #9 Interfacing Edison X Grower

messages@element14.com — Mon, 05 Jun 2017 00:41:53 GMT

Details of electrical connections for the grow light and water pump

The relays that switch the light and the water pump were enclosed inside a junction box so there are no exposed wires and terminals for this part of the circuit.

The control cables came through the machine frame just where I gonna fix the Edison Board. The relay block has 4 relays but at this stage, I am using only 2.

The other 2 I will have as spare as I have plans to install an air blower to force air into the drum if it gets too hot or too humid and an air pump to aerate the nutrient.

Edison/Arduino Board & LCD Display

The Edison board was fixed on the back of the machine. It is far from the water and moisture and easily accessible. The display above facing the front side of the machine and on the left side is the PH sensor board.

Temperature/Humidity & Light Sensors

The sensors to monitor the drum temperature, humidity and light intensity were fixed on the light mounting. This is the only spot I could find that will not be on the way of the moving plants or blocking the light.

Stepper Motor/Driver

PH probe/board

The PH probe is fixed on the dump pipe and submerged into the lower reservoir. Its board is fixed next to the Edison board.

Upcycle It - Washing Machine Hydroponic Grower - #8 Nutrient Solution System

messages@element14.com — Mon, 05 Jun 2017 00:39:39 GMT

On hydroponic systems, the growing medium has the only function to secure the plant roots in place so it doesn't have any means to nourish the plants as the soil does. Therefore, the water caring a nutrient solution is the sole source of nutrients to the plant.

Conventional hydroponic systems consist in a reservoir for the nutrient solution and a pump that delivers this solution to the growing trays as required. For rotary systems, the solution normally doesn't need to be pumped as the growing bed will be partly submerged into the reservoir so every complete turn will deliver nutrient to all plants inside the drum.

In our case, we have a limited volume of water we can store on the bottom of the washing machine drum so we have to combine the 2 methods. We will have the drum partially submerged so the growing medium can absorb the nutrient when dipping into it but due to its low volume it wouldn't last long without refilling it. So we need an auxiliary reservoir to store the nutrient and pump it into the drum when the drum level is low. The drum and the auxiliary tank will have a level switch. The one on the drum will trigger the pump to refill it and the one on the auxiliary reservoir will set an alarm to be manually filled.

Below is the nutrient solution system schematic.

Details of the items

Reservoir - Made using a plastic container. I drilled a hole and installed a threaded fitting with 2 "O" rings to seal the water. I also made a frame on the bottom of the washing machine using 20x20 mm aluminium equal angle so the plastic container is secured in place.

Water Pump - Original water pump connected to the reservoir

Water Level Adjustment - Made of 25 mm PVC Pipe, 2 x 90º Elbows and 1 x "T". Connected to the original flex joint that originally was connected to the water pump. I secured the pipe using a wingnut so we can change the water level adjusting the pipe height. Note that the top part of the pipe assembly is open; otherwise, it would become a siphon draining all drum water.

Water Level Sensor - The original drum water level switch is an interesting piece of equipment, it is a mechanical device that uses air pressure, created by the water weight on the bottom of the drum, to actuate a contact switch. I couldn't imagine but this mechanical sensor can be adjusted to the level we want turning the plastic screws on the back. It took a while to adjust it but I managed to have it switching off when the water inside the drum lowers below the accepted level. This sensor will be used to give a signal to turn the water pump on.

Besides the pump being started once the level inside the tumbler is low. it will also turn on in cycles for 10 seconds every hour to ensure the nutrient solution is refreshed.

Below is a short video of the water pump cycle testing.

Upcycle It - Washing Machine Hydroponic Grower - #7 Drum RPM Calculation

messages@element14.com — Mon, 05 Jun 2017 00:38:26 GMT

To start programming the stepper motor control, I did some tests having the stepper motor turning the drum at different pulse frequencies.

Checking some other rotary growing systems I found that it normally takes 30 to 45 minutes to give a complete turn. I found it very slow (about 0.025 RPM). The beauty of having a stepper motor is that we can virtually set it at any speed below its maximum RPM.

I decided to physically check the drum RPM applying different pulse frequencies to the stepper controller and measure the turn time. Doing this test I could get the constant relation in between pulse width (ms) and the actual drum RPM.

Below is the code for the testing. I set different pulse frequencies at different pins so I shift the pulse wire through the pins and measured the rotation time.

 
 
//Pulses pins 13, 9 & 8 at different frequencies
 
 
const int pulsePin13 = 13;             // pin 13 @ 1000ms (on board LED)
const long interval13 = 1000;          // interval at which to pulse pin (milliseconds)
int pinState13 = LOW;                  // set pinState to 0 
unsigned long previousMillis13 = 0;    // store last time pin was updated
 
 
const int pulsePin8 = 8;              // pin 8 @ 50ms
const long interval8 = 50;            // interval at which to pulse pin (milliseconds)
int pinState8 = LOW;                  // set pinState to 0 
unsigned long previousMillis8 = 0;    // store last time pin was updated
 
 
 
 
 
 
 
//Pin13
  if (currentMillis - previousMillis13 >= interval13) {
    // save the last pulse time
    previousMillis13 = currentMillis;
 
 
    // if the pin is off turn it on and vice-versa:
    if (pinState13 == LOW) {
      pinState13 = HIGH;
 
const int pulsePin9 = 9;              // pin 9 @ 100ms
const long interval9 = 100;           // interval at which to pulse pin (milliseconds)
int pinState9 = LOW;                  // set pinState to 0
unsigned long previousMillis9 = 0;    // store last time pin was updated
    } else {
      pinState13 = LOW;
    }
 
 
    // set the pin with the pinState of the variable:
    digitalWrite(pulsePin13, pinState13);
  }
 
 
 //Pin9
  if (currentMillis - previousMillis9 >= interval9) {
    // save the last pulse time
    previousMillis9 = currentMillis;
 
 
    // if the pin is off turn it on and vice-versa:
    if (pinState9 == LOW) {
      pinState9 = HIGH;
    } else {
      pinState9 = LOW;
    }
 
 
    // set the pin with the pinState of the variable:
    digitalWrite(pulsePin9, pinState9);
  }
 
 
//Pin8
  if (currentMillis - previousMillis8 >= interval8) {
    // save the last pulse time
    previousMillis8 = currentMillis;
 
 
    // if the pin is off turn it on and vice-versa:
    if (pinState8 == LOW) {
      pinState8 = HIGH;
    } else {
      pinState8 = LOW;
    }
 
 
    // set the pin with the pinState of the variable:
    digitalWrite(pulsePin8, pinState8);
  }
 
 
 
 
void setup() {
 
    pinMode(pulsePin13, OUTPUT);
    pinMode(pulsePin9, OUTPUT);
    pinMode(pulsePin8, OUTPUT);
       
}
 
 
void loop() {
 
 
  unsigned long currentMillis = millis();
 
}

The results are the following:

Pin 8: 50ms - 1m 15s per turn = 0.8RPM = 48RPH

Pin 9: 100ms - 2m 30s per turn = 0.4RPM = 24RPH

(I didn't take the time for 1000ms, it would take ages and I was happy with the consistency of the previous results)

This gives us an inversely proportional relation of 40. Therefore, dividing 40 for the required RPM, we can get the interval to set the program to give the required pulses.

As the drum will normally be set to under 1 RPM, seeing such small RPM values might be awkward so I am using RPH "Rotation per Hour".

At this stage will limit the range to be set from 1 RPH to 60 RPH (1 RPM). I don't need anything faster than 1 RPM but I might want to try the balearicdynamics suggestion injecting more gravity to the plants in the future. I am not sure about the results but it sounds fun.

Maybe in the future, we could also have a database with the best turning speed for the different group of plants so it can be easily set once we start a new cycle.

Below is a table with some values relating RPM, RPH and pulse interval.

RPM	RPH	Pulse Interval (ms)
0.0167	1	2400
0.0333	2	1200
0.1	6	400
0.1667	10	240
0.4	24	100
0.8	48	50
1	60	40

As we are going to inform the desired RPH through MQTT. Once we get the RPH value we need to calculate the Pulse Interval as following.

Pulse Interval = 2400/RPH

After all the boring stuff you can relax having a glimpse of the drum turning at 0.8 RPM or 48 RPH

[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #11: One of its kind!

messages@element14.com — Sun, 04 Jun 2017 20:43:27 GMT

Upcycle finished! The Hybrid Radio is ready

I published the first draft pic as a comment to my last post #10. Here is a better one.

This is my last post for the Upcycle-it Challenge,

During the last week of the project everything had to go according to plan. On Friday, June 2nd noon time, I had an almost finished radio that still needed some finishing touches, but it was working.

While I was in the process of preparing it and the software ready, more ideas and features came to my mind. Things that if you do not have something up and running to familiarize yourself with, you cannot even think of.

We live in the IoT era and experiment with it. I am not sure what the next leap will be. One thing is sure, I have come a long way from my first Intel 8080 and the ARPANET of the 300/75 bps modems to our wifi super fast society. I decided to participate in this Challenge as I wanted to experiment with new ideas. Intel Edison proved to be quite an interesting and powerful platform. As I have another board I am thinking to use for an upgraded version of the Web SDR Analog Radio Client.

It would be really nice if a friend or fellow Ham could share directly with you an interesting or rare reception the moment it takes place, and you could listen to it on your hardware right away.

Web SDR movement expands. Have a look at www.sdr.hu, and you can get a taste of it. Companies like ICOM, specializing in Amateur Radio equipment start using SDR technology in their products. KiwiSDR (http://kiwisdr.com/KiwiSDR/) lets you build a Wideband Web SDR server with a BeagleBone Black.

Although I have accomplished my task for my 1978 Panasonic vintage receiver, I want to continue my experimentation. There are plenty of vintage receivers to Upcycle, adding various flavors to them.

The idea with the OLED display and the building block from Sparkfun gave me the smallest possible footprint, but for the next project, I would opt for a larger screen.

Tuning to the same station both from my location through the analog portion of my receiver and the Web SDR portion of my Intel Edison I can compare the reception conditions of the same broadcasting transmission at two different locations in one panel and come with useful observations about Wave Propagation, just to name one important feature.

Wrapping the Panasonic receiver

Well, before wrapping it up, I had to open my receiver, carefully remove the antenna wire and the battery connections and put away the back comer. Then I removed the power supply, the speaker, the logo name plate and eventually the speaker metal front grill.

Getting ready to be recycled/

I decided to use a plexiglass front plate from a scrapped device that was a short of magnifying glass as well.

I mounted the Edison block on it with four screws. The most difficult part was to find a knob for the joystick button. All the possible places that I visited had knobs that had a larger square diameter than the one that was needed which was 2.2 mm. That was a problem. I should have thought of it earlier, but I was always under the impression that shops that sold such joystick buttons, would also have the right knob for it. As that was not true, I thought that I could print a 3d button from the local 3dhub print shops, but I needed the file in the right format for it. Delivery was next day, so I was still withing my plan. But I did not find such file. I contacted Sparkfun’s support, but they only had the pdf file of the switch that I had in the meantime traced (SF303GJ26-3).

So I decided to make one myself with the help of a friend that is more experienced on such mechanical tasks. The plastic axle of an Alps potentiometer was used for the purpose, as it had a small hole in the center. It was cut in the right length and the hole was enlarged to 2,2 mm so that it could be fit on the joystick. It was successfully fitted by 03:15 on Thursday morning and to mark the occasion we named our effort as the Midnight project.

We also had to change the two buttons on the OLED board, with ones that had longer axle, but that less difficult. We then cut a conical hole on the plexiglass for the joystick button and by 06:30 on Friday morning the Midnight project was over. During that time we also had to cut and bend the grill, fit a new 2 gang push button change-over switch and put everything together using simple tools. It was a great experience for me.

After some hours sleep, I had to make a small LM317 regulator board that would power the Edison with 4 volts, to be on the safe side, make the Audio and power connections and put everything back hoping that it would work.

That “easy” task took time to complete, as the schematics that I had found did not correspond to the pcb’s of my radio, but with patience everything was gradually resolved and I ended up with a working radio, a dual mode Hybrid, Web SDR & Analog Receiver. One of its kind if you really think of it. It combined all kind of technologies. A mechanical frequency dial, a switchable frequency counter and a Web SDR client with an OLED display powered by an Intel Edison. The 1978 receiver had been Upcycled to modern standards.

I was the proud and happy owner of it. Panasonic DR-28/ MK-I.

The last part of the software

In my last post, I had stopped with a version of the software that did not include and display on the screen. So I had to add the methods of displaying the Client commands on the screen.

While doing that, I had to adapt a basic concept of the client which was the number of frequency steps to match with the Web SDR server. Three frequency steps are provided. big (+++), medium (++) and small (+), which work cyclically with the Left and Right buttons of the Joystick. They correspond to +:0.1kHZ, ++:1kHz, +++:2.5/9kHz depending on the Mode.

Big frequency change is accomplished from the two separate Band switches (A and B) of the OLED module. My assigned bands are: LW, MW, 160m, 80m, 40m, 30m, 20m, 18m, 15m, 12m, 10m.

Mode (demodulation) is controlled from the Joystick’s center button and is assigned as: CW, LSB, USB, AM, FM, AM-s (Am-Sync).

Assuming that you select LW band where the broadcasts using AM modulation, the Frequency Stepping becomes 9 KHz(+++), 1 KHz(++), 0,1 KHz(+) . As Long Wave has a range of frequencies that expands from 153 KHz to 279 with a spacing of 9 KHz between the stations, even a single step of (+++) would be enough.

The code is listed below:

'use strict';
const CDP = require('chrome-remote-interface');
const mraa = require('mraa');
var edison = require('../node_modules/edison-oled/build/Release/edisonnodeaddon');
var keypress = require('keypress');
var verbose = true;
var delay = 50;
var smallDelay = 10;
var sleepTime = 5000;
/*
screen is 64 X 48
*/
var lcdWidth = edison.LCDWIDTH;
var lcdHeight = edison.LCDHEIGHT;
var oled = new edison.Oled();

function cleanUp() {
        oled.clear(0);
        oled.display();
}

function initOled() {
        if(verbose) {
                console.log('--setup screen');
        }
        oled.begin();
        oled.clear(0);
        oled.display();
        oled.setFontType(0);
        lcdWidth = oled.getLCDWidth();
        lcdHeight = oled.getLCDHeight();
        if(verbose) {
                console.log('---width: ' + lcdWidth);
                console.log('---height: '
function printError(message) {
        console.log("Err: " + meesage);
        printErrorOled(message);
}

function printErrorOled(message) {
        oled.clear(0);
        oled.setFontType(1);
        oled.setCursor(0, 0);
        oled.print("Error!");
        oled.setFontType(0);
        oled.setCursor(0, 15)
        oled.print(message);
        oled.display();
}

CDP((client) => {

        function killClient() {
                client.close();
                cleanUp();
        }

        var args = process.argv;
        if(args.length != 4) {
                console.log("Invalid execution: node websdr_controller_edison.js freq mode");
                killClient();
        } else {
                var MAX_STEP = 3;
                var step = 3;
                var currentMode = args[3];
                var currentFrequency = parseFloat(args[2]);
                const bands = [153, 522, 1800, 3500, 7000, 10100, 14000, 18068, 21000, 24890, 28000];
                const bandNames = ['LW', 'MW', '160m', '80m', '40m', '30m', '20m', '18m', '15m', '12m', '10m'];
                const modes = ['cw', 'lsb', 'usb', 'am', 'fm', 'amsync'];
                const modeNames = ["CW", "LSB", "USB", "AM", "FM", "AM's"];
+ lcdHeight);
        }
}
initOled();

function printError(message) {
        console.log("Err: " + meesage);
        printErrorOled(message);
}

function printErrorOled(message) {
        oled.clear(0);
        oled.setFontType(1);
        oled.setCursor(0, 0);
        oled.print("Error!");
        oled.setFontType(0);
        oled.setCursor(0, 15)
        oled.print(message);
        oled.display();
}

CDP((client) => {

        function killClient() {
                client.close();
                cleanUp();
        }

        var args = process.argv;
        if(args.length != 4) {
                console.log("Invalid execution: node websdr_controller_edison.js freq mode");
                killClient();
        } else {
                var MAX_STEP = 3;
                var step = 3;
                var currentMode = args[3];
                var currentFrequency = parseFloat(args[2]);
                const bands = [153, 522, 1800, 3500, 7000, 10100, 14000, 18068, 21000, 24890, 28000];
                const bandNames = ['LW', 'MW', '160m', '80m', '40m', '30m', '20m', '18m', '15m', '12m', '10m'];
                const modes = ['cw', 'lsb', 'usb', 'am', 'fm', 'amsync'];
                const modeNames = ["CW", "LSB", "USB", "AM", "FM", "AM's"];
                var currentBand = 0;
                var currentModeId = 3;
                var btnUp, btnDown, btnLeft, btnRight, btnSelect, btnA, btnB;

                function debounce(func, wait, immediate) {
                        var timeout;
                        return function() {
                                var context = this, args = arguments;
                                var later = function() {
                                        timeout = null;
                                        if (!immediate) func.apply(context, args);
                                };
                                var callNow = immediate && !timeout;
                                clearTimeout(timeout);
                                timeout = setTimeout(later, wait);
                                if (callNow) func.apply(context, args);
                        };
                };

                function sleep(ms) {
                                var now = new Date().getTime();
                                while(new Date().getTime() < now + ms){ /* do nothing */ }
                }

                function startScreen() {
                        if(verbose) {
                                console.log('--show start');
                        }
                        oled.clear();
                        oled.setCursor(9, 0);
                        oled.print("EDISON's");
                        oled.setCursor(0, 11);
                        oled.print("Web SDR ON");
                        oled.setCursor(0, 23);
                        oled.print("design by:");
                        oled.setCursor(3, 35);
                        oled.setFontType(1);
                        oled.print("SV1ONW");
                        oled.display();
                }

                function mainScreen(frequency, mode, step, band) {
                        oled.clear(0);
                        oled.setFontType(1);
                        let firstPartFreq = Math.floor(frequency);
                        oled.setCursor(calcOffset(firstPartFreq)*8, 0);
                        oled.print(firstPartFreq);
                        // First part of Frequency string
                        oled.setCursor(46, 4);
                        oled.setFontType(0);
                        let secondPartFreq = (frequency % 1).toFixed(3).substring(2)
                        oled.print(secondPartFreq);
                        // Second part of Frequency string
                        oled.setCursor(0, 15)
                        oled.print("Mode: " + mode);
                        //AMsync becomes AM's
                        oled.setCursor(0, 26);
                        oled.print("Band: " + band);
                        oled.setCursor(0, 37);
                        oled.print("Step: " + step);
                        oled.display();
                }

                function calcOffset(num) {
                        if(num > 0 && num < 10) {
                                return 4;
                        } else if(num >= 10 && num < 100) {
                                return 3;
                        } else if(num >= 100 && num < 1000) {
                                return 2;
                        } else if(num >= 1000 && num < 10000) {
                                return 1;
                        } else if(num >= 10000) {
                                return 0;
                        }
                }

                function initButtons() {
                        btnUp = initButton(46, freqUp);
                        btnDown = initButton(31, freqDown);
                        btnLeft = initButton(15, stepLeft);
                        btnRight = initButton(45, stepRight);
                        btnSelect = initButton(33, nextMode);
                        btnA = initButton(47, bandUp);
                        btnB = initButton(32, bandDown);
                }

                function deregisterButtons() {
                        btnUp.isrExit();
                        btnDown.isrExit();
                        btnLeft.isrExit();
                        btnRight.isrExit();
                        btnSelect.isrExit();
                        btnA.isrExit();
                        btnB.isrExit();
                }

                function initButton(pinIn, callback) {
                        let btn = new mraa.Gpio(pinIn);
                        btn.dir(mraa.DIR_IN);
                        btn.isr(mraa.EDGE_RISING, callback);
                        return btn;
                }

                function intro() {
                        console.log("Frequency down ['j'] / up ['k'].\nStep size down: ['h'] / up ['l'].\nBand down: ['i'], Band up: ['o'].\nC$
                        printStatus();
                }

                function addKeyPressListener() {
                        // make `process.stdin` begin emitting "keypress" events
                        keypress(process.stdin);
                        // listen for the "keypress" event
                        process.stdin.on('keypress', keyPressEvent);
                        process.stdin.setRawMode(true);
                        process.stdin.resume();
                }

                function changeStep(stepIn) {
                        step = stepIn;
                        printStatus();
                }

                function changeFreq(up, step) {
                        var str = up ? '+' : '-';
                        client.send('Runtime.evaluate', {'expression': 'freqstep(' + str + step + '); nominalfreq();'}, (error, response) => {
                                if(error) {
                                        console.log(error);
                                        return;
                                }
                                currentFrequency = response.result.value;
                                printStatus();
                        });
                        //if(verbose)
                        //      console.log('stepped ' + (up ? 'up' : 'down'));
                }

                function setFreq(freq) {
                        client.send('Runtime.evaluate', {'expression': 'setfreq(' + freq + '); nominalfreq();'}, (error, response) => {
                                if(error) {
                                        console.log(error);
                                        return;
                                }
                                currentFrequency = response.result.value;
                                printStatus();
                        });
                }

                function setBand(up) {
                        if(up) {
                                currentBand += 1;
                                currentBand = currentBand >= bands.length ? 0 : currentBand;
                        } else {
                                currentBand -= 1;
                                currentBand = currentBand < 0 ? bands.length - 1 : currentBand;
                        }
                        setFreq(bands[currentBand]);
                }

                function setMode(mode) {
                                client.send('Runtime.evaluate', {'expression': 'set_mode(\'' + mode + '\'); nominalfreq();'}, (error, response$
                                if(error) {
                                        console.log(error);
                                        return;
                                }
                                currentFrequency = response.result.value;
                                printStatus();
                        });
                        currentMode = mode;
                }

                function queryFrequency() {
                        client.send('Runtime.evaluate', {'expression': 'nominalfreq()'}, (error, response) => {
                                if(error) {
                                        console.log(error);
                                        return;
                                }
                                currentFrequency = response.result.value;
                        });
                }

               function printStatus() {
                        let currentModeName = modeNames[currentModeId];
                        let currentBandName = bandNames[currentBand];
                        let currentStepStr = step == 1 ? "+" : (step == 2 ? "++" : "+++");
                        console.log('Frequency: ' + parseFloat(currentFrequency).toFixed(3) + 'kHz, Band: ' + currentBandName + ', Mode: ' + c$
                        mainScreen(currentFrequency, currentModeName, currentStepStr, currentBandName);
                }

                function keyPressEvent(ch, key) {
                        //console.log('got "keypress"', key);
                        if (key && key.name == 'k') {
                                freqUp();
                        }
                        else if (key && key.name == 'j') {
                                freqDown();
                        }
                        else if(key && key.name == 'h') {
                                stepLeft();
                        }
                        else if(key && key.name == 'l') {
                                stepRight();
                        }
                        else if(key && key.name == 'o') {
                                bandUp();
                        }
                        else if(key && key.name == 'i') {
                                bandDown();
                        }
                        else if(key && key.name == 'm') {
                                nextMode();
                                //queryFrequency();
                        }
                        else if (key && key.ctrl && key.name == 'c') {
                                process.stdin.pause();
                                killClient();
                       }
                }

                var freqUp = debounce(function() {
                        changeFreq(true, step);
                }, smallDelay);

                var freqDown = debounce(function() {
                        changeFreq(false, step);
                }, smallDelay);

                var stepLeft = debounce(function() {
                        step = step - 1;
                        step = step < 1 ? MAX_STEP : step;
                        changeStep(step);
                }, delay);

                var stepRight = debounce(function() {
                        step = step + 1;
                        step = step > MAX_STEP ? 1 : step;
                        changeStep(step);
                }, delay);

                var nextMode = debounce(function() {
                        currentModeId += 1;
                        currentModeId = currentModeId >= modes.length ? 0 : currentModeId;
                        currentMode = modes[currentModeId];
                        setMode([currentMode]);
                }, delay);

                var bandUp = debounce(function() {
                        setBand(true);
                }, delay);

                var bandDown = debounce(function() {
                        setBand(false);
                }, delay);

                intro();
                //addKeyPressListener();

                startScreen();
                sleep(sleepTime);
                if(verbose) {
                        console.log('--show main screen');
                }
                setFreq(currentFrequency);
                printStatus();
                initButtons();
        }
}).on('error', (err) => {
  // cannot connect to the remote endpoint
  printError(err);
});

Autostart

If you want to make the client start automatically when you boot Edison, follow these steps (adapted from Stepanie Moyerman's blog post):

Disable the keyboard event listener by commenting out the following line in websdr_controller_edison.js:

. . . intro(); // addKeyPressListener();  <--- (line 330)  startScreen(); sleep(sleepTime); if(verbose) { console.log('--show main screen'); } setFreq(currentFrequency); printStatus(); initButtons(); . . .

Create a shell script in /etc/init.d, by calling it something like start_websdr.sh and add the following (make sure you enter the correct path to where you have cloned the client into, and the parameters for the starting script; see above for details):

#!/bin/sh  ### BEGIN INIT INFO # Provides:   start_websdr # Required-Start: # Required-Stop: # Default-Start:     2 3 4 5 # Default-Stop:      0 1 6 # Short-Description: starts the websdr client ### END INIT INFO cd path_to_where_websdr_client_is_installed ./websdr.sh websdr_server_url start_freq start_mode

Make the script you have just made executable via chmod +x start_websdr.sh
Finally, make sure the script is executable every time linux boots:

$ cd /etc/init.d/ $ update-rc.d start_websdr.sh defaults

For the latest version of the code, the initialization script and the automation script files, including installation instructions, you can look at the following GitHub link: https://github.com/sinantie/websdr

The video

Thanks to my colleague and good friend Thanos, SV1IVK, I have a better video now.

Credits

In closing I would like to thank my wife Roula for her patience during the whole time of the project, my son and fellow Radio Ham Yannis for his great assistance with code development and js, my daughter-in-law Maria for sharing her web experience with me and our family friend George that helped me with the mechanical portion of the portion.

Thank you team.

Published Posts
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #1: Introduction
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #2: Software Concept
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #3: Meeting with Edison
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #4: Software Challenges with Edison
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #5: The Software Challenge goes on
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #6: Changing the Display
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #7: Hardware is ready!
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #8: Problem with Audio.
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #9: Problem with Browser
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #10: Making the Web SDR Client work!
[Upcycle it Design Challenge] Embedded Web SDR client on Analog Radio Receiver #11: One of its kind!

UpCycle IT - R2I - BackONTrack

messages@element14.com — Sun, 04 Jun 2017 07:09:00 GMT

UpCycle IT - R2I - Hot2Not

UpCycle IT – R2I INDEX:

Blog #1_”Introduction”

Blog #2_”Designing”

Blog #3 "The Kit"

Blog #4_"Mother Natures Version"

Blog #5_"Research"

Blog #6_"Competition01"

Blog #7_"Edison Setup"

Blog #8_"Edison 2 Ardunio"

Blog #9_"Grove-ON"

Blog #10_"Hot2Not"

Blog #11_"BackONTrack"

Blog #11 - BackONTrack

Ah good times! Sometimes you can be stuck on a single problem for days and days, other times you can be so lucky as to come across a simple fix that has you back working in just a few hours!

Today was one of the good days.

In my last blog I was feeling a little down because while I had success with the Temperature sensor, the LCD RGB Backlight didn't work and I was concerned it would take some modifying to get it doing what it should.

Instead some more research showed me that I had not been as aware of the features of the Base Shield as I should have been.

In the yellow circle you will see a little switch for going from 3.3 V to 5V. By default it was set for 3.3V. This allowed my Temperature Sensor to function (although due to the math being based on 5v it was not correct) but my LCD would not. Switching this over to 5V quickly changed the situation to R2I being Back On Track!

Okay, let's try that Hello World example again!

I have to agree with Mr. Powers on this one!!!

Okay, so we have our LCD working! But Hello World really isn't going to do much for the R2I project, so time to modify a little of that example code and come up with something better for this purpose!

/* Hello World and Grove Temperature Sensor sketches modified for use

in displaying temperature to lcd.

#include <Wire.h>

#include "rgb_lcd.h"

rgb_lcd lcd;

const int colorR = 0;

const int colorG = 0;

const int colorB = 255; //BLUE

const int pinTemp = A0; //Temp

const int B = 3975; //Temp

void setup()

{

Serial.begin(9600); //Temp

// set up the LCD's number of columns and rows:

lcd.begin(16, 2);

lcd.setRGB(colorR, colorG, colorB);

// Print a message to the LCD.

lcd.print("E14-R2I Project");

delay(1000);

}

void loop()

{

int val = analogRead(pinTemp);

float resistance = (float)(1023-val)*10000/val;

float temperature = 1/(log(resistance/10000)/B+1/298.15)-273.15;

float ftemp = temperature * (9.0/5.0) + 32.0;

// set the cursor to column 0, line 1

// (note: line 1 is the second row, since counting begins with 0):

lcd.setCursor(0, 1);

// print the number of seconds since reset:

lcd.print(ftemp); //TEMP

delay(100);

}

/*********************************************************************************************************

END FILE

*********************************************************************************************************/

Combining elements from the Temperature sketch and the Hello World sketch and changing Hello World to blue E14-R2I Project brings the LCD to a much nicer look for what I want.

I used Green to highlight the key spots, there are a few more changes not displayed due to size of picture, but it is the main part.

So let's see what this Sketch will give us now!

Yes I definitely like this better! I had turned on my space heater as well so the combination of the heater right below my work area as well as using the correct voltage brings a tad more understandable temperatures into view.

Deciding to play with a little more code and the Grove LED option, I added a section that would check and see if the temperature was between a certain range and turn on the LED if it is.

The idea with this was a quick way to display how the temperature sensor will pickup changes and the LED will display a range of interest.

This can later be applied with the Relay and the heat element to keep the incubator at a programmed temperature and not too cold or too hot.

Here is my Temp2LCD2LED Sketch:

/* Hello World and Grove Temperature Sensor sketches modified for use

in displaying temperature to lcd. LED activated if TEMP is in a

range to simulate heat element for R2I project

#include <Wire.h>

#include "rgb_lcd.h"

rgb_lcd lcd;

const int colorR = 0;

const int colorG = 0;

const int colorB = 255; //BLUE

const int pinTemp = A0; //Temp

const int B = 3975; //Temp

const int pinLed = 3; //LED

void setup()

{

Serial.begin(9600); //Temp

pinMode(pinLed, OUTPUT); //LED

// set up the LCD's number of columns and rows:

lcd.begin(16, 2);

lcd.setRGB(colorR, colorG, colorB);

// Print a message to the LCD.

lcd.print("E14-R2I Project");

delay(1000);

}

void loop()

{

int val = analogRead(pinTemp); //Temp

float resistance = (float)(1023-val)*10000/val; //Temp

float temperature = 1/(log(resistance/10000)/B+1/298.15)-273.15; //Temp

float ftemp = temperature * (9.0/5.0) + 32.0; //Temp

if ((ftemp > 79) and (ftemp < 90)) digitalWrite(pinLed, HIGH); //LED

if ((ftemp < 80) or (ftemp > 89)) digitalWrite(pinLed, LOW); //LED

// set the cursor to column 0, line 1

// (note: line 1 is the second row, since counting begins with 0):

lcd.setCursor(0, 1);

// print the number of seconds since reset:

lcd.print(ftemp);

delay(100);

}

/*********************************************************************************************************

END FILE

*********************************************************************************************************/

So key parts now are we are watching for Temp to be less than 80 and the LED is unlit. More than 89 and the LED is unlit. But if the temp is between 80 & 89 the LED will illuminate. Easily allowing us to imagine where instead I would require the heat to come on if the temperature is too low and shut off at a certain point. That is a simpler piece of logic but I wanted to show the Sensor off with the LED. :-)

Here we can see the temperature is below 80 so the LED is unlit. Yes I know, in the incubator now I would actually want to be applying heat, but this is for demonstration purposes.

Now the temperature is greater than 80 and the LED is illuminating.

And here we have exceeded the 89 degree limit and the LED has went to an unlit state.

What I will end up doing later is implementing the LED as an external display of when the heat is on or off.

So far so good! More to come!

UpCycle IT - R2I - Hot2Not

messages@element14.com — Sun, 04 Jun 2017 01:47:00 GMT

UpCycle IT - R2I - Grove-ON!

UpCycle IT – R2I INDEX:

Blog #1_”Introduction”

Blog #2_”Designing”

Blog #3 "The Kit"

Blog #4_"Mother Natures Version"

Blog #5_"Research"

Blog #6_"Competition01"

Blog #7_"Edison Setup"

Blog #8_"Edison 2 Ardunio"

Blog #9_"Grove-ON"

Blog #10_"Hot2Not"

Blog #10 - Hot2Not

As I had mentioned in blog #9 I am interesting in getting the temperature sensor and the lcd display rolling together since it seems a great duo to work with my project. Let's see how well they play together with the Intel Edison!

The Base shield is pretty straight forward, with the pin layout it can only appropriately fit one way to the Intel Edison board.

Grove - Temperature Sensor:

Here is the Temperature sensor that we will use.

Going with the suggestion from our Handy/Dandy info page I used the first Analog port, A0 for our temperature sensor.

In Blog #9 we pulled the Grove Examples into our IDE for our own use. Here is the Grove_Temperature_Sensor example we will work with.

Pretty straight forward, go ahead and upload it over to your Edison.

Error!!! Ah, I see that Will Robinson must have switched over to Com8, the Edison does have 2 usb connections and I want to use Com7 for my setup. So if you get an error you may want to verify you are on the right communications port!

Success!!! Always the preferred result.

Let's take a look at our Serial Monitor since that is where we will be displaying the Temperature sensor results.

Here we have the basic data coming from out Temperature Sensor. Yes it is a tad chilly in my office.

Here I actually cupped the sensor in my hand to provide a little more heat to show it adjusting it's data with temperature change.

To make it easier for my American brain I added a line that took Celsius and converted to Fahrenheit.

// Calculate F temp

float ftemp = temperature * (9.0/5.0) + 32.0;

Finally to make it cleaner, I added some text to explain exactly what was what.

// Print the temperature to the serial console.

Serial.print("Celcius = ");Serial.println(temperature);

Serial.print("Fahrenheit = ");Serial.println(ftemp);

Okay let's take a look at that LCD Display and hopefully eventually push our Temperature results to the LCD.

Grove - RGB Backlight LCD:

Here we go, v4.0 even.

Here we have the LCD plugged into the 2nd I2C port per the Handy Dandy info page. Keeping it simple!

Let's go ahead and load the tried and true favorite, Hello World as an example test.

Hmm, not what I was hoping for.

I tried several other examples and while it looks like the sketch loads fine the LCD does not actually display the appropriate messages.

Looking online I found some references that suggested hardwiring some additional pieces in to resolve this but I want to fully explore Grove first to see if they have updated information. It seems contrary to their kit idea to have to start throwing additional pieces at their devices that were not included.

So the Temperature Sensor was a success hence the Hot part of the Title.

Sadly the LCD wasn't, explaining the 2Not part.

I am going to keep researching since the LCD seems a perfect part of the kit to use, so stay tuned!

[Upcycle It] Interactive Race Car Driver - The Checkered Flag

messages@element14.com — Sat, 03 Jun 2017 22:28:50 GMT

"What will you make?" asked the Intel Edison. The objective of the project was to upcycle an old RC car and a Furby to create an Interactive Race Car Driver using the Intel Edison and scrap or recycled components.

Car

One of the key features that attracted me to the car was that it had 4 screws located at the front and back. I knew those would make a good mounting point for a frame to which I could attach my components. The frame was printed using with recycled filament that used to be car dashboards. The screws came from old PCs and keyboards.

The middle of the car housed the RC module and a container for the original battery pack. I checked if the H-Bridge of the RC module could be reused on a simulator and then in reality. It was designed never to stop so would not work for my project. So that was removed and swapped with an off the shelf module. The middle of the car was cut down and rewired using old PC cables.
Another feature that appealed to me was the 4 wheel drive skid steer setup of the motors. However only 3 of my 4 wheels were working so I had to repair the gearbox. Which I did with some gears from the spares box.
To my frame I attached lights and bumpers, along with a battery box. The lights were upcycled too, a broken downlight was disassembled to extract the LEDs for the headlights. 3mm RED LEDs for brake lights were salvaged from a keyboard, theses have yet to be incorporated into the car.

I wanted the Edison to take pride of place so I styled that as the engine with the aid of some 3D printed parts, these were printed using recycled P.E.T. which used to be drink bottles.

To simplify testing and wiring I used the grove shield and connectors. I put my own sockets on the breakout boards for the motor and lights. The boards I used for the lights were upcycled from some scrapped protoshields with poor quality silk screen that AverageManVsPi sent me last year. The wiring for these boards was also upcycled where possible using old telephone cables. The bumper was also 3D printed and fitted with microswitches. The switches came from a broken shredder. The car is powered from a phone powerbank which clips onto the back of the car with 3D printed clips. Unfortunately my 3D print broke before I finished printing all the parts but temporary parts have been made from wood.

All the 3D models can be found at: https://github.com/Workshopshed/UpcyclingDesignChallenge

Driver

The main donor component for the driver was a first generation Furby from the 1990s. Like the car this had it's H-Bridge swapped out with an off the shelf module. Also removed were the 2 chip on board modules that used to control the motion and sounds. These were replaced with wires that connected up to the Edison via some simple level shifters. The level shifters were made using more scrap protoshields and some transistors that most likely came from a radio.

The Furby's motion is driven from a series of cams. The position of those is sensed with a mechanical home switch and an optical sensor that pulses as the cam rotates. The LED for that sensor was replaced as it did not seem to be working. The output of the sensor went through some conditioning circuity to transistor to shift the signal level down to 1.8v for the Edison. The MCU was programmed to detect the pulses and count them.

To give the Furby a voice a USB audio card was plugged into the Edison. This was modified to have a micro USB connector. An amplifier module was added to drive the Furby's original speaker.

I got my daughter to record her best Furby impersonations and these were chopped into segments and copied to the Freddie board.

Upcycling summary table

Item	Origin
Radio controlled Car	Surplus store sometime in 1995.
Furby	Probably from a toyshop in late 1990s early 2000s.
Wire	Telephone Cable PC Power Cable
PCBs	Scrapped Protoshield
Nuts, Bolts, Screws	Decomissioned PCs and broken domestic appliances
Microswitches	Shredder
LEDs	Headlight LEDs from broken downlighter Brakelights from computer keyboard
Level shifter transistors	Most likely from an old radio
Filament	ABS recycled from car dashboards PET recycled from drink bottles
Wood	Sprue from Dollshouse Offcuts from other projects

Software

Right from the start I decided to standardise on NodeJS for the code. I also wanted to be able to control the car from a phone or tablet. I wrote a simple web UI that connected back to the Edison using MQTT over Sockets. This was secured using certificates.

To read the signals from the optical sensor, the Furby uses the Edison's MCU and reports that back to the control software allowing the position of the action cam to be known. The Furby also hooks into MQTT too and responds to events from the car.

All the software can be found at: https://github.com/Workshopshed/UpcyclingDesignChallenge

Car and Driver

{gallery} Closeups
Engine Bay: Wiring for lights, bumpers and motors, power converter to right
Fuel Tank: The power for the car, the original on/off switch still disconnects the power
Under the seat: Level shifters, audio, power and Edison to control the Furby
Car Engine: The Edison is what powers this beast of a car
Car and Driver: Completed car and driver
Car and Driver: Completed car and driver
Car and Driver: Completed car and driver

{gallery} Closeups

Engine Bay: Wiring for lights, bumpers and motors, power converter to right

Fuel Tank: The power for the car, the original on/off switch still disconnects the power

Under the seat: Level shifters, audio, power and Edison to control the Furby

Car Engine: The Edison is what powers this beast of a car

Car and Driver: Completed car and driver

Car Demo

Car test using some simple nodeJS scripts.

Motion test

Light test

Driver Demo

Coming Soon

Thanks

Firstly to my family for putting up with 10 weeks of my madness and for their help, feedback and motivation.

Thanks to Intel for the Edisons, sponsoring the challenge and providing a great set of tools, documentation and O/S images.
Element14 for hosting the challenge.
Fellow challenges for their suggestions and ideas.
Previous Furby hackers: Kelly Heaton, Chris Brown and Northwestern University Mechatronics Design Laboratory
Harry Fairhead for his excellent notes on life at 1.8v.
Thomas Stratford and Alan Barnet for identifying my mystery transistors.
Brian and Enrico who offered to print parts when my printer broke.
And to the Element14 and Twitter communities for their encouragement.

Upcycled Clock – Summary

messages@element14.com — Sat, 03 Jun 2017 22:01:22 GMT

The last couple of months have been a lot of fun taking part in the challenge, and here is a quick summary of all the features I was able to implement as part of the challenge. I have managed to achieve most of the features I initially planned as part of the proposal, with a couple of deviations. And, with the build of the clock and circuit completed, this put me in a good position to add more software features to the clock in the future. Here is an before and after picture side by side

Features Implemented

Here are the list of features I have managed to implement using the Intel Edison.

Visual indicator using diffusion panels - as part of the build five glass panels were switched out for 3D printed LED diffusion panel, which are meant to give an visual indicator when I wake up in the morning. Here is a brief description of the panels -
- Weather - this lights up based on the weather conditions from openweathermap.org. Yellow for sunny, blue for rainy and white for cloudy.
- Traffic – based on the Google Maps Distance Matrix API, gives me an indicator if I need to leave early because of heavy traffic.
- Twitter - this will be set to blue , if the hashtag that I am tracking has been used more that 5 times in a tweets today on the twittersphere.
- Gmail - this panel will light up red, if I have more than 10 unread messages, and green if less than 10.
- Home - this panel is to monitor values from the Air quality and Temperature sensors connected to the back of the clock.
Getting more info from the LCD panel - there are two more glass panels that were replaced on the clock to house an Grove LCD and two buttons and a potentiometer, which are used to set alarms, show the weather condition, temperature and humidity outside, and also show temperature and air quality sensor values. In addition, you can also get the IP address assigned to the Intel Edison just in case you have to ssh in for maintenance, and also switch off/on you phillips-hue smart bulbs at home.
Making the clock Speak in the morning - as part of the setup I am using an amplifier and speaker connected to the USB sound card, to read out the weather condition,the latest 5 tweets for a specific hashtag that I am tracking. As part of this feature, I would also like to add the top 5 news headline in a future enhancement.
Uploading sensor data to Cayenne - this feature was a great addition to the clock, and was a result of meeting the folks from myDevices at the Bay Area Makerfaire a couple of weeks ago.Basically as part of this feature, I am uploading the temperature,Light and Air quality sensor to Cayenne IoT dashboard.I have just touched the surface with this, and would like to explore a couple of more features in future.
Make the clock speak after the door is opened (post challenge) – this feature uses an ESP8266 and Magnetic contact switch aka a door sensor to detect the opening of my front door, when I get home from work in the evening. Once the door is opened, the ESP8266 publishes a MQTT message on a topic which the Intel Edison subscribes to, and then reads out the weather condition, temperature at home and tweet with a specific hashtag

Electronics and Upcycling the clock

Here are the list of sensors used as part of the build, connected to the Intel Edison Arduino board

Pin#	Sensor connected
A0	Potentiometer which is used to control features on the clock and display things like weather condition, Temperature etc.
D2	Top green button
D3	Yellow button at the bottom
D5	Grove buzzer sensor for sounding the Alarms
D11	Data line of the LED strip (APA102)
D13	Clock line of the LED strip
A1	Grove Air quality sensor v1.3
A2	Grove temperature sensor
A3	Grove Light sensor
I2C A4, A5	Grove RGB LCD display connected to the I2C connector on the Grove shield

In addition, I am using Adafruit’s Stereo 3.7W Class D Audio Amplifier - MAX98306 with a 4 ohms 3 watt speaker connected to the USB sound card, which you see on the left of the picture above. But I should have ideally gone with Adafruit Mono 2.5W Class D Audio Amplifier - PAM8302, since I am using only one speaker,which means I will have to order one later.

To power the Intel Edison, I am using the power adapter that came in as part of the kit that is Triad Magnetic Power Supply 1 Output 24 W 12 V,2 A .And to power the LED strip I am currently using another power adapter 5V and 2.5 A.

As part of the build,I had to remove the glass panels and replace them with something that would not impact the rustic look and aesthetic of the old clock. So, I set-out and designed the panels in Autodesk Fusion 360 and 3D printed them in Sunlu wood filament , which I then sanded and stained using Mirmax Wood finish. And for the LED diffusion parts of the panel were dual 3D printed using Hatchbox transparent PLA, in combination with another matching color PLA.

List of blog posts

Here are the list of blog posts written as part of the challenge, most of the blog posts which include code also include setup instructions on the Intel Edison which you can tweak to include in your own projects.

Upcycled Clock #1– Project details

Upcycled Clock #2- 3D printing parts to hold buttons, pot and LCD

Upcycled Clock #3 - Showing IP address and temperature on Grove LCD

Upcycled Clock #4 - Unleash the power using IFTTT

Upcycled Clock #5 - Reading out the weather using eSpeak

Upcycled Clock #6- Reading out tweets on a Bluetooth speakers

Upcycled Clock #7 - Testing the RGB LED strip

Upcycled Clock #8- Commute time to work using Google Maps API

Upcycled Clock #9 - 3D Printing panels

Upcycled Clock #10 - 3D Printing LED diffusers for the panels

Upcycled Clock #11- posting sensor data to Cayenne

Upcycled Clock #12 -Soldering and more 3D printing

Upcycled Clock #13- LED diffusion panel Integration

Upcycled Clock #14-Display data on the Grove LCD

Upcycled Clock #15- Detect door opening (post challenge)

Software

The code for the project and the blog post above, has been uploaded to Github at

https://github.com/CJAndrade/Upcycled-Clock/

Video Demo

Conclusion

In conclusion, I would like to thank element14 and Intel to hosting and sponsoring this awesome challenge. And in addition, I would also like to say a big thank you to all the other challengers and members of the element14 community, who commented on my blog post with suggestion and positive feedback and CharlesGantt for featuring my updates on the weekly challenge summaries. And a big shout out to rscasny, whom I had an opportunity to meet in person at the Bay Area Makerfaire for re-shipping my kit, after UPS returned package back to Chicago.

As part of next steps after the challenge, I plan to clean up the code on github and also have a couple of extra features I would like to implement, so remember to check out the blog posts using the tag - UpcycledClock