Skip to content

Week 10 - Output devices

Group Assignment:

  • Measure the power consumption of an output device.
  • Document your work to the group work page and reflect on your individual page what you learned

Please refer to the group page to read about our group assignment.

Individual Assignment:

  • Add an output device to a microcontroller board you’ve designed and program it to do something.

Learnings from this week's group assignment

This week I learned from the group assignemnt, that the power consumption of the OLED display is very low and that the stepper motor has a specific holding current and requires a bit less power during full speed rotation, then when standing still.

Display

I'm going to try the 0,96'' OLED I2C display with my development board from week 9.

The screen uses I2C for communication. I followed this tutorial page on how to install the library and get started with the program.

So I went ahead with the example and modified the code. On the screen I saw the I2C address that was written 0x78. However, I got no response from the screen. After checking all the connections and measuring that 3,3 V was present on the breakout board I consulted the web and found this post in the arduino forum:

OLED address

Guess what, I works with the 0xBC address.

Screen demo

Now I looked at the code to understand how to manipulate the display's output. There are several ways of drawing shapes, writing text and even bitmap images.

First I started with a simple text message and a horizontal line.

Screen demo2

Then I wanted try displaying a bitmap. The tutorial explains how that is done.

I used this landscape photo, reduced the size to 128x64 and converted it to a monochrome image and hex code.

Landscape

Monochrome

Lastly, I pasted it into the code. 

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0xBC ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

static const unsigned char PROGMEM image_data_w10_bitmap[] = {
    0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xe3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xfe, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0xff, 0xff, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0x7e, 0x3f, 0xe8, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0x3f, 0xf3, 0xbf, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
    0x0f, 0xff, 0xff, 0x10, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 
    0x03, 0x91, 0xff, 0x01, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xc0, 
    0x00, 0x18, 0x8d, 0x81, 0x3f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xfe, 0x00, 
    0x00, 0x0c, 0x01, 0x40, 0x8f, 0xff, 0x1d, 0xff, 0xff, 0x81, 0xff, 0xff, 0xf8, 0x03, 0xc0, 0x00, 
    0x80, 0x00, 0x00, 0x00, 0x0f, 0xfe, 0x08, 0x0f, 0xfc, 0x00, 0x7f, 0xff, 0xf0, 0x00, 0x00, 0x00, 
    0xe0, 0x00, 0x80, 0x00, 0x0f, 0xfe, 0x04, 0x00, 0x00, 0x00, 0x3f, 0xff, 0x80, 0x00, 0x00, 0x00, 
    0x7a, 0x00, 0x00, 0x00, 0x1f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x3e, 0x00, 0x00, 0x00, 0x00, 
    0x4f, 0xc0, 0x00, 0x00, 0x0d, 0xf0, 0x20, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x7b, 0xe0, 0x00, 0x00, 0x33, 0x01, 0xe0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x17, 0xf8, 0x00, 0x06, 0xfe, 0x00, 0x08, 0x3f, 0xdc, 0x1f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x10, 0xff, 0x7f, 0x0f, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x3d, 0xf9, 0xff, 0xfa, 0x00, 0x00, 0x11, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x0c, 0xee, 0xfc, 0xe8, 0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x00, 0x79, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x00, 0x03, 0x2c, 0x00, 0x00, 0x00, 0x00, 0xc4, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x0c, 0x26, 0x40, 0x00, 0x00, 0x00, 0x00, 0x20, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0xa4, 0x3e, 0x00, 0x40, 0x00, 0x00, 0x08, 0x00, 0x1d, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x68, 0x3e, 0x00, 0x00, 0x0c, 0x00, 0x24, 0x00, 0x01, 0x38, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x00, 0x1e, 0x20, 0x00, 0x00, 0x00, 0x13, 0x80, 0x01, 0x3e, 0x00, 0xff, 0xff, 0x6c, 0xa1, 0xe0, 
    0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0xa0, 0xc0, 0x00, 0x03, 0xc0, 0xd8, 0x18, 0x17, 0xe1, 0x00, 
    0x0e, 0x00, 0x00, 0x00, 0x00, 0x89, 0x00, 0xc0, 0x00, 0x00, 0x39, 0x80, 0x00, 0x00, 0x00, 0x00, 
    0x00, 0x1c, 0x00, 0x01, 0x80, 0x82, 0x02, 0x49, 0xe0, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x01, 0x26, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 
    0x00, 0x4f, 0x00, 0x00, 0x00, 0x00, 0xb2, 0x40, 0x00, 0x00, 0x00, 0x80, 0xe0, 0x07, 0x00, 0x00, 
    0x00, 0x82, 0x40, 0x00, 0x08, 0x40, 0x05, 0xf0, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x00, 0x00, 
    0x00, 0x80, 0x20, 0x01, 0xd0, 0x10, 0x30, 0x70, 0x40, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 
    0x00, 0x30, 0x30, 0x00, 0x02, 0x1e, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 
    0x00, 0x00, 0x30, 0x00, 0x07, 0xfc, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x00, 0x00, 0x0f, 0x84, 0x0f, 0xc0, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x01, 0x60, 0x00, 
    0x00, 0x05, 0x03, 0x06, 0x00, 0x20, 0x00, 0x00, 0x0f, 0xe0, 0x00, 0x00, 0x0f, 0xe0, 0x00, 0x00, 
    0x00, 0x01, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x7c, 0x0f, 0x40, 0xfc, 0x00, 0x00, 0x00, 
    0x00, 0x07, 0xe4, 0x04, 0x30, 0x0c, 0x60, 0x00, 0x05, 0x0f, 0x03, 0xff, 0x60, 0x00, 0x00, 0x00, 
    0x40, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x41, 0xc5, 0xf3, 0x70, 0x00, 0x00, 0x00, 
    0xf0, 0x04, 0x08, 0x78, 0x00, 0x12, 0x00, 0x00, 0x06, 0x00, 0xfe, 0x13, 0xe0, 0x00, 0x00, 0x00, 
    0xf8, 0x74, 0x0f, 0xe0, 0x00, 0x00, 0x00, 0x08, 0x03, 0x80, 0x1f, 0xf1, 0xc0, 0x20, 0x80, 0x00, 
    0x98, 0xdc, 0x7e, 0x00, 0x00, 0x00, 0x20, 0x00, 0x40, 0x00, 0x21, 0xc0, 0x00, 0xff, 0xc8, 0x00, 
    0x00, 0x7e, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x43, 0xff, 0xc0, 
    0x00, 0xfe, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0xc0, 0x01, 0x3c, 
    0xa0, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x40, 0x00, 0x00, 0xe0, 0x60, 0x00, 0x1f, 
    0xf0, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x40, 0x95, 0x81, 
    0x78, 0x49, 0x80, 0x00, 0x00, 0x00, 0x0f, 0x40, 0x20, 0x00, 0x40, 0x00, 0x24, 0x07, 0xf8, 0x07, 
    0xc8, 0x60, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x70, 0x00, 0x03, 0x00, 0x3b, 0xff, 
    0xac, 0x68, 0x00, 0x00, 0x18, 0x00, 0x07, 0x00, 0x10, 0x00, 0x1c, 0xc0, 0x07, 0xc7, 0xf0, 0x00, 
    0x2f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x07, 0x4f, 0xc0, 0x00, 
    0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x08, 0x00, 0x00, 0x38, 0x10, 0x38, 0x1f, 0x80, 0x00, 
    0x7f, 0x80, 0x00, 0x00, 0x00, 0x08, 0x0e, 0x00, 0x00, 0x01, 0xc0, 0xc0, 0x00, 0xff, 0x80, 0x00, 
    0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x07, 0x01, 0x00, 0x07, 0x80, 0xcf, 0x60, 0xf8, 0x40, 0x00, 
    0xff, 0xc0, 0x00, 0x7f, 0xe0, 0x00, 0x00, 0x88, 0x80, 0x03, 0x00, 0x02, 0x7f, 0xf2, 0x00, 0x00, 
    0xff, 0xc0, 0x01, 0xff, 0x7f, 0xfe, 0x80, 0x04, 0x30, 0x00, 0x00, 0x03, 0xbf, 0xc2, 0x00, 0x04, 
    0xff, 0xe0, 0x03, 0xff, 0xff, 0xfe, 0x6c, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x07, 0x00, 0x80, 
    0xdd, 0xf0, 0x03, 0xff, 0xff, 0xff, 0x3e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 
    0xed, 0xf8, 0x0f, 0xff, 0xff, 0xf3, 0x1f, 0x81, 0x00, 0x00, 0x00, 0x01, 0x80, 0x06, 0x00, 0x00, 
    0x24, 0x7e, 0x03, 0xff, 0xf8, 0x3e, 0x07, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x40, 0x85, 0x00, 0x00, 
    0x90, 0x1b, 0x03, 0xff, 0xe8, 0x18, 0x83, 0xe1, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 
    0xd8, 0x6a, 0x01, 0xfc, 0x80, 0x18, 0x81, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 
    0x39, 0x6c, 0x21, 0x60, 0x00, 0x18, 0x80, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00
};


void setup() {
  Serial.begin(9600);

  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }
  display.display();
  delay(2000); // Pause for 2 seconds

  // Clear the buffer
  display.clearDisplay();
}


void loop() {

  display.clearDisplay();

  display.setTextSize(1);             // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE);        // Draw white text
  display.setCursor(0,2);             // Start at top-left corner
  display.println(F("Hello, FabAcademy!"));

  display.drawLine(0,20,display.width(),20,WHITE);

  display.display();
  delay(2000);

  display.clearDisplay();

  display.drawBitmap(0, 0, image_data_w10_bitmap, 128, 64, 1);

  display.display();
  delay(2000);
}

That looks nice!

With this success, I'm going to continue with another output device.

Stepper motor

In the shelves of the Fab Lab I found this unipolar stepper motor with a ten tooth sprocket and decided to try it.

My supervisor recommended using the ULN2003 driver breakout board for unipolar motors.

I tried uploading an example code but nothing happened. Not even the LED's lit up.

After trying for a while I went to the Fab Lab again and tried another breakout board and another stepper motor type. That worked, so I used that breakout board to try the first motor with different connections and got very confused while trying to figure out how it is supposed to work. All attempts seemed to either result in no movement or some vibration, but no rotation.

I went back to zero and ended up connecting the the wires in the order stated in the table in the datasheet.

Connection table

I also used the step columns to set the pins output high and low in the "right" sequence. Still, I didn't get the motor to turn.

In a desperate attempt, I rearranged the sequence and guess what - the most obvious order worked (1-2-3-4). That was too easy. (This is called one phase on mode and it turns the motor clockwise)

Step/Pin 1 2 3 4
1 HIGH LOW LOW LOW
2 LOW HIGH LOW LOW
3 LOW LOW HIGH LOW
4 LOW LOW LOW HIGH

The two phase on mode works similar, but two pins are set HIGH simultaniously. It can generate more torque.

Step/Pin 1 2 3 4
1 HIGH HIGH LOW LOW
2 LOW HIGH HIGH LOW
3 LOW LOW HIGH HIGH
4 HIGH LOW LOW HIGH

Here is how the wires have to be connected to the breakout board:

  • P0(A) --- orange
  • P1(B) --- yellow
  • P2(C) --- red
  • P3(D) --- black
  • P4(E) --- blue

The video shows the motor alternating the rotational direction.

And here is the code: 

int motorPin1 = 1;
int motorPin2 = 2;
int motorPin3 = 6;
int motorPin4 = 3;
int delayTime = 10;

void setup() {
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop() {


for(int x=0; x<30; x++){

  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delay(delayTime);
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(delayTime);

}

for(int x=0; x<30; x++){

  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(delayTime);

  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delay(delayTime);

  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
}




}

Speed limits

I experimented with the delay time between the steps, to see how fast I could turn the motor. According to the datasheet it has a pull in rate of 300 pps (pulses per second), which means a delay time of around 3 ms. However, I found that from 5 ms and below, the motor doesn't keep up. That might be either related to the motor or the driver.

With 6 ms per step, the rotational speed would be 208 rpm.

Combining input and output devices

Here I first encountered, that I might need to run multiple tasks in parallel in my code, but wasn't sure what the best approach would be. I found this tutorial, that explains the use of millis().

Things got a bit more complicated, when I made a function for running the stepper motor and I needed to keep track of the steps. I used the switch() case function for that.

Here is the code:

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0xBC ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

const int motorPin1 = 1;
const int motorPin2 = 2;
const int motorPin3 = 6;
const int motorPin4 = 3;
int delayTime = 6;
int step = 1;

const int potpin = A0;

void setup() {

  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);

  pinMode(potpin, INPUT);

  Serial.begin(9600);

  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }
  display.display();
  delay(2000); // Pause for 2 seconds

  // Clear the buffer
  display.clearDisplay();
}

void updateoled (unsigned long duration){
  static unsigned long chrono = millis();
  if (millis() - chrono < duration) return;
  chrono = millis();

  display.clearDisplay();
  display.setTextSize(3);                     // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE);        // Draw white text

  // Display rpm
  display.setCursor(0,10);                    // Start at top-left corner
  display.print(60000/(48*delayTime));
  display.println(" rpm");

  // Display progress bar
  display.drawRect(0,40,display.width(),20,SSD1306_WHITE);
  display.fillRect(2,42,124+7-delayTime,16,SSD1306_WHITE);

  display.display();
}

void runmotor (unsigned long duration) {
  static unsigned long chrono = millis();
  if (millis() - chrono < duration) return;
  chrono = millis();

  switch (step){
  case 1:  
    digitalWrite(motorPin1, HIGH);
    digitalWrite(motorPin2, HIGH);
    digitalWrite(motorPin3, LOW);
    digitalWrite(motorPin4, LOW);
    break;

  case 2:
    digitalWrite(motorPin1, LOW);
    digitalWrite(motorPin2, HIGH);
    digitalWrite(motorPin3, HIGH);
    digitalWrite(motorPin4, LOW);
    break;

  case 3:
    digitalWrite(motorPin1, LOW);
    digitalWrite(motorPin2, LOW);
    digitalWrite(motorPin3, HIGH);
    digitalWrite(motorPin4, HIGH);
    break;

  case 4:
    digitalWrite(motorPin1, HIGH);
    digitalWrite(motorPin2, LOW);
    digitalWrite(motorPin3, LOW);
    digitalWrite(motorPin4, HIGH);
    break;
  }

  if(step < 4){
    step++;
  }else{
  step = 1;
  }


}

void readpot (unsigned long duration) {
  static unsigned long chrono = millis();
  if (millis() - chrono < duration) return;
  chrono = millis();

  delayTime = analogRead(potpin)/5;    // use analog input as step duration in ms
  if (delayTime < 7){                // avoid overspeed
    delayTime = 7;
  }
}


void loop() {


  readpot(100);

  updateoled(200);

  runmotor(delayTime);

}

And a video showing the response:

Solenoid

Because I like making things from sratch, I decided to design and test a solenoid door lock prototype.

The principle is very simple. A coil is wound around a ferromagnetic cylinder. When current flows through the coil a magnetic field is created, that will create an axial force and push the cylinder (made from a ferromagnetic material) in either direction. Because I don't want to energize the coil the whole time and have some kind of fail-safe function, the lock will be held in the closed position by a compression spring. To unlock, the coil needs to be energized.

I looked around and found some parts, that might be suitable.

  • Hex bolt DIN 931 M8 x 80 8.8 (galvanized)
  • Compression spring L = 18,5 mm; k = 280N/mm

We also have enameled wire in the FabLab in 0,4 mm, 0,8 mm and 1,2 mm diameter.

The design was made in Fusion and with the aim to make a quick prototype using only 3D printing and no metal fabrication.

I printed the latch from PETG and the other parts from PLA. I also made an adaptor for the stepper motor's sprocket to use it for winding the coil and wrote a new program to count the number of rotations for me and display them on the screen.

I decided to go for the 0,4 mm wire (20 AWG / 0,5mm^2), which should be able to handle 1,5 A, which is what I found in the specifications for commercial door lock solenoids.

Here are the components:

Solenoid parts

And this is the very improvised setup for winding the coil:

Winding setup

However, next time it would be wise to spend more time on a nice rig to wind the coil with better control and tension. When doing this alone, a foot switch would have been very clever. I managed to get 900 windings on the coil, before it reached the maximum diameter. The tension and pattern is not ideal, so with better winding I assume I would get 1200+ windings on the coil.

Anyway, this is just a proof of concept / prototype so I went ahead and tested the coil with the desktop power supply.

As you can see it works, but the solenoid isn't quite strong enough to fully retract the bolt. A weaker spring might have solved the problem or improving the coil.

Note

I had to utilize the full current the power supply could provide, resulting in the coil getting warm and using more power then I expected. This was the reading on the power supply: 27 V // 3,2 A. So the power consumption was 86 W.