SS4H-PF Pet Feeder – DIY Project based on ESP8266

Do you think that your pet gives a shit that it’s the weekend and you need to sleep in? My cat certainly doesn’t. Every Saturday at 7 am my cat Strachu meows a serenade “I’m hungry!!”. And he doesn’t give a hoot that you went to bed late last night because: (cross out false one) you were at a party / you worked / your child didn’t let you sleep.

That is just one example where a remote feeder would come in handy.

Today I’m gonna show you how I built your own Pet Feeder and integrated it with a Smart Home. Without any further ado, let’s get down to business!

LED assembly may not be obvious. You have to bend it correctly so that it doesn’t protrude beyond the outline. Then it gonna fit perfectly into the hole in the housing (photo).

Additionally, You can cover the lens with a heat shrink tube. Thanks to this, the light doesn’t disperse that much.

The three-pin PIR module socket is the only one on the bottom side of the PCB.

If you want to power the device with a 5V power supply, you can omit the DC-DC converter. Remember to set the jumper in the right place.

The Application Programming Interface defines how the Integration in the Home Assistant gonna interact with the ESP device. If you’ve only used integrations supported natively by HA, then you probably didn’t have to do anything else with it aside from putting the command “api:”.

Unfortunately, the stepper motor isn’t natively supported (yet), but nothing prevents us from making our own API.

I added two services: to support the stepper motor and the length of the beep. Thanks to this, I can easily modify these two elements by adding in the Home Assistant additional parameter. I don’t need to modify the config to do it.

The service “start_buzzer” receives an integer variable and then passes it as a parameter of the function “delay. Thus it determines what long BEEEEP the device will do..”

The “stepper_control” service, like before, receives an integer variable, which this time will define the number of steps that the motor has to do. However, before doing so, the current position must be set to 0. Thanks to this, the required number of steps will be counted from the beginning each time.

As you can see, I’m using the command “!lambda“. It is used to inject C++ code into the YAML file. Thus, we significantly expand the capabilities of ESPHome. I’m not gonna go deep into details here. You can read more on the ESPHome website. All you need to know now is that we use this to convert a C++ variable into a language understood by ESPHome.

api:
   services:
     - service: start_buzzer
       variables:
         delay_time: int
       then:
         - switch.turn_on: buzzer_pf_id
         - delay: !lambda 'return delay_time;'
         - switch.turn_off: buzzer_pf_id
     - service: stepper_control
       variables:
         target: int
       then:
         - stepper.report_position:
             id: ss4h_pf_motor
             position: 0      
         - stepper.set_target:
             id: ss4h_pf_motor
             target: !lambda 'return target;'

I used the ULN2003 (Aliexpress) chip as the stepper motor driver. ESPHome supports a different, more sophisticated driver like A4988 (Aliexpress). But ULN2003 is definitely a cheaper and simpler way.

The ID must be the same as you entered when adding a new API service.

Additionally, I recommend you to set true with the sleep_when_done parameter. The motor won’t heat up or draw a current when idle.

stepper:
  - platform: uln2003
    id: ss4h_pf_motor
    pin_a: 16
    pin_b: 14
    pin_c: 12
    pin_d: 13
    max_speed: 250 steps/s

    # Optional:
    sleep_when_done: true

Important!

Due to the limited amount of pins in the ESP-12F module, I connected the Buzzer to the GPIO2. Its state must be high when connecting the power supply. Otherwise, it won’t boot. You can read more about him in the article How to program an ESP8266. 

Anyway, to boot the device in normal mode (not flashing mode), you have to set GPIO2 as a switch. It’s best to do it during the first programming with the USB-UART adapter. As for the rest, you can do it later, via OTA (over the air).

switch:
  - platform: gpio
    pin: 2
    name: "Buzzer_PF"
    id: buzzer_pf_id

This entire code is only for the button on the Pet Feeder. Don’t let the volume of it scare you. 

All of this could be done in Home Assistance itself (not ins ESPHome), without any problem. But, in case of a WiFi or HA’s failure, I wanted to keep basic functionality working.

I assume that I don’t need to explain the basics of configuring a binary sensor. So let’s move on to more exciting lines.

The “on_release” parameter is activated when the button is, surprise, surprise: released 🙂

In this case, first, the Buzzer and LED will confirm the button pressed. Then the stepper motor will move 800 steps forward, thus dispensing portions of treats for your pet.

The “on_click” parameter is even more interesting. We can detect with it a long press of the button (min and max length). I set the detection between 1 and 5s, but you can change this time frame if you want. In this case, both LED and Buzzer will make a double flash (beep), then the Stepper Motor will retract a bit.

I did it just in case of a jam. Fortunately, I haven’t had to use it so far. But based on maaany previous prototypes of Pet Feeder, it sometimes happened that a single treat blocked the worm gear. There was no other option but to poke your finger inside to unlock the mechanism.

That’s why I added this feature now so that problems like this can be solved quickly. But as already mentioned, in this version of the device, I didn’t have to use it yet.

binary_sensor:
  - platform: gpio
    pin: 4
    name: "Button_PF" 
    filters:
    - invert:
    on_click:
      - min_length: 1000ms
        max_length: 5000ms
        then:
        - switch.turn_on: buzzer_pf_id
        - switch.turn_on: led_pf_id
        - delay: 100ms
        - switch.turn_off: buzzer_pf_id
        - switch.turn_off: led_pf_id
        - delay: 50ms
        - switch.turn_on: buzzer_pf_id
        - switch.turn_on: led_pf_id
        - delay: 100ms
        - switch.turn_off: buzzer_pf_id
        - switch.turn_off: led_pf_id
        - stepper.report_position:
            id: ss4h_pf_motor
            position: 0      
        - stepper.set_target:
            id: ss4h_pf_motor 
            target: -200
    on_release:
      - switch.turn_on: buzzer_pf_id
      - switch.turn_on: led_pf_id
      - delay: 100ms
      - switch.turn_off: buzzer_pf_id
      - switch.turn_off: led_pf_id
      - stepper.report_position:
          id: ss4h_pf_motor
          position: 0      
      - stepper.set_target:
          id: ss4h_pf_motor 
          target: 800

1. Go to: Developer Tools -> Services

2. All servicers created in ESPHome begin with the “esphome.”. Then there’s the node name followed by the service name. In my case, it is: “esphome.ss4h_pf_stepper_control”.

You also need to add a variable that will determine the number of steps of the motor. In this example, after clicking the CALL SERVICE button, the motor will rotate exactly 1500 steps.

2. Name it whatever you like. However, it is good when the name reflects the function of a given automation. It is easier to deal with in the future.

3. Here we can set the time when the automation will be triggered. As you can see, my cat likes to eat breakfast at 7 AM 🙂

4. In the Action section, we’re gonna call our two services. First, a short BEEP to summon the cat/dog/rabbit or whoever you have there 🙂

The second one is the rotation of the stepper motor. As you can see, it looks similar to when we tested it before.

Here you can see the most significant advantage of custom services. We could set the number of steps and the beep length directly in the ESPHome configuration file. But then any modification would’ve required the chip to be reprogramed. Now we can increase or decrease the portion of pet treats directly in the Home Assistant.

Go to: Overview, and then to the tab where you want to put the button. I’ve made a “cat-tab”, especially for this article. But I usually keep it on the main tab to make it convenient to reach.

Enter the edit mode (three dots in the upper right corner) and add a new Button Card. You can also use a Manual Card if you prefer, but that way, there will be less typing. And we like “less typing” 🙂

Although most of the configuration can be done using the visual editor, we’ll still have to switch to code editor at the end. Setting the Tap Action to Call service at here crashes visual editor..

But while you are reading this, it may already be working – check it out. If not, go to the code editor.

At this point, we only need to add these three lines:

You can make sure that your pet has come to the bowl and is eating food.

To do this, all you need is a Glance card. As an entity select: binary_sensor.pir_pf. Or whatever you named your PIR sensor in ESPHome.

If you have such a fountain, you can only turn it on only when the pet is nearby. You can save some money on electricity thanks to this. Or even more importantly, you can’t hear the water splashing all the time. It was driving me crazy before I did Pet Feeder.

Of course, to do this, you need to be able to turn this fountain on and off remotely. You can use a Relay Module with ESP8266 (Aliexpress) or a power socket, e.g., Sonoff socket (Aliexpress).

If you have the Home Assistant app on your phone (iOS or Android), you can receive notifications about various events. You can also decide right away if it’s a good time for lunch.

I’ve described in detail how to make such a notification on iOS and Android phones in my other article. You will find it here: Integrating Smart Doorbell with Home Assistant

Of course, in this case, a lot depends on the pet. My Strachu is hungry all the time, so I had to turn this notification off completely. But maybe yours isn’t such a gobbler 🙂

In other projects, in this kind of chapter, I described a PCB case. This time, that part of the project is the most extensive one. It took me the longest to design it, and it “cost me” a lot of unsuccessful prototypes. But that’s the only way when reliability is a key feature.

Now we’re gonna make the PCB box, which is also the base of the device.

The box consists of three parts: top, middle, and bottom. I designed it this way so it could be printed without supports.

Because it is a food-related device, it would be appropriate to wash it once in a while. That’s why this project took me sooo much time. I wanted to be able to separate the electronic part from the “food” part in a matter of seconds and without any tools. And I think I managed to achieve it.

All you need is three steps:

1. Slide the stepper motor cover upwards.
2. Pull out the stepper motor.
3. Pull the entire body of the device forward.

This way, you can safely wash the inside of the device without the fear of getting the electronics wet.