Electronic:

From inert to connected

A connected Green House? How?

during the design of this project, I have attacked the electronic part.

I have tried to define connected and what was the relevant informations the Green House shoud send and what interaction the user should have with it. Then I have made a reality check with my expertise and the time-frame left

bluetooth communication : it was really important for me that the communication between the user and the Green House was fast and easy. the Bluetooth fill that role.

Sensors : I have already said that I want humidity, temperature and luminosity so my board has to be able to do that

Motor : I need at least a motor for the door/aeration so I have to plan accordingly my design

The creation of the board itself

I have use KIKAD to made the schematic and PCB. The board itself was made via chemical etching in Denis's lab ( thanks for having us! ) and i can't thanks enough a friend of mine, Benoit who teach me most of what I know on this field now :)

Now that I know what my board is supposed to do, time to hit the keyboard!

You can find the schematic and PCB of the board in the picture below. Everything is SMD, except the connectors in PDIP

Main Components Table

Component	Quantity	Comment
Microcontroller : Homemade board	1	This will be my main microcontroller
bluetooth module : HC-05 Bluetooth	1	This is the bluetooth module I'll use to connect to the computer or phone.
DHT 11 sensors	3	My sensor for temperatur and humidity
Photo resistor	3	This servo can rotate 360°, I will use it to make the minutes' LED turn around the clock
Servo motor	1	I will use this to move the aeration door

I have highlighted few points on the schematic who differ from "standard board" :


This is the power supply part of the schematic. It consists of 2 Low-Dropout Linear Regulator LM1117, one for the board (5V) and another which can be used for the servo (It makes possible to have a different voltage for the servo if needed).


This is the ADC part of the schematic. I'll use ADCs to measure the light received.
To achieve that, I've made a Voltage divider with 5V as input voltage, a photo-resistor as the first resistor (connected through the pin headers), the output connected to an ATMega328 Analog to Digital converter and finally a second resistor of 10k connected to the ground.


This is one of the main component of my schematic. It'll be used to retrieve the Temperature and Humidity values from a DHT11 module.
I've followed the recommendation (for the 1-Wire bus) and added a Pull up resistor on the signal pin.


The servo connections.
I'll use a servo with a standard Graupner wiring (Orange => Signal, Red => +, Brown => -).
S0, 1, 2 are connected to a digital output from the ATMega328.


This is the Button part of the schematic. I added this in the case I needed buttons (which is not the case).
I've used a 10k resistor as pulldown resistor.

With all if these goodness, I can connect 3 sensors such as DHT11, 3 Photosensors and 3 motors. Maybe a bit overkill but it should suffice to most usage

DHT11 basic temperature-humidity sensor

Here are the ranges and accuracy of the DHT11 and it's datasheet:

• Humidity Range: 20-90% RH
• Humidity Accuracy: ±5% RH
• Temperature Range: 0-50 °C
• Temperature Accuracy: ±2% °C
• Operating Voltage: 3V to 5.5V

Photosensitive Sensor Module

An LDR is a component that has a (variable) resistance that changes with the light intensity that falls upon it. This allows them to be used in light sensing circuits.

Here I will simply use it to read the level of luminosity from the ldr (a value between 0-1023)

Chemical etching

Once the schematic and the .pcb finished, time to etch it

The technique itself is quite easy but require some know-how and numerous operations. You will find below an overview of these steps

Quick testing fo the board

Everything seems fine and no short-circuits so I have tested the board with the networking assignment (the breadboard seen in the video has been replaced by a real board later :) )

Greenhouse board to Breadboard


Greenhouse board to Breadboard

The code or the heart of the project!

I have my board, sensors and motor and all working, some cleverness was needed

                            
#include <DHT.h>
#include <Servo.h>

#define DHTTYPE DHT11
#define DHT0PIN 7
#define DHT1PIN 6
#define DHT2PIN 5

#define SERVO0PIN 10
#define SERVO1PIN 9
#define SERVO2PIN 8

#define PHOTO0PIN A2
#define PHOTO1PIN A1
#define PHOTO2PIN A0

#define BUTTON0PIN 2
#define BUTTON1PIN 3
#define BUTTON2PIN 4

#define TIMER_PERIOD 200

#define SERVOANGLEOPEN 10
#define SERVOANGLECLOSE 168
#define SERVOANGLEDEFAULT 90

int Temp = 30;
int Hyst = 1;

DHT dht0(DHT0PIN, DHTTYPE);
DHT dht1(DHT1PIN, DHTTYPE);
DHT dht2(DHT2PIN, DHTTYPE);
DHT dht[] = {dht0, dht1, dht2};

Servo s0;
Servo s1;
Servo s2;
Servo s[] = {s0, s1, s2};
int sPin[] = {SERVO0PIN, SERVO1PIN, SERVO2PIN};
int sValues[] = {SERVOANGLEDEFAULT, SERVOANGLEDEFAULT, SERVOANGLEDEFAULT};

float te[] = {0, 0, 0};
float hu[] = {0, 0, 0};

char photoPin[] = {PHOTO0PIN, PHOTO1PIN, PHOTO2PIN};
char buttonPin[] = {BUTTON0PIN, BUTTON1PIN, BUTTON2PIN};

int lValues[] = {0, 0, 0};

int interruptCounter = 0;

String inputString = "";
boolean stringComplete = false;

void setup() {
  setupDHT();
  //setupServo();
  setupButton();

  analogReference(EXTERNAL);

  inputString.reserve(200);
  Serial.begin(9600);
}

void setupDHT() {
  dht0.begin();
  dht1.begin();
  dht2.begin();
}

/* void setupServo() {
  s0.attach(SERVO0PIN);
  s1.attach(SERVO1PIN);
  s2.attach(SERVO2PIN);
}*/

void setupButton() {
  pinMode(BUTTON0PIN, INPUT);
  pinMode(BUTTON1PIN, INPUT);
  pinMode(BUTTON2PIN, INPUT);
}

void loop() {
  delay(10);
  // put your main code here, to run repeatedly:
  if (stringComplete) {
    processSerial(inputString);
    inputString = "";
    stringComplete = false;
  }

  interruptCounter++;
  if (interruptCounter > TIMER_PERIOD) {
    interruptCounter = 0;
    for(int i = 0; i < 3 ; i++ ) {
      float t = readTemp(i);
      float h = readHumid(i);
      if (!isnan(h) && !isnan(t)) {
        hu[i] = h;
        te[i] = t;
      }
    }
  }

  for(int z = 0; z < 3; z++) {
    //checkTemp(z);
    checkLum(z);
  }
}

void checkLum(int moduleNumber) {
  int sVal = analogRead(photoPin[moduleNumber]);
  if(sVal > 0) {
    lValues[moduleNumber] = sVal;
  }
}

//Hysteresis. At 31° => Open door. At 29° => Close door
void checkTemp(int moduleNumber) {
  if(te[moduleNumber] >= Temp + Hyst) { // Changer signe
    if(readServoAngle(moduleNumber) != SERVOANGLEOPEN) {
      moveServo(moduleNumber, SERVOANGLEOPEN);
    }
  }
  else {
    if(te[moduleNumber] <= Temp - Hyst) {
      if(readServoAngle(moduleNumber) != SERVOANGLECLOSE) {
        moveServo(moduleNumber, SERVOANGLECLOSE);
      }
    }
  }
}


void processSerial(String serialString) {
  switch (serialString.charAt(0)) {
    case 'M':
      processModuleCommand(serialString);
      break;
    default:
      break;
  }
}

void processModuleCommand(String serialString) {
  int moduleNumber = serialString.substring(1).toInt();
  String command = getNextPart(serialString,':');
  switch (command.charAt(0)) {
    case 'S':
      sendModuleStatus(moduleNumber);
      break;
    case 'D':
      handleDoor(moduleNumber, command);
      break;
    case 'P':
      moveServoCommand(moduleNumber, command);
      break;
    default:
      break;
  }
}

/*
 * M0:<Command>=> Selection Module (M : Module; 0,1,2 : Module 0,1,2)

 * <Command>
 * S => Status : M0>D1/T20/H90/L95/S120/B1 (D : Door 1Open/0Closed, T : Temp, H: Humidity, L: Luminosity, S: Servo °, B : Button 1Open/0Closed)
 * D1 => Open Door
 * D0 => Close Door
 */

void sendModuleStatus(int moduleNumber) {
  int lum = readLuminosity(moduleNumber);
  int sangle =  readServoAngle(moduleNumber);
  int b = readButton(moduleNumber);

  Serial.print("M");
  Serial.print(moduleNumber);
  Serial.print(">T");
  Serial.print(te[moduleNumber]);
  Serial.print("/H");
  Serial.print(hu[moduleNumber]);
  Serial.print("/L");
  Serial.print(lum);
  Serial.print("/S");
  Serial.print(sangle);
  Serial.print("/B");
  Serial.println(b);

}

float readTemp(int moduleNumber) {
  return dht[moduleNumber].readTemperature();
}

float readHumid(int moduleNumber) {
  return dht[moduleNumber].readHumidity();
}

int readLuminosity(int moduleNumber) {
  //int sVal = analogRead(photoPin[moduleNumber]);
  //int percent = sVal * (100 / 1023);
  int prc = map(lValues[moduleNumber], 0, 1023, 0, 100);
  return prc;
}

int readServoAngle(int moduleNumber) {
  return sValues[moduleNumber];
}

int readButton(int moduleNumber) {
  return digitalRead(buttonPin[moduleNumber]);
}

void handleDoor(int moduleNumber, String command) {
  int oc = command.substring(1).toInt();
  if(oc < 1) {
    moveServo(moduleNumber, SERVOANGLECLOSE);
  }
  else {
    moveServo(moduleNumber, SERVOANGLEOPEN);
  }
}

void moveServoCommand(int moduleNumber, String command) {
  int angle = command.substring(1).toInt();
  moveServo(moduleNumber, angle);
}

void moveServo(int moduleNumber, int angle) {
  sValues[moduleNumber] = angle;
  s[moduleNumber].attach(sPin[moduleNumber]);
  s[moduleNumber].write(angle);
  delay(1000);
  s[moduleNumber].detach();
}

//Cut the string at the specified length and return the right side.
String getNextPart(String s, char separator) {
  for(int i = 0; i < s.length(); i++) {
    if(s[i] == separator) {
      return s.substring(i+1);
    }
  }
  return "";
}

void serialEvent() {
  while (Serial.available()) {
    // get the new byte:
    char inChar = (char)Serial.read();
    // add it to the inputString:
    inputString += inChar;
    // if the incoming character is a newline, set a flag
    // so the main loop can do something about it:
    if (inChar == '\n') {
      Serial.println(inputString);
      stringComplete = true;
    }
  }
}

                            

We can isolate some part more interessting part of the code. The code gather the information received from the DHT 11, the photosensor and the motor position and format it for easy reading. The code allows also the closure and opening of the door/aeration

I have implemented a mode where the temperature is checked until the define threshold in order to open or close the aeration following the temperature inside the Greenhouse

                      
                        //Hysteresis. At 31° => Open door. At 29° => Close door
                        void checkTemp(int moduleNumber) {
                          if(te[moduleNumber] >= Temp + Hyst) { // Changer signe
                            if(readServoAngle(moduleNumber) != SERVOANGLEOPEN) {
                              moveServo(moduleNumber, SERVOANGLEOPEN);
                            }
                          

In this prototype, I have put only one of each but the code is already planned for more. Explanation below

The User interface

Since I'm working in bluetooth, an app or another way of communication with compatible devices (laptop/smartphone/tablet) was needed

My first test was done with Processing and I wasn't a big fan at all.

A friend of mine (thanks again Virginie and Benoit!) sees me struggling with it and says "why don't you use App inventor from the MIT?". That was the declic and it was really fast and efficient, as you can see below.
I have mainly use these sources as base for the app : source1 and source2

The application deconnected as seen by my smartphone

The application connected as seen by my smartphone, with the values feed by the board

I have now a board, the code, an interface and a way of communication via the HC-05 and bluetooth. Let's finish it in the next step : Prototyping and assembly

Date: June 2017