Loading files…
Original first-generation open-source insulin pump research prototype
You are viewing the
mk1branch. For the second-generation firmware, Calm Mode, UI simulator, controller PCB, and open KiCad design files, open themk2branch.
IINTS MK1 (Insuline Is Not The Solution) is the original open-source educational insulin pump prototype built around the Raspberry Pi Pico.
The project started as an experiment to understand how insulin pumps work from an engineering perspective: how a motor can create precise linear movement, how that movement can be translated into fluid displacement, and how embedded software can control the complete mechanism.
The first generation of IINTS combines a Raspberry Pi Pico, a stepper-driven syringe mechanism, a display, physical controls, and a 3D-printed enclosure.
Important: IINTS is an educational and research prototype. It is not a medical device, has not been clinically validated or certified, and must not be used to administer insulin or any other medication to a person.
mk1 branch: The original pump firmware, assets, guide, and mechanical
files documented on this page.mk2 branch: The second-generation controller, firmware, Calm Mode,
simulator, PCB sources, and dedicated MK2 documentation are available on
the MK2 branch.I started IINTS in 2024 after becoming curious about the technology behind the insulin pumps I had been using for most of my life.
Instead of treating the pump as a closed box, I wanted to understand what was happening inside it:
IINTS became my way of exploring those questions by building a pump mechanism from scratch.
The project is published as open source so that others interested in embedded systems, electronics, programming, 3D printing and medical technology can study and experiment with the concepts behind it.
The first-generation IINTS prototype consists of several main subsystems:
The Pico controls the motor, display and physical user inputs.
A small stepper motor drives a threaded linear mechanism.
Rotational movement from the motor is converted into linear movement, which pushes the syringe plunger forward.
The motor is controlled through a dedicated motor driver.
The prototype includes:
The mechanical assembly consists of:
The basic mechanical principle is relatively simple.
A stepper motor rotates a threaded spindle. The spindle converts the rotational movement of the motor into linear movement.
That linear movement pushes the plunger of a syringe.
Because the dimensions of the syringe, spindle pitch and motor movement are known, the theoretical fluid displacement per motor revolution or motor step can be estimated.
For a syringe with internal radius (r) and a spindle with pitch (p):
$$ V_{rev} = \pi r^2 p $$
where:
If the motor requires (N_{steps}) controlled steps for one revolution:
$$ V_{step} = \frac{V_{rev}}{N_{steps}} $$
This provides a theoretical relationship between motor movement and syringe displacement.
These equations describe the mechanical principle only. Real systems are affected by factors such as backlash, friction, syringe tolerances, motor accuracy, compliance and assembly tolerances.
The calculations in this repository must therefore not be interpreted as validated medication-delivery accuracy.
The device is controlled by an RP2040-based Raspberry Pi Pico running MicroPython.
A stepper motor provides controlled mechanical movement of the syringe plunger.
A small display provides a graphical interface for interacting with the prototype.
Push buttons allow the user to navigate the interface and control the demonstrator.
The enclosure and several mechanical components can be produced using a standard FDM 3D printer.
The firmware, mechanical designs and documentation are publicly available so that the project can be studied, modified and improved.
| First-generation IINTS prototype |
The exact hardware used has changed during development, but the prototype is built around the following components.
Different revisions of the prototype may use different components or wiring. Check the firmware and hardware files in the repository for the configuration corresponding to a specific revision.
The available 3D-printable components can be found in the /stl directory.
These settings were used as a general starting point during prototyping:
These are prototype settings rather than strict manufacturing specifications.
The firmware is written in MicroPython and runs directly on the Raspberry Pi Pico.
The original prototype was developed using:
MicroPython v1.23.0 – 2024-06-02
for the Raspberry Pi Pico.
MicroPython firmware for the Raspberry Pi Pico is available at:
Connect to the MicroPython REPL and run:
import os
print(os.uname())
The original firmware was primarily developed using Thonny.
Thonny can be downloaded from:
git clone https://github.com/python35/IINTS.git
cd IINTS
You can also download the repository as a ZIP file directly from GitHub.
The repository contains the different parts of the first-generation IINTS project, including firmware, assets and mechanical files.
For example:
IINTS/
├── assets/
│ └── project images and media
│
├── stl/
│ └── 3D-printable components
│
├── main.py
│ └── main MicroPython firmware
│
└── README.md
The exact structure may change as the repository evolves.
IINTS is intended as:
IINTS is not:
The project demonstrates engineering concepts only.
Contributions are welcome.
If you want to experiment with the project:
Improvements to the firmware, documentation, electronics, mechanical design and simulation tools are all welcome.
Please keep the educational and non-clinical nature of the project clear when contributing.
This repository is licensed under the MIT License.
The license allows the source code and project files to be used, modified and redistributed under the terms of the MIT License.
The MIT License does not imply that the hardware or software is safe, clinically validated, medically approved or suitable for use as a medical device.
IINTS is an experimental educational prototype.
The hardware, firmware, mechanical components and calculations in this repository have not been designed, tested, validated or certified for clinical use.
Do not connect this prototype to a person and do not use it to administer insulin, medication or other substances.
Commercial insulin pumps are safety-critical medical devices that require extensive engineering controls, verification, validation, risk management, manufacturing controls and regulatory approval. This project does not provide those guarantees.
Use the repository only for education, research and engineering experimentation.
A special thank you to the coaches of CoderDojo Genk and Hasselt for their guidance and support throughout the development of IINTS.
Their feedback and mentorship helped turn an early experiment into a much larger engineering and educational project.
This repository documents the original hardware-focused generation of IINTS.
The project has since grown beyond the physical pump prototype into broader research and educational work around diabetes technology, simulation, algorithmic safety and transparent medical technology.
The original pump remains an important part of that story: it was the starting point for understanding what happens between a line of software and the physical movement of a medical device.
No comments yet. Be the first to ask about this board.