•

Published November 27, 2016 © GPL3+

Automated Dog Food Dispenser

Utilizes IFTTT Google Calendar to operate a servo motor, and sends data to another particle photon to tabulate the data.

IntermediateFull instructions provided6 hours2,609

Things used in this project

Hardware components

Particle Photon

ControlEverything.com I2C Shield

ControlEverything.com ADS1115 I2C 16-Bit Analog-Digital Converter

Winrida 11lb 5kg Digital Kitchen Food Scale,1g/0.01oz Resolution,Calibration Supported, LCD Display,White

Tower Pro MG996R Robot Servo 360° Rotation

Zevro KCH-06121/GAT200 Indispensable Dry Food Dispensers

Basswood

Software apps and online services

IFTTT Maker service

Google Calendar

Particle IDE

ThingSpeak API

Hand tools and fabrication machines

Soldering iron (generic)

Drill

Screwdriver

Story

Project Overview

The overall aim of this project was to use an IOT device to drive a continuous rotation servo motor to dispense specified amounts of food at specific daily intervals. Initially to be driven by weight readings from a load cell adapted from a kitchen scale, the final implementation utilized IFTTT-driven publications from a Google Calendar to drive a dispensing servo at designated times.

Initial Concept and Implementation

The first Photon (P1) was meant to take a weight reading from the kitchen scale and publish a variable to the Particle cloud. The second Photon (P2) was meant to subscribe to this variable and operate the servo.

Servo:

The first hurdle to overcome was to decide on a container, and a quick Amazon search yielded a set of simple cereal dispensers.

Zevro KCH-06121/GAT200 Indispensable Dry Food Dispensers

This led to deciding on servo implementation. It was quickly realized that the servo contained in the particle maker kit only rotated 180 degrees. Three wires were removed from the potentiometer, and two 1000 ohm resistors were soldered in place of the variable resistor. Although continuous rotation of the servo was successful, the engaging gear of the servo possessed a flat surface preventing 360 degrees of rotation. This engaging gear was replaced by another that had a full gear of splines and no flat surfaces. Another problem reared its head in the form of the top cover would not fit over the new gear even after slight modification. This coupled with another problem of each attempt to replace the back cover broke the solder joints due to the small wires and tight confinement. Ultimately, the task of modifying the servo was abandoned for a high-torque continuous servo purchased from Amazon.

Mini-Servo Disassembled for Modification

Voltage Divider Added to Mini-Servo Circuitboard

Mini-Servo Modified for Continuous Rotation

With the servo problem situated, it was then assumed that the new servo could be plugged directly into the same pins on the Particle Photon. This was a sorely mistaken assumption, which resulted in a fried Photon when turned on. With the purchase of a new Photon, the project was back on track. Additionally, thorough research taught that the high-torque servo required an external power source.

Weight Scale:

Focus then transitioned to weight scale operation, and how that would incorporate into the overall project. An analog to digital converter (ADC) and I2C shield were purchased from ControlEverything.com.

I2C Master Shield

ADS1115 16-Bit 4-Channel Precision Analog to Digital Converter I²C Mini Module

The ADC was to convert the analog voltage from the weight scale load cell to digital voltage:

Load Cell to ADC Connection

This digital voltage was to be input into the photon via the I2C shield. The positive strain gauge output (green wire), and negative strain gauge output (white wire) were connected to two of the ADC's analog inputs. The strain gauge was powered externally by the scale's original AA batteries through the breadboard:

ADC and I2C Shield with Particle Photon

The code to be used for converting the analog load cell results into a usable digital readout by the ADC was obtained from the community library ADAFRUIT_ADS1X15 through the Particle IDE. After numerous attempts, followed by further research into load cell/ADC interfacing, it was determined that the signals generated by the load cell compression were too small for the ADS 1115 to be properly utilized. Attempts were made to utilize the Comparator, Differential, and Single-Ended versions of the code, but none were successful in returning useful counts to the digital inputs of P1.

In an attempt to demonstrate a proof-of-concept for the design, the outputs of the load cell were connected to the analog inputs of P1. The variables "analogvalue1" and "analogvalue2" corresponded to the A0 and A1 pins, respectively. The difference between the A0 and A1 readings was set as "analogdiff", and load on the cell was incrementally increased to determine if load variations could be sensed:

Analog Scale Code Progressive Load Test.

As shown in the video above, increasing loads produced measurable results, albeit not at a fine enough resolution to meet project objectives. If the above video is placed in Fullscreen, the average "analogdiff" value can be observed changing from 1.2 with an unloaded scale to -2 with one book, -6 with two books, and peaking at -6.5 with three books.

In an attempt to produce a usable signal at smaller load variations, an LM358 Op-Amp was used to process the output signal from the load cell. While highly sensitive to load variations, the LM358-processed signal was ultimately too corrupted by noise to provide usable data on load variations.

Simultaneously, coding work was being attempted to operate the servo via mobicle.io. Functions were added to the code to allow for "on" and "off" buttons to cue the servo from a telephonic mobile device. Unfortunately, the coding never moved beyond any errors when verified or attempted flashing. The combination of these issues and the scope of details to be addressed regarding load cell signal processing resulted in the search for a more reliable method of implementation.

Secondary Concept and Implementation

This method involved utilizing the If This, Then That (IFTTT) website to set specific dates and times the servo was to be in operation for a specified degree of rotation. The event "Feed Dog" was added to a Google Calendar. Linking an IFTTT applet to this calendar causes an event to be published to the Particle cloud within fifteen minutes of the even occurring. Subscribing to the event signals P1 to execute the servo operation, while P2 registers the event and plots it as a data point on a simple graph on thingspeak.com.

Final Implementation Test - The event occurs fifteen minutes in advance of the scheduled Google Calendar event in accordance with standard IFTTT protocols. In addition, the lighting of the D7 LED on P2 demonstrates the ability of P2 to register the event. This action was changed to publishing a Thingspeak variable in the final version.

Final Wiring - P1 is on the right (White USB), P2 on the left (Blue USB)

Code

Servo myservo;  // create servo object to control a servo
                // a maximum of eight servo objects can be created

int pos = 0;    // variable to store the servo position

void setup()
{
  myservo.attach(D0);  // attaches the servo on the D0 pin to the servo object
  // Only supported on pins that have PWM
}
int servo(String command) {

void loop()

// Finally, we will write out our ledToggle function, which is referenced by the Particle.function() called "led"



    if (command=="on") {
        digitalWrite(myservo,HIGH);
          for(pos = 0; pos < 360; pos += 1)  // goes from 0 degrees to 360 degrees
  {                                  // in steps of 1 degree
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(0);                       // waits 0ms for the servo to reach the position
  }
        return 1;
    }
    else if (command=="off") {
        digitalWrite(myservo,LOW);
          for(pos = 0; pos < 0; pos += 0)  // goes from 0 degrees to 180 degrees
  {                                  // in steps of 1 degree
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(0);                       // waits 15ms for the servo to reach the position
  }
        return 0;
    }
    else {
        return -1;
    }

int led = D7;

void setup() {
    
    pinMode(led, OUTPUT);
    digitalWrite(led, LOW);
    
    Particle.subscribe("Feed_Dog", Confirm_Feed_Dog, "550038000a51353531343431");
    
}

void Confirm_Feed_Dog(const char *event, const char *data)
{
    digitalWrite(led, HIGH);
    delay(5000);
    digitalWrite(led, LOW);
    String Feed_Dog = String(random(0,100));
    Particle.publish("Feed Dog", Feed_Dog, PRIVATE);
    delay(10000);
}

int analogvalue1 = 0;
int analogvalue2 = 0;
int analogdiff = 0;
int digival1 = 0;
int digival2 = 0;
int digidiff = 0;
char *message = "my name is particle";
String aString;

void setup()
{
  // variable name max length is 12 characters long
  Particle.variable("analogvalue1", analogvalue1);
  Particle.variable("digival1", digival1);
  Particle.variable("digival2", digival2);
  Particle.variable("digidiff", digidiff);
  Particle.variable("analogvalue2", analogvalue2);
    Particle.variable("analogdiff", analogdiff);
  if (Particle.variable("mess", message)==false)
  {
      // variable not registered!
  }
  Particle.variable("mess2", aString);

  pinMode(A0, INPUT);
}

void loop()
{
  // Read the analog value of the sensor (TMP36)
  analogvalue1 = analogRead(A0);
   analogvalue2 = analogRead(A1);
   analogdiff = (analogvalue1 - analogvalue2);
   digival1 = digitalRead(D0);
   digival2 = digitalRead(D7);
   digidiff = digival1 - digival2;
  //Convert the reading into degree celcius
  //tempC = (((analogvalue * 3.3)/4095) - 0.5) * 100;
  delay(200);
}

int servoPin = D0;
Servo myservo;
int servoPos = 0;
void setup() {
    myservo.attach( D0 );
Particle.subscribe("Feed_Dog", myHandler);
}

void loop()
{}
  
void myHandler(const char *event, const char *data)
{
    if(strcmp(data,"Feed_Dog")==0)
    {
       Particle.publish("Feed_Dog", "Confirm_Feed_Dog");
myservo.write(180);
delay(2500);
myservo.write(0);
}
}