Published September 17, 2026 © MIT

Robot Eyes: Smooth Animated Eyes on Raspberry Pi

A lightweight robot face engine with smooth, expressive eye animations running on a Raspberry Pi and 1.8" ST7735 TFT display.

BeginnerFull instructions provided1.2 hours80

Robot Eyes: Smooth Animated Eyes on Raspberry Pi

Things used in this project

Hardware components

Raspberry Pi 5

1.8 Inch ST7735 LCD Display

Female/Female Jumper Wires

Software apps and online services

Raspberry Pi Raspbian

Story

Introduction

A robot does not always need a complicated display or camera to have a personality. Sometimes, a pair of simple animated eyes is enough to make a robot feel more interactive.

This project uses a Raspberry Pi 5 and a 1.8-inch ST7735 TFT display to create a small animated robot face. The display shows two expressive eyes that can move, blink, and change shape to communicate different emotions.

The main idea behind the project is to use the shape and movement of the eyes themselves to create expressions. There are no pupils or complicated graphics. This keeps the system lightweight and makes it suitable for small Raspberry Pi-based robots.

Why I Built It

I wanted to create a simple visual interface that could be added to a robot without requiring a large display or a powerful graphics system.

A small ST7735 TFT display is inexpensive, compact, and easy to interface with a Raspberry Pi using SPI. However, simply displaying static eyes does not make the robot feel very interactive.

The goal was therefore to create an animation engine that could make the eyes move naturally and respond to different events.

The project was designed around three main requirements:

Simple graphics that can run on a small TFT display.
Smooth eye movement without sudden jumps.
Multiple expressions that can be controlled from another Python program.

Hardware

The hardware for the project is simple.

Components:

Raspberry Pi 5
1.8-inch ST7735 TFT LCD, 128 × 160
Jumper wires(Female/Female)

1 / 3 • Raspberry Pi 5

The Raspberry Pi handles the graphics and animation while the ST7735 display acts as the robot's face.

Display Connections

The ST7735 display communicates with the Raspberry Pi using SPI. The display's SDA pin is used as the SPI MOSI/data line, not as an I2C SDA connection.

The wiring is as follows:

Actual wiring of the Raspberry Pi and ST7735 display

Setting Up the Display

For the setup I used the following guide Getting 1.8 Inch LCD Display ST7735 to Work With Raspberry Pi Zero W

sudo apt install python3-pip
sudo apt install python3-pil
sudo apt install python3-dev
sudo apt install python3-numpy
sudo apt istall python3-libgpiod 
sudo pip3 install st7735 //This command throws the following error:

error: externally-managed-environment
× This environment is externally managed
╰─> To install Python packages system-wide, try apt install
    python3-xyz, where xyz is the package you are trying to
    install.
    If you wish to install a non-Debian-packaged Python package,
    create a virtual environment using python3 -m venv path/to/venv.
    Then use path/to/venv/bin/python and path/to/venv/bin/pip. Make
    sure you have python3-full installed.
    For more information visit http://rptl.io/venv

In order to overcome this error, use the following command:

sudo pip install st7735 --break-system-packages

In addition, you need to install the following libraries:

sudo pip install gpiod --break-system-packages
sudo pip install gpiodevice --break-system-packages

So you need to edit the main file of the installed ST7735 library with the command:

sudo nano /usr/local/lib/python3.xx/dist-packages/st7735/__init__.py

// replace the python3.xx in the path with your corrct version of python like below
//sudo nano /usr/local/lib/python3.13/dist-packages/st7735/__init__.py
//Inside this file, replace the above values with these ones:

ST7735_TFTWIDTH = 124
ST7735_TFTHEIGHT = 160

ST7735_COLS = 124
ST7735_ROWS = 160

The display is configured for SPI communication and rotated so that the 160 × 124 working area is used horizontally.

The display initialization is:

disp = st7735.ST7735(
    port=0,
    cs=st7735.BG_SPI_CS_BACK,
    dc="GPIO24",
    backlight="GPIO22",
    rst="GPIO25",
    rotation=90,
    invert=False,
    spi_speed_hz=4000000
)

1 / 2

Getting the display working first made it easier to separate hardware and software problems before developing the animation system.

Designing the Robot Eyes

The first version of the project used simple rectangular eye shapes.

Instead of drawing pupils inside the eyes, the eye shapes themselves are used to communicate the robot's state.

For example, the eyes can become larger when the robot is surprised, narrower when it is sleeping, or angled when it is angry.

The main expressions implemented in the project are:

Normal
Happy
Angry
Surprised
Sleep
Blink
Wink left
Wink right

This approach keeps the graphics simple while still allowing the robot to display different emotions.

The Robot Eyes Engine

The main software component is robot_eyes_engine.py.

This file is responsible for communicating with the display, drawing the eye shapes, and controlling the animations.

It provides functions for changing the robot's expression as well as moving the eyes.

For example:

eyes.look_left()
eyes.look_right()
eyes.look_center()

eyes.look_up()
eyes.look_down()

eyes.happy()
eyes.angry()
eyes.surprised()

eyes.blink()
eyes.sleep()
eyes.look_left()
eyes.look_right()
eyes.look_center()

eyes.look_up()
eyes.look_down()

eyes.happy()
eyes.angry()
eyes.surprised()

eyes.blink()
eyes.sleep()

A short section of robot_eyes_engine.py showing the main RobotEyes class and initialization

import time
import math
from PIL import Image, ImageDraw
import st7735


class RobotEyes:

    def __init__(self, rotation=90):

        # ==================================================
        # ST7735 DISPLAY
        # ==================================================

        self.disp = st7735.ST7735(
            port=0,
            cs=st7735.BG_SPI_CS_BACK,
            dc="GPIO24",
            backlight="GPIO22",
            rst="GPIO25",
            rotation=rotation,
            invert=False,
            spi_speed_hz=4000000
        )

        self.disp.begin()

        # Display size after rotation=90
        self.WIDTH = 160
        self.HEIGHT = 124

        # ==================================================
        # EYE SETTINGS
        # ==================================================

        self.eye_width = 38
        self.eye_height = 52

        self.left_x = 25
        self.right_x = 97

        self.center_y = 36

        # Current eye movement
        self.offset_x = 0
        self.offset_y = 0

        # Current expression
        self.expression = "normal"

        # Colors
        self.background = (0, 0, 0)
        self.eye_color = (255, 255, 255)

        self.draw()

Smooth Eye Movement

One of the most important parts of the project is the eye movement.

A simple implementation could instantly change the position of the eyes from one location to another. However, this produces a mechanical-looking movement.

Instead, the animation engine calculates intermediate positions between the starting and ending positions.

The movement is updated over multiple frames using an ease-in/ease-out function. The eyes start moving quickly, slow down as they approach the target position, and then settle into place.

This makes the movement appear much more natural without requiring complicated graphics.

The expressions can also be combined with movement. For example, the robot can look to the side while displaying a surprised expression.

Controlling the Robot Face

The second main program is robot_face.py.

While the eyes engine handles the actual graphics and animation, robot_face.py controls the behaviour of the robot.

It can randomly trigger actions such as looking in different directions, blinking, or changing expressions.

This separation makes the system easier to expand. Another robot program can use the same eyes engine and trigger an expression whenever something happens.

For example, a robot could display a surprised expression when its ultrasonic sensor detects an obstacle.

# ============================================================
# FAST LOOK
# ============================================================

def look_left():
    eyes.look_left(0.22)


def look_right():
    eyes.look_right(0.22)


def look_center():
    eyes.look_center(0.18)


def look_up():
    eyes.look_up(0.20)


def look_down():
    eyes.look_down(0.20)


# ============================================================
# NATURAL BLINK
# ============================================================

def blink():
    eyes.blink()


# ============================================================
# QUICK DOUBLE BLINK
# ============================================================

def double_blink():

    eyes.blink()
    time.sleep(0.06)
    eyes.blink()

The complete robot_face.py file should be uploaded in the Hackster Code section.

Running the Project

After connecting the display and installing the required Python libraries, the robot face can be started from the Raspberry Pi terminal.

The main behaviour program can be launched with:

python3 robot_face.py

The program initializes the display and starts the robot face animation.

Once running, the display continuously performs different movements and expressions.

Project Structure

The project contains several versions of the robot eyes software. The different versions make it possible to experiment with pupil-based eyes, pupil-free eyes, and different animation behaviours.

Robot_eyes/
│
├── robot_eyes_engine.py
├── robot_face.py
│
├── robot_eyes_engine_nop.py
├── robot_face_nop.py
├── robot_face_nop_fast.py
│
├── robot_eyes.py
└── README.md

robot_eyes_engine.py

This is the main pupil-based robot eyes engine. It handles the ST7735 display, draws the eyes and pupils, provides different expressions, and smoothly moves the pupils in different directions. It also includes blinking, winking, scanning, and random eye movement functions.

robot_face.py

This is a simple behaviour program that uses robot_eyes_engine.py. It demonstrates the robot looking forward, looking left and right, returning to the center, and blinking continuously.

robot_eyes_engine_nop.py

This is the no-pupil version of the eyes engine. Instead of using pupils to indicate direction, the entire eye shape moves around the display. The eye shapes themselves are also changed to create expressions such as normal, happy, angry, surprised, sleeping, blinking, and winking.

NOP means "No Pupils". In this version, the eyes are simply white shapes on a black background, without separate pupils.

robot_face_nop.py

This is the demonstration program for the no-pupil version. It demonstrates the different expressions, blinking, winking, diagonal movements, scanning, and an idle animation.

robot_face_nop_fast.py

This version focuses on fast, smooth, and seamless behaviour. It uses shorter movement durations and randomised behaviour to make the robot appear more natural and responsive. It can look around, blink, double blink, listen, and display happy, surprised, and angry reactions.

robot_eyes.py

This is a simple standalone version that directly draws the two basic robot eyes on the ST7735 display. It was used as a basic starting point for displaying the eyes before developing the more advanced animation engines.

README.md

This file contains additional information about the project, its files, setup, and usage.

Two Main Versions

The project can therefore be viewed as having two main approaches.

Pupil-based eyes

robot_eyes_engine.py
        ↓
robot_face.py

The eye remains in place while the pupil moves to indicate where the robot is looking.

No-pupil eyes

robot_eyes_engine_nop.py
        ↓
robot_face_nop.py
        ↓
robot_face_nop_fast.py

The entire eye shape moves and changes to create the robot's expressions and direction of attention.

The no-pupil approach was developed to create a cleaner and more minimal robot face using only the eye shapes themselves. Hackster recommends using clear section headings and separating code from the main explanatory text, so the full .py files should be uploaded in the Code section while only short relevant snippets are shown in the Story.

Testing

The project was tested by running the different expressions and movement functions individually before combining them into the main robot behavior.

The main things tested were:

Display initialization
Eye rendering
Left and right movement
Up and down movement
Diagonal movement
Blinking
Winking
Expression changes
Smooth transitions
Continuous idle behavior

The final result is a small robot face capable of continuously moving and changing expressions while running entirely from the Raspberry Pi.

Possible Applications

Although this project was developed as a standalone robot face, the animation engine can be used as the visual interface for many different projects.

For example, the eyes could respond to:

Ultrasonic obstacle detection
Voice commands
Speech output
Robot movement
Sensors
Notifications
AI assistant responses
Facial recognition
User interaction

A robot could therefore use the eyes to communicate its current state without requiring a large screen.

Future Improvements

There are several ways I would like to improve the project.

Future versions could include more eye shapes and animations, including different styles for emotions and reactions.

The eyes could also be synchronized with speech so that the robot's expressions change while it is talking.

Another possibility is to connect the animation engine to sensors and an AI assistant. This would allow the robot to automatically choose an expression based on what it detects or what it is doing.

Other possible improvements include:

More expressive eye shapes
Speech-synchronized animation
Sensor-triggered expressions
Voice-controlled reactions
Facial recognition
AI assistant integration
More advanced transition effects
Integration with a mobile or web interface

Conclusion

This project demonstrates how a small 1.8-inch ST7735 TFT display can be turned into a simple but expressive robot face using a Raspberry Pi and Python.

The project focuses on keeping the graphics lightweight while making the animations feel smooth and natural. By separating the animation engine from the robot's behaviour, the same eye system can also be reused in different robotics projects.

The result is a compact visual interface that gives a Raspberry Pi-based robot a simple personality and a way to communicate its state through movement and expressions.

import time
import random
from robot_eyes_engine import RobotEyes


# ============================================================
# ROBOT FACE
# Fast + Smooth + Seamless Animation
# ============================================================

eyes = RobotEyes(rotation=90)


# ============================================================
# FAST LOOK
# ============================================================

def look_left():
    eyes.look_left(0.22)


def look_right():
    eyes.look_right(0.22)


def look_center():
    eyes.look_center(0.18)


def look_up():
    eyes.look_up(0.20)


def look_down():
    eyes.look_down(0.20)


# ============================================================
# NATURAL BLINK
# ============================================================

def blink():
    eyes.blink()


# ============================================================
# QUICK DOUBLE BLINK
# ============================================================

def double_blink():

    eyes.blink()
    time.sleep(0.06)
    eyes.blink()


# ============================================================
# NATURAL LOOK AROUND
# ============================================================

def look_around():

    direction = random.choice([
        "left",
        "right",
        "up",
        "down",
        "center"
    ])

    if direction == "left":
        look_left()

    elif direction == "right":
        look_right()

    elif direction == "up":
        look_up()

    elif direction == "down":
        look_down()

    else:
        look_center()


# ============================================================
# RANDOM EXPRESSION
# ============================================================

def random_expression():

    expression = random.choice([
        "normal",
        "happy",
        "surprised",
        "angry"
    ])

    eyes.set_expression(expression)


# ============================================================
# TALKING / LISTENING STYLE ANIMATION
# ============================================================

def listening():

    eyes.normal()

    time.sleep(0.3)

    look_left()

    time.sleep(0.25)

    look_right()

    time.sleep(0.25)

    look_center()


# ============================================================
# HAPPY REACTION
# ============================================================

def happy_reaction():

    eyes.happy()

    time.sleep(0.6)

    eyes.normal()


# ============================================================
# SURPRISE REACTION
# ============================================================

def surprise_reaction():

    eyes.surprised()

    time.sleep(0.45)

    eyes.normal()


# ============================================================
# QUICK ANGRY REACTION
# ============================================================

def angry_reaction():

    eyes.angry()

    time.sleep(0.5)

    eyes.normal()


# ============================================================
# STARTUP ANIMATION
# ============================================================

def startup():

    # Start sleeping
    eyes.sleep()

    time.sleep(0.4)

    # Wake up
    eyes.normal()

    time.sleep(0.15)

    # Quick scan
    look_left()
    look_right()
    look_center()

    eyes.blink()


# ============================================================
# IDLE FACE
# ============================================================

def idle():

    # Small random movement
    look_around()

    # Short natural pause
    time.sleep(
        random.uniform(0.25, 0.7)
    )

    # Sometimes blink
    if random.random() < 0.35:

        blink()

        time.sleep(
            random.uniform(0.15, 0.4)
        )

    # Occasionally look back at center
    if random.random() < 0.45:

        look_center()

        time.sleep(
            random.uniform(0.2, 0.5)
        )


# ============================================================
# MAIN
# ============================================================

try:

    startup()

    while True:

        # ----------------------------------------
        # Mostly normal idle behavior
        # ----------------------------------------

        chance = random.random()


        # Normal looking around
        if chance < 0.60:

            idle()


        # Happy
        elif chance < 0.70:

            happy_reaction()


        # Quick blink
        elif chance < 0.82:

            blink()


        # Double blink
        elif chance < 0.88:

            double_blink()


        # Surprise
        elif chance < 0.93:

            surprise_reaction()


        # Angry
        elif chance < 0.96:

            angry_reaction()


        # Listening / scanning
        else:

            listening()


        # Very short pause before next action
        time.sleep(
            random.uniform(0.08, 0.25)
        )


except KeyboardInterrupt:

    print("\nRobot face stopped.")


finally:

    eyes.close()

import time
import math
from PIL import Image, ImageDraw
import st7735


class RobotEyes:

    def __init__(self, rotation=90):

        # ==================================================
        # ST7735 DISPLAY
        # ==================================================

        self.disp = st7735.ST7735(
            port=0,
            cs=st7735.BG_SPI_CS_BACK,
            dc="GPIO24",
            backlight="GPIO22",
            rst="GPIO25",
            rotation=rotation,
            invert=False,
            spi_speed_hz=4000000
        )

        self.disp.begin()

        # Display size after rotation=90
        self.WIDTH = 160
        self.HEIGHT = 124

        # ==================================================
        # EYE SETTINGS
        # ==================================================

        self.eye_width = 38
        self.eye_height = 52

        self.left_x = 25
        self.right_x = 97

        self.center_y = 36

        # Current eye movement
        self.offset_x = 0
        self.offset_y = 0

        # Current expression
        self.expression = "normal"

        # Colors
        self.background = (0, 0, 0)
        self.eye_color = (255, 255, 255)

        self.draw()


    # ======================================================
    # CREATE IMAGE
    # ======================================================

    def create_image(self):

        return Image.new(
            "RGB",
            (self.WIDTH, self.HEIGHT),
            self.background
        )


    # ======================================================
    # DRAW ONE EYE
    # ======================================================

    def draw_eye(self, draw, x, y):

        w = self.eye_width
        h = self.eye_height

        # Apply smooth eye movement
        x += self.offset_x
        y += self.offset_y


        # --------------------------------------------------
        # NORMAL
        # --------------------------------------------------

        if self.expression == "normal":

            draw.rounded_rectangle(
                (
                    x,
                    y,
                    x + w,
                    y + h
                ),
                radius=10,
                fill=self.eye_color
            )


        # --------------------------------------------------
        # HAPPY
        # --------------------------------------------------

        elif self.expression == "happy":

            draw.arc(
                (
                    x,
                    y + 5,
                    x + w,
                    y + h + 15
                ),
                200,
                340,
                fill=self.eye_color,
                width=6
            )


        # --------------------------------------------------
        # ANGRY
        # --------------------------------------------------

        elif self.expression == "angry":

            draw.polygon(
                [
                    (x, y + 12),
                    (x + w, y),
                    (x + w, y + h),
                    (x, y + h - 8)
                ],
                fill=self.eye_color
            )


        # --------------------------------------------------
        # SURPRISED
        # --------------------------------------------------

        elif self.expression == "surprised":

            draw.rounded_rectangle(
                (
                    x - 3,
                    y - 6,
                    x + w + 3,
                    y + h + 6
                ),
                radius=14,
                fill=self.eye_color
            )


        # --------------------------------------------------
        # SLEEP
        # --------------------------------------------------

        elif self.expression == "sleep":

            draw.rounded_rectangle(
                (
                    x + 5,
                    y + h // 2 - 3,
                    x + w - 5,
                    y + h // 2 + 3
                ),
                radius=3,
                fill=self.eye_color
            )


        # --------------------------------------------------
        # BLINK
        # --------------------------------------------------

        elif self.expression == "blink":

            draw.rounded_rectangle(
                (
                    x + 4,
                    y + h // 2 - 3,
                    x + w - 4,
                    y + h // 2 + 3
                ),
                radius=3,
                fill=self.eye_color
            )


        # --------------------------------------------------
        # WINK LEFT
        # --------------------------------------------------

        elif self.expression == "wink_left":

            if x < self.WIDTH // 2:

                draw.rounded_rectangle(
                    (
                        x + 4,
                        y + h // 2 - 3,
                        x + w - 4,
                        y + h // 2 + 3
                    ),
                    radius=3,
                    fill=self.eye_color
                )

            else:

                draw.rounded_rectangle(
                    (
                        x,
                        y,
                        x + w,
                        y + h
                    ),
                    radius=10,
                    fill=self.eye_color
                )


        # --------------------------------------------------
        # WINK RIGHT
        # --------------------------------------------------

        elif self.expression == "wink_right":

            if x >= self.WIDTH // 2:

                draw.rounded_rectangle(
                    (
                        x + 4,
                        y + h // 2 - 3,
                        x + w - 4,
                        y + h // 2 + 3
                    ),
                    radius=3,
                    fill=self.eye_color
                )

            else:

                draw.rounded_rectangle(
                    (
                        x,
                        y,
                        x + w,
                        y + h
                    ),
                    radius=10,
                    fill=self.eye_color
                )


        # --------------------------------------------------
        # LOOK UP
        # --------------------------------------------------

        elif self.expression == "look_up":

            draw.rounded_rectangle(
                (
                    x,
                    y - 8,
                    x + w,
                    y + h - 8
                ),
                radius=10,
                fill=self.eye_color
            )


        # --------------------------------------------------
        # LOOK DOWN
        # --------------------------------------------------

        elif self.expression == "look_down":

            draw.rounded_rectangle(
                (
                    x,
                    y + 8,
                    x + w,
                    y + h + 8
                ),
                radius=10,
                fill=self.eye_color
            )


        # --------------------------------------------------
        # DEFAULT
        # --------------------------------------------------

        else:

            draw.rounded_rectangle(
                (
                    x,
                    y,
                    x + w,
                    y + h
                ),
                radius=10,
                fill=self.eye_color
            )


    # ======================================================
    # DRAW BOTH EYES
    # ======================================================

    def draw(self):

        image = self.create_image()
        draw = ImageDraw.Draw(image)

        self.draw_eye(
            draw,
            self.left_x,
            self.center_y
        )

        self.draw_eye(
            draw,
            self.right_x,
            self.center_y
        )

        self.disp.display(image)


    # ======================================================
    # SMOOTH MOVEMENT
    # ======================================================

    def move(self, target_x, target_y, duration=0.5):

        start_x = self.offset_x
        start_y = self.offset_y

        fps = 30
        frames = max(1, int(duration * fps))

        for frame in range(frames + 1):

            progress = frame / frames

            # Smooth ease-in / ease-out
            smooth = (
                0.5
                - 0.5 * math.cos(progress * math.pi)
            )

            self.offset_x = int(
                start_x +
                (target_x - start_x) * smooth
            )

            self.offset_y = int(
                start_y +
                (target_y - start_y) * smooth
            )

            self.draw()

            time.sleep(1 / fps)


    # ======================================================
    # LOOK LEFT
    # ======================================================

    def look_left(self, duration=0.5):

        self.expression = "normal"

        self.move(
            -10,
            0,
            duration
        )


    # ======================================================
    # LOOK RIGHT
    # ======================================================

    def look_right(self, duration=0.5):

        self.expression = "normal"

        self.move(
            10,
            0,
            duration
        )


    # ======================================================
    # LOOK CENTER
    # ======================================================

    def look_center(self, duration=0.5):

        self.expression = "normal"

        self.move(
            0,
            0,
            duration
        )


    # ======================================================
    # LOOK UP
    # ======================================================

    def look_up(self, duration=0.5):

        self.expression = "normal"

        self.move(
            0,
            -8,
            duration
        )


    # ======================================================
    # LOOK DOWN
    # ======================================================

    def look_down(self, duration=0.5):

        self.expression = "normal"

        self.move(
            0,
            8,
            duration
        )


    # ======================================================
    # DIAGONAL LOOKING
    # ======================================================

    def look_up_left(self, duration=0.5):

        self.expression = "normal"

        self.move(
            -8,
            -7,
            duration
        )


    def look_up_right(self, duration=0.5):

        self.expression = "normal"

        self.move(
            8,
            -7,
            duration
        )


    def look_down_left(self, duration=0.5):

        self.expression = "normal"

        self.move(
            -8,
            7,
            duration
        )


    def look_down_right(self, duration=0.5):

        self.expression = "normal"

        self.move(
            8,
            7,
            duration
        )


    # ======================================================
    # EXPRESSIONS
    # ======================================================

    def normal(self):

        self.expression = "normal"
        self.draw()


    def happy(self):

        self.expression = "happy"
        self.draw()


    def angry(self):

        self.expression = "angry"
        self.draw()


    def surprised(self):

        self.expression = "surprised"
        self.draw()


    def sleep(self):

        self.expression = "sleep"
        self.draw()


    # ======================================================
    # BLINK
    # ======================================================

    def blink(self):

        previous = self.expression

        self.expression = "blink"
        self.draw()

        time.sleep(0.12)

        self.expression = previous
        self.draw()


    # ======================================================
    # DOUBLE BLINK
    # ======================================================

    def double_blink(self):

        self.blink()

        time.sleep(0.08)

        self.blink()


    # ======================================================
    # WINK
    # ======================================================

    def wink_left(self):

        self.expression = "wink_left"
        self.draw()

        time.sleep(0.3)

        self.normal()


    def wink_right(self):

        self.expression = "wink_right"
        self.draw()

        time.sleep(0.3)

        self.normal()


    # ======================================================
    # SET EXPRESSION
    # ======================================================

    def set_expression(self, expression):

        expression = expression.lower()

        valid = [
            "normal",
            "happy",
            "angry",
            "surprised",
            "sleep",
            "blink",
            "wink_left",
            "wink_right"
        ]

        if expression in valid:

            self.expression = expression
            self.draw()

        else:

            print("Unknown expression:", expression)


    # ======================================================
    # SCAN
    # ======================================================

    def scan(self):

        self.look_left(0.7)

        time.sleep(0.3)

        self.look_right(1.2)

        time.sleep(0.3)

        self.look_left(1.2)

        time.sleep(0.3)

        self.look_center(0.7)


    # ======================================================
    # ROBOT IDLE MOVEMENT
    # ======================================================

    def idle_animation(self):

        self.look_center(0.4)

        time.sleep(1.5)

        self.look_left(0.6)

        time.sleep(0.5)

        self.look_center(0.6)

        time.sleep(1)

        self.blink()

        time.sleep(1)

        self.look_right(0.6)

        time.sleep(0.5)

        self.look_center(0.6)


    # ======================================================
    # CLOSE
    # ======================================================

    def close(self):

        self.expression = "sleep"

        self.offset_x = 0
        self.offset_y = 0

        self.draw()

        time.sleep(0.2)

        try:
            self.disp.set_backlight(0)
        except:
            pass

MIT License

Copyright (c) 2026 Calvin Sewornu Kofi Mawulorm

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files, to deal in the Software
without restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies of the
Software, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

Credits

calvin sewornu

5 projects • 3 followers

Thanks to stratosb.

Embed the widget on your own site

Robot Eyes: Smooth Animated Eyes on Raspberry Pi

Robot Eyes: Smooth Animated Eyes on Raspberry Pi

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Why I Built It

Hardware

Display Connections

Setting Up the Display

Designing the Robot Eyes

The Robot Eyes Engine

Smooth Eye Movement

Controlling the Robot Face

Running the Project

Project Structure

robot_eyes_engine.py

robot_face.py

robot_eyes_engine_nop.py

robot_face_nop.py

robot_face_nop_fast.py

robot_eyes.py

README.md

Two Main Versions

Testing

Possible Applications

Future Improvements

Conclusion

Code

robot_face.py

robot_eyes_engine.py

README.md

Credits

calvin sewornu

Comments

Related channels and tags