Singer Parts Drawer Holder

February 25, 2017 / Leave a comment

I use these Akro-Mils 10144 D sets of drawers to keep my various electronics components organized. They’re cheap, reasonable quality, but most importantly inexpensive.

Something that I find myself doing a lot is transferring individual drawers around. For example, I have a specific drawer that holds short jumper wires for breadboards. Sometimes I bring this drawer up to campus for working in the lab. Same goes for my misc-resistor drawer. It’s much easier to move the drawer rather than re-packing it.

The problem is that these are open drawers! They don’t have lids, so what I’ll do is put it in a ziplog bag and throw it into my backpack. This is a bad solution, I have a 3D printer, time to get CADing.

I wanted the drawer to be able to lock in place, so it wouldn’t slide out of the holder while in transit, here is a video of the locking mechanism in action:

As I iterated on this design, it became clear that I could get away with a pretty thin wall thickness, and that extending the slot cut made it much much easier to flex the locking mechanism, so the grab point on the outer surface became unnecessary.

Annoyingly, I couldn’t figure out a good solution to be able to use this part without having to use supports.

Here is the Thingiverse Link

If you’re interested, I’m keeping a page of all of my prints. You can find it here.

Tiny Apartment Improvement Project – Wire Shelf Keyboard Holder

February 11, 2017 / Leave a comment

I recently purchased a Prusa i3 MK2 and it is glorious. The price was right, the assembly was straightforward and the print quality is probably better than I will ever need. After printing the requisite amount of dogs and other figurines, it’s time to start using this tool to improve my life.

Keyboard Shelf

I store a lot of my equipment on wire shelves. They’re cheap, easy to move around, and pretty strong. They can hold a lot of stuff, which means I keep a lot on them, and space, much like in the rest of my apartment, is limited. The server that is hosting this webpage lives on one of these shelves, and sometimes I have to manually work on it with a keyboard and monitor. It is a pain to have to dig out a keyboard, but it’s also not worth it to have a keyboard permanently on the shelf taking up space. That desire to maximize space is the motivation behind this project.

Here is the thingiverse page for this project with the parts, if you end up building or modifying it, let me know!

I’ve also added a page on this blog for holding more of my work with 3D printing, this will get fleshed out more as time goes on.

Multiplexing Composite NTSC Video

November 17, 2016 / Leave a comment

This was one of those rare times where I had a hunch, followed it, and had a great result.

So for a project I’m working on for school, we have a robot with multiple composite video cameras onboard. We will be using those cameras seen on DIY drones or in simple security systems. We will be transmitting this video feed via a 5.8GHz video transmitter meant for a drone. We want the operator to be able to switch which feed they’re viewing at a given time, but we don’t want to have to use 3 transmitters and receivers. So to get around this, I thought we might just connect video feeds to a simple analog multiplexer I had laying around from a previous project and see if you could switch the feed that way. Turns out, you totally can. Here’s the eventual block diagram of this part of our project if you’re interested:

The following is the code running on the arduino. Remember, this isn’t doing anything special other than driving the mux:

#define NUMSELECTS 4

int s0 = 2;
int s1 = 3;
int s2 = 4;
int s3 = 5;

int selects[NUMSELECTS] = {s0, s1, s2, s3};
int select_state[NUMSELECTS] = {0, 0, 0, 0};

void setup()
{
  Serial.begin(9600);
  for (int index = 0; index < NUMSELECTS; index++)
  {
    pinMode(selects[index], OUTPUT);
    digitalWrite(selects[index], select_state[index]);
  }
}

void loop() 
{
  if (Serial.available() > 0)
  {
    char inchar = Serial.read(); //assigns one byte (as serial.read()'s only input one byte at a time
    switch(inchar)
    {
      case '0':
        Serial.println("Switching to video signal 0");
        select_state[0] = 0;
        select_state[1] = 0;
        select_state[2] = 0;
        select_state[3] = 0;
        write_selects();
        break;
      case '1':
        Serial.println("Switching to video signal 1");
        select_state[0] = 1;
        select_state[1] = 0;
        select_state[2] = 0;
        select_state[3] = 0;
        write_selects();
        break;
       default:
        Serial.println("Bad input");
        break;
    }
  }
}

void write_selects()
{
  for (int index = 0; index < NUMSELECTS; index++)
  {
    digitalWrite(selects[index], select_state[index]);
  }
}

#define NUMSELECTS 4

int s0 = 2;

int s1 = 3;

int s2 = 4;

int s3 = 5;

int selects[NUMSELECTS] = {s0, s1, s2, s3};

int select_state[NUMSELECTS] = {0, 0, 0, 0};

void setup()

{

Serial.begin(9600);

for (int index = 0; index < NUMSELECTS; index++)

{

pinMode(selects[index], OUTPUT);

digitalWrite(selects[index], select_state[index]);

}

void loop()

{

if (Serial.available() > 0)

{

char inchar = Serial.read(); //assigns one byte (as serial.read()'s only input one byte at a time

switch(inchar)

{

case '0':

Serial.println("Switching to video signal 0");

select_state[0] = 0;

select_state[1] = 0;

select_state[2] = 0;

select_state[3] = 0;

write_selects();

break;

case '1':

Serial.println("Switching to video signal 1");

select_state[0] = 1;

select_state[1] = 0;

select_state[2] = 0;

select_state[3] = 0;

write_selects();

break;

default:

Serial.println("Bad input");

break;

}

void write_selects()

{

for (int index = 0; index < NUMSELECTS; index++)

{

digitalWrite(selects[index], select_state[index]);

}

Sound Supervisor

September 22, 2016 / Leave a comment

I wrote a page summarizing my HackMIT 2016 Project, check it out here!

RS485 Hardware Network 2 – Multi-Byte Communication

August 18, 2016 / 13 Comments

Edit: I don’t really make a point of saying it, but the common ground between the modules isn’t necessary.

Here’s a video of the software running on the boards.

So for this example, there are 4 bytes being transmitted from the master to the slaves.

Start of Transmission (0xDB)
ID of the slave to talk to
The type of command
The data that is transmitted

A transmission to set the pwm value of the green led on the slave with the ID 1 to 100 would be:

0xDB 0x01 0x01 0x64

1	0xDB 0x01 0x01 0x64

This is the schematic of the circuit for this example:

This is the code running on the master Arduino:

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;
int MAX485_Driver_Input_PIN = 11;
int MAX485_Driver_Output_Enable_PIN = 12;

#define NUMSWITCHES 3

int ID_switches[NUMSWITCHES] = {2, 3, 4};
int mode_switch = 5; 

byte IDs[NUMSWITCHES] = {1, 2, 3};

#define TXSIZE 4

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

byte target_node_ID;

struct transmission {

  byte start = 0xDB;
  
  byte ID;
  byte type;
  byte message;

  const int tx_size = TXSIZE;
};

void setup()
{
  software_serial.begin(9600); // begin software serial
  
  pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);
  digitalWrite(MAX485_Driver_Output_Enable_PIN, HIGH); // this disables Receiver Output Enable and enables Driver Output Enable
  
  for (int index = 0; index < NUMSWITCHES; index++)
  {
    pinMode(ID_switches[index], INPUT); 
  }
  
  pinMode(mode_switch, INPUT);
  
  target_node_ID = 0;
}

void loop()
{
  for (int index = 0; index < NUMSWITCHES; index++)
  {
    if ((byte)digitalRead(ID_switches[index]))
    {
      target_node_ID = IDs[index];
      break;
    }
  }
  
  transmission t;
  
  t.ID = target_node_ID;
  t.type = digitalRead(mode_switch);
  t.message = (byte)map(analogRead(0), 0, 1023, 0x00, 0xFF);
  
  byte message[TXSIZE] = {t.start, t.ID, t.type, t.message};
  
  software_serial.write(message, t.tx_size);
}

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;

int MAX485_Driver_Input_PIN = 11;

int MAX485_Driver_Output_Enable_PIN = 12;

#define NUMSWITCHES 3

int ID_switches[NUMSWITCHES] = {2, 3, 4};

int mode_switch = 5;

byte IDs[NUMSWITCHES] = {1, 2, 3};

#define TXSIZE 4

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

byte target_node_ID;

struct transmission {

byte start = 0xDB;

byte ID;

byte type;

byte message;

const int tx_size = TXSIZE;

};

void setup()

{

software_serial.begin(9600); // begin software serial

pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);

digitalWrite(MAX485_Driver_Output_Enable_PIN, HIGH); // this disables Receiver Output Enable and enables Driver Output Enable

for (int index = 0; index < NUMSWITCHES; index++)

{

pinMode(ID_switches[index], INPUT);

}

pinMode(mode_switch, INPUT);

target_node_ID = 0;

}

void loop()

{

for (int index = 0; index < NUMSWITCHES; index++)

{

if ((byte)digitalRead(ID_switches[index]))

{

target_node_ID = IDs[index];

break;

}

transmission t;

t.ID = target_node_ID;

t.type = digitalRead(mode_switch);

t.message = (byte)map(analogRead(0), 0, 1023, 0x00, 0xFF);

byte message[TXSIZE] = {t.start, t.ID, t.type, t.message};

software_serial.write(message, t.tx_size);

}

This is the code running on the slave Arduinos:

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;
int MAX485_Driver_Input_PIN = 11;
int MAX485_Driver_Output_Enable_PIN = 12;

int led_1_PIN = 5; 
int led_2_PIN = 6; 

unsigned long time = 0;  
unsigned long oldtime = 0; 
int state = 0;
int next_ID_button_PIN = 2;

#define NUMSTATES 3
int states[NUMSTATES] = {7, 8, 9};
byte IDs[NUMSTATES] = {1, 2, 3};

#define MESSAGELENGTH 3

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

void setup()
{
  software_serial.begin(9600); // begin software serial
  
  pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);
  digitalWrite(MAX485_Driver_Output_Enable_PIN, LOW);
  
  pinMode(led_1_PIN, OUTPUT);
  pinMode(led_2_PIN, OUTPUT);
  
  pinMode(next_ID_button_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(next_ID_button_PIN), next_ID, RISING); 
  
  set_LEDs();
}

void loop() // run over and over
{
  
  byte start_of_message = 0xDB;
  byte incoming_byte;
  byte message[MESSAGELENGTH];
  
  while (true)
  {
    if (software_serial.available())
    { 
      incoming_byte = software_serial.read();
      
      if (incoming_byte == start_of_message)
      {
        software_serial.readBytes(message, MESSAGELENGTH);
        process_message(message);
      }
    }
  }
}
 
void process_message(byte message[])
{
  byte system_ID = IDs[state];

  byte incoming_ID = message[0];
  byte incoming_mode = message[1];
  byte LED_brightness = message[2];
   
  if (incoming_ID == system_ID)
  {
    byte pin;
    
    if (incoming_mode == 0)
    {  
      pin = led_1_PIN;
    }
    else if (incoming_mode == 1)
    {
      pin = led_2_PIN; 
    }
    analogWrite(pin, LED_brightness);  
  }
}

void next_ID()
{
  time = millis();
  
  //soft debounce
  if (time - oldtime > 200) 
  {
    oldtime = time;
    
    state++;
    
    if (state >= (NUMSTATES))
    {
      state = 0;
    }
  }
  set_LEDs();
}

void set_LEDs()
{
  for (int index = 0; index < NUMSTATES; index++)
  {  
    if (index == state)
    {
      digitalWrite(states[index], HIGH);
    }
    else 
    {
      digitalWrite(states[index], LOW);
    }
  } 
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;

int MAX485_Driver_Input_PIN = 11;

int MAX485_Driver_Output_Enable_PIN = 12;

int led_1_PIN = 5;

int led_2_PIN = 6;

unsigned long time = 0;

unsigned long oldtime = 0;

int state = 0;

int next_ID_button_PIN = 2;

#define NUMSTATES 3

int states[NUMSTATES] = {7, 8, 9};

byte IDs[NUMSTATES] = {1, 2, 3};

#define MESSAGELENGTH 3

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

void setup()

{

software_serial.begin(9600); // begin software serial

pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);

digitalWrite(MAX485_Driver_Output_Enable_PIN, LOW);

pinMode(led_1_PIN, OUTPUT);

pinMode(led_2_PIN, OUTPUT);

pinMode(next_ID_button_PIN, INPUT_PULLUP);

attachInterrupt(digitalPinToInterrupt(next_ID_button_PIN), next_ID, RISING);

set_LEDs();

}

void loop() // run over and over

{

byte start_of_message = 0xDB;

byte incoming_byte;

byte message[MESSAGELENGTH];

while (true)

{

if (software_serial.available())

{

incoming_byte = software_serial.read();

if (incoming_byte == start_of_message)

{

software_serial.readBytes(message, MESSAGELENGTH);

process_message(message);

}

void process_message(byte message[])

{

byte system_ID = IDs[state];

byte incoming_ID = message[0];

byte incoming_mode = message[1];

byte LED_brightness = message[2];

if (incoming_ID == system_ID)

{

byte pin;

if (incoming_mode == 0)

{

pin = led_1_PIN;

}

else if (incoming_mode == 1)

{

pin = led_2_PIN;

}

analogWrite(pin, LED_brightness);

}

void next_ID()

{

time = millis();

//soft debounce

if (time - oldtime > 200)

{

oldtime = time;

state++;

if (state >= (NUMSTATES))

{

state = 0;

}

set_LEDs();

}

void set_LEDs()

{

for (int index = 0; index < NUMSTATES; index++)

{

if (index == state)

{

digitalWrite(states[index], HIGH);

}

else

{

digitalWrite(states[index], LOW);

}

RS485 Hardware Network 1 – Getting Started

August 1, 2016 / 6 Comments

For another project I’m currently working on, I need a way to control multiple microcontrollers in a multi-point, multi-drop network configuration. Luckily, we live in amazing times. As I write this, you you can buy a fully assembled breakout board for the MAX485 chip from Maxim Integrated for a mere $0.45 USD shipped from China.

I bought a 5 pack, here are some of the boards:

RS485 is an old protocol, but is the logical next step for devices I’m already communicating with via RS232. For this example, I’m using 4 Arduino boards of various types.

An Arduino Micro as the master
2 Slave Arduino Leonardos
1 Slave Arduino Pro Mini (5v)

Here is a video of the setup:

The schematic is really straightforward as well. The only tricky bit is that I’m using a software serial port on each of the Arduinos for ease of debugging. Here’s a schematic:

The code to acomplish this is really intuitive as well.

Here is the code for the master Arduino:

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;
int MAX485_Driver_Input_PIN = 11;
int MAX485_Driver_Output_Enable_PIN = 12;

int debug_led = 13;

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

void setup()
{
  Serial.begin(9600); // begin hardware serial
  software_serial.begin(9600); // begin software serial
  
  pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);
  digitalWrite(MAX485_Driver_Output_Enable_PIN, HIGH); // this disables Receiver Output Enable and enables Driver Output Enable
}

void loop()
{
  
  byte to_send = 0; // declare the byte to be sent to the slaves though, init as 0
  int rate;
  
  while (true) 
  {
    // invert the byte to be sent
    if (to_send == 1) to_send = 0;
    else if (to_send == 0) to_send = 1; 
    
    Serial.print("Sending: ");
    Serial.println(to_send);
    
    digitalWrite(debug_led, to_send);
    
    rate = map(analogRead(5), 0, 1023, 0, 1000);
    
    software_serial.write(to_send); // send our byte out to the MAX485
    
    delay(rate);
  }
}

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;

int MAX485_Driver_Input_PIN = 11;

int MAX485_Driver_Output_Enable_PIN = 12;

int debug_led = 13;

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

void setup()

{

Serial.begin(9600); // begin hardware serial

software_serial.begin(9600); // begin software serial

pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);

digitalWrite(MAX485_Driver_Output_Enable_PIN, HIGH); // this disables Receiver Output Enable and enables Driver Output Enable

}

void loop()

{

byte to_send = 0; // declare the byte to be sent to the slaves though, init as 0

int rate;

while (true)

{

// invert the byte to be sent

if (to_send == 1) to_send = 0;

else if (to_send == 0) to_send = 1;

Serial.print("Sending: ");

Serial.println(to_send);

digitalWrite(debug_led, to_send);

rate = map(analogRead(5), 0, 1023, 0, 1000);

software_serial.write(to_send); // send our byte out to the MAX485

delay(rate);

}

This is the code for the slave Arduinos:

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;
int MAX485_Driver_Input_PIN = 11;
int MAX485_Driver_Output_Enable_PIN = 12;

int debug_led_PIN = 9; 

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

void setup()
{
  software_serial.begin(9600); // begin software serial
  
  pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);
  digitalWrite(MAX485_Driver_Output_Enable_PIN, LOW);
  
  pinMode(debug_led_PIN, OUTPUT);
  
}

void loop() // run over and over
{
  byte k;
  
  if (software_serial.available() > 0) // make sure there is something to read
  { 
    k = software_serial.read(); // read in a single byte from the serial port    
    digitalWrite(debug_led_PIN, k); 
  }
}

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;

int MAX485_Driver_Input_PIN = 11;

int MAX485_Driver_Output_Enable_PIN = 12;

int debug_led_PIN = 9;

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

void setup()

{

software_serial.begin(9600); // begin software serial

pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);

digitalWrite(MAX485_Driver_Output_Enable_PIN, LOW);

pinMode(debug_led_PIN, OUTPUT);

}

void loop() // run over and over

{

byte k;

if (software_serial.available() > 0) // make sure there is something to read

{

k = software_serial.read(); // read in a single byte from the serial port

digitalWrite(debug_led_PIN, k);

}

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;
int MAX485_Driver_Input_PIN = 11;
int MAX485_Driver_Output_Enable_PIN = 12;

int debug_led_PIN = 9; 

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

void setup()
{
  software_serial.begin(9600); // begin software serial
  
  pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);
  digitalWrite(MAX485_Driver_Output_Enable_PIN, LOW);
  
  pinMode(debug_led_PIN, OUTPUT);
  
}

void loop() // run over and over
{
  byte k;
  
  if (software_serial .available() &gt; 0) // make sure there is something to read
  { 
    k = software_serial.read(); // read in a single byte from the serial port    
    digitalWrite(debug_led_PIN, k); 
  }
}

#include <SoftwareSerial.h>

int MAX485_Receiver_Output_PIN = 10;

int MAX485_Driver_Input_PIN = 11;

int MAX485_Driver_Output_Enable_PIN = 12;

int debug_led_PIN = 9;

SoftwareSerial software_serial (MAX485_Receiver_Output_PIN, MAX485_Driver_Input_PIN); // RX, TX

void setup()

{

software_serial.begin(9600); // begin software serial

pinMode(MAX485_Driver_Output_Enable_PIN, OUTPUT);

digitalWrite(MAX485_Driver_Output_Enable_PIN, LOW);

pinMode(debug_led_PIN, OUTPUT);

}

void loop() // run over and over

{

byte k;

if (software_serial .available() > 0) // make sure there is something to read

{

k = software_serial.read(); // read in a single byte from the serial port

digitalWrite(debug_led_PIN, k);

}

In subsequent posts, things will start getting more advanced. For now however this should be enough to start from scratch.

Thanks for reading.

Raspberry Pi Digital Hourglass

April 23, 2016 / 2 Comments

Trying to get the most out of a day has been big theme of my life lately, as I’m sure it is for many people. I’ve found that I always manage my time better when things are urgent; I’m considerably more productive when I have to be.

I want an ascetically pleasing way to be able to represent how much time is left in the day at a granular scale, like an hourglass. Watching individual seconds disappear will look cool and (hopefully) create that sense of urgency that I want to induce.

Technically, this is a really simple thing to accomplish thanks to python and pygame. Here’s a video of a proof of concept running on my laptop:

At the start of each day, the display is filled with squares at random locations, with a random color. As each second elapses, a square will vanish.

To make it easier to see for the video, I’ve made the squares much bigger than they will actually be for the final build. This is what the display looks like with the squares at their actual size:

The code really really simple, like less than 100 lines simple. Here’s how it works:

Here’s the version of the code running on my computer in the video:

import pygame
from random import randint
from apscheduler.schedulers.blocking import BlockingScheduler
import datetime

class random_square(object):
    def __init__(self, max_x_location, max_y_location):

        self.x_loc = randint(0, max_x_location)
        self.y_loc = randint(0, max_y_location)

        max_color_value = 255

        red = randint(0, max_color_value)
        green = randint(0, max_color_value)
        blue = randint(0, max_color_value)

        self.color = [red, green, blue]


class clock(object):
    def __init__(self, initial_count, max_count, screen_w, screen_h):

        self.max_count = max_count
        self.screen_w = screen_w
        self.screen_h = screen_h

        # create the screen object, force pygame fullscreen mode
        self.screen = pygame.display.set_mode([screen_w, screen_h], pygame.FULLSCREEN)

        # the screen's width in pixels is stored in the 0th element of the array
        self.square_size = screen_w / 200

        # create the list of squares, initially as empty
        self.squares = []

        # fill the squares with the inital seconds until midnight
        for second in range(initial_count):
            self.squares.append(random_square(screen_w, screen_h))


    # starts ticking the clock
    def start(self):
        scheduler = BlockingScheduler()
        scheduler.add_job(self.tick, 'interval', seconds=1)
        try:
            scheduler.start()
        except (KeyboardInterrupt, SystemExit):
            pass

    # this occurs once every time a unit of time elapses
    def tick(self):
        # this will happen once per "day"
        if len(self.squares) == 0:

            # fill the list of squares to be drawn
            for second in range(self.max_count):
                self.squares.append(random_square(self.screen_w, self.screen_h))

        # draw a blank screen
        self.screen.fill([0, 0, 0])

        # draw the squares
        for square in self.squares:
            rect = (square.x_loc, square.y_loc, self.square_size, self.square_size)
            pygame.draw.rect(self.screen, square.color, rect, 0)

        pygame.display.update()

        # remove a single square from the list as one tick has elapsed
        self.squares.pop()

# initialize pygame
pygame.init()

# figure out the parameters of the display we're connected to
screen_width = pygame.display.Info().current_w
screen_height = pygame.display.Info().current_h
screen_size = screen_width, screen_height

# determine the number of seconds until midnight
seconds_in_a_day = 86400
now = datetime.datetime.now()
midnight = now.replace(hour=0, minute=0, second=0, microsecond=0)
seconds_until_midnight = seconds_in_a_day - (now - midnight).seconds

# create and start the clock!
cl = clock(seconds_until_midnight, seconds_in_a_day, screen_width, screen_height)
cl.start()

import pygame

from random import randint

from apscheduler.schedulers.blocking import BlockingScheduler

import datetime

class random_square(object):

def __init__(self, max_x_location, max_y_location):

self.x_loc = randint(0, max_x_location)

self.y_loc = randint(0, max_y_location)

max_color_value = 255

red = randint(0, max_color_value)

green = randint(0, max_color_value)

blue = randint(0, max_color_value)

self.color = [red, green, blue]

class clock(object):

def __init__(self, initial_count, max_count, screen_w, screen_h):

self.max_count = max_count

self.screen_w = screen_w

self.screen_h = screen_h

# create the screen object, force pygame fullscreen mode

self.screen = pygame.display.set_mode([screen_w, screen_h], pygame.FULLSCREEN)

# the screen's width in pixels is stored in the 0th element of the array

self.square_size = screen_w / 200

# create the list of squares, initially as empty

self.squares = []

# fill the squares with the inital seconds until midnight

for second in range(initial_count):

self.squares.append(random_square(screen_w, screen_h))

# starts ticking the clock

def start(self):

scheduler = BlockingScheduler()

scheduler.add_job(self.tick, 'interval', seconds=1)

try:

scheduler.start()

except (KeyboardInterrupt, SystemExit):

pass

# this occurs once every time a unit of time elapses

def tick(self):

# this will happen once per "day"

if len(self.squares) == 0:

# fill the list of squares to be drawn

for second in range(self.max_count):

self.squares.append(random_square(self.screen_w, self.screen_h))

# draw a blank screen

self.screen.fill([0, 0, 0])

# draw the squares

for square in self.squares:

rect = (square.x_loc, square.y_loc, self.square_size, self.square_size)

pygame.draw.rect(self.screen, square.color, rect, 0)

pygame.display.update()

# remove a single square from the list as one tick has elapsed

self.squares.pop()

# initialize pygame

pygame.init()

# figure out the parameters of the display we're connected to

screen_width = pygame.display.Info().current_w

screen_height = pygame.display.Info().current_h

screen_size = screen_width, screen_height

# determine the number of seconds until midnight

seconds_in_a_day = 86400

now = datetime.datetime.now()

midnight = now.replace(hour=0, minute=0, second=0, microsecond=0)

seconds_until_midnight = seconds_in_a_day - (now - midnight).seconds

# create and start the clock!

cl = clock(seconds_until_midnight, seconds_in_a_day, screen_width, screen_height)

cl.start()

Let’s walk through some of the design decisions of this code. The first thing that’s worth talking about is how the data for the squares is handled:

class random_square(object):
    def __init__(self, max_x_location, max_y_location):

        self.x_loc = randint(0, max_x_location)
        self.y_loc = randint(0, max_y_location)

        max_color_value = 255

        red = randint(0, max_color_value)
        green = randint(0, max_color_value)
        blue = randint(0, max_color_value)

        self.color = [red, green, blue]

class random_square(object):

def __init__(self, max_x_location, max_y_location):

self.x_loc = randint(0, max_x_location)

self.y_loc = randint(0, max_y_location)

max_color_value = 255

red = randint(0, max_color_value)

green = randint(0, max_color_value)

blue = randint(0, max_color_value)

self.color = [red, green, blue]

It’s just an object with no methods, and on initialization, all the parameters of the square (location and color) are generated randomly as opposed to just floating the raw numbers in arrays around (even though that’s basically what is happening). This let’s us fill the squares array very easily later on in the file here:

# fill the squares with the inital seconds until midnight
for second in range(initial_count):
    self.squares.append(random_square(screen_w, screen_h))

# fill the squares with the inital seconds until midnight

for second in range(initial_count):

self.squares.append(random_square(screen_w, screen_h))

and here:

# this will happen once per "day"
if len(self.squares) == 0:

    # fill the list of squares to be drawn
    for second in range(self.max_count):
        self.squares.append(random_square(self.screen_w, self.screen_h))

# this will happen once per "day"

if len(self.squares) == 0:

# fill the list of squares to be drawn

for second in range(self.max_count):

self.squares.append(random_square(self.screen_w, self.screen_h))

When it comes time to draw these squares, it also makes that pretty intuitive:

# draw the squares
for square in self.squares:
    rect = (square.x_loc, square.y_loc, self.square_size, self.square_size)
    pygame.draw.rect(self.screen, square.color, rect, 0)

# draw the squares

for square in self.squares:

rect = (square.x_loc, square.y_loc, self.square_size, self.square_size)

pygame.draw.rect(self.screen, square.color, rect, 0)

Again, very simple stuff, but worth it to talk about.

I’ll be back at my place that has the Raspberry Pi and display I would like to use for this project, so more on this then.

Thanks for reading!

UV Resin Curing Cabinet | Final Code, Schematic, Bill Of Materials and Demo

August 12, 2015 / 1 Comment

Here’s a demo of the finished system:

In the end, it all turned out really well. Painting it white and using a white print stand was a good insight, the light reflects around the box pretty well for how few LEDs are in use.

The software flow chart has changed slightly. I removed the speaker as it wasn’t loud enough and added software debouching for the pushbutton interrupt service routine. Here’s that most recent version:

The interesting parts of the code are the cookResin function as well as the main loop of the Arduino:

void loop() {
  digitalWrite(BUTTONLED_pin, HIGH); 
  displayStaticState(0);
  if (BPRESSED == true) {
    cookResin(14400);
  }
}

void cookResin(unsigned long MAXTIMER){
  unsigned long SECTIMER = 0;
  
  writeLCDLines("CURING TIME REM:", "H:MM:SS  -:--:--");
  
  fadeLEDs(1,1);
  
  while ((SECTIMER &lt; MAXTIMER) &amp;&amp; (BPRESSED)) {
    digitalWrite(BUTTONLED_pin, HIGH); 

    String part0 = String("H:MM:SS  ");
    String part1 = secToHuman(MAXTIMER - SECTIMER);
    String line1 = part0 + part1;
    lcd.setCursor(0, 1);
    lcd.print(line1);

    int DMILSECTIMER = 0;
    while ((DMILSECTIMER &lt; 10) &amp;&amp; (BPRESSED)){
      digitalWrite(BUTTONLED_pin, HIGH); 
      Alarm.delay(100);
      //Alarm.delay(1);
      DMILSECTIMER++;
    }
    SECTIMER++;
  }
  
  if (BPRESSED == false){
    //start of cancelled cure end
    
    displayStaticState(2);
    
    fadeLEDs(0,1);
    
    
    delay(1000);
    BPRESSED = false;
    
    //end of cancelled cure end
  } else {
    //start of successful cure end
  
    displayStaticState(1);
    
    fadeLEDs(0,1);
    
    delay(1000);
    BPRESSED = false;
    
    //end of sec cure end
  }
  
  return;
  
}

void loop() {

digitalWrite(BUTTONLED_pin, HIGH);

displayStaticState(0);

if (BPRESSED == true) {

cookResin(14400);

}

void cookResin(unsigned long MAXTIMER){

unsigned long SECTIMER = 0;

writeLCDLines("CURING TIME REM:", "H:MM:SS -:--:--");

fadeLEDs(1,1);

while ((SECTIMER < MAXTIMER) && (BPRESSED)) {

digitalWrite(BUTTONLED_pin, HIGH);

String part0 = String("H:MM:SS ");

String part1 = secToHuman(MAXTIMER - SECTIMER);

String line1 = part0 + part1;

lcd.setCursor(0, 1);

lcd.print(line1);

int DMILSECTIMER = 0;

while ((DMILSECTIMER < 10) && (BPRESSED)){

digitalWrite(BUTTONLED_pin, HIGH);

Alarm.delay(100);

//Alarm.delay(1);

DMILSECTIMER++;

}

SECTIMER++;

}

if (BPRESSED == false){

//start of cancelled cure end

displayStaticState(2);

fadeLEDs(0,1);

delay(1000);

BPRESSED = false;

//end of cancelled cure end

} else {

//start of successful cure end

displayStaticState(1);

fadeLEDs(0,1);

delay(1000);

BPRESSED = false;

//end of sec cure end

}

return;

}

Again, this all should all be explained by the flow chart. The full source can be found at the bottom of this post.

The circuit schematic hasn’t changed at all since this post, here’s a fritzing of what’s going on:

Super simple, basically a screen and a button. The parts to make this are here:

Assembly is super straight forward, if you’re trying to build one and have any questions, let me know!

Thanks for reading!

UV Resin Curing Cabinet | CAD Modeling And Physical Build and Installation

August 12, 2015 / Leave a comment

This past school year I too several classes related to 3D modeling. One class in particular, a class based around SolidWorks. I hadn’t really been able to use the software again, not having the tools to actually execute. MADE@MassChallenge really has the whole kit, 3D Printers, a 40W Laser Cutter etc. All the tools of a hackerspace as a part of my job. Here’s a “finished” model of the system:

Cure Cab Models

The frame is built out of:

.22in thick masonite painted black on one side
The frame is held together with a series of L brackets and machine screws from home depot
The front opening is secured with two metal hinges from home depot

There were a couple 3D modeled components as well:

The four feet

I ended up gluing these down with hot glue even though they have cuts for screws. In the end, it wasn’t worth it to use more screws and add more complexity.

The electronics enclosure

View post on imgur.com

There is a frosted acrylic sheet inserted in the top. One of the goals of this project was to show off the tech, and I think this does that quite nicely.

The knob assembly

View post on imgur.com

The knob has a stem that comes of the back and forces the hinge back, keeping the door closed. I wanted to try and keep things as simple as possible. The threads I modeled weren’t within tolerance. So I just glued the nut in place so the knob could rotate freely.

The print stand, for holding up the prints so they cure evenly

View post on imgur.com

It doesn’t make sense to have the prints just sit on the bottom of the frame. I also cut inserts that fit the inside of the print stand. This is so resin doesn’t cure to the print stand so it can be used many times while only needing to change the cardstock inserts.

Here are some more photos of the build process:

Cure Cab Build Photos

I’ll include the plans to build this whole assembly in the final post for this project once it’s all finalized.

UV Resin Curing Cabinet | Declaration and Software Flow

August 10, 2015 / Leave a comment

This project is the first of what I hope to be many in collaboration with the MADE@MassChallenge Hardware lab. The primary goal of this project is to speed up the time to delivery on prints coming out of the Formlabs Form 1+ SLA 3D printer using UV LEDS. Here’s a proof of concept of my circuit:

One of my tasks during my internship at MassChallenge was managing the queue of incoming models to be 3D printed on our 3D printers. Turnaround is often a pressing issue when doing this. It was often the case that teams had a deadlines or presentations that they needed parts for. Shaving even minutes off of the time from submission to receiving a fully processed part mattered quite a bit.

The Form 1+ is an amazing printer. If used correctly, the print quality can be much higher than the other 3D printer in MADE, a uPrint SE Plus by Stratysis; a printer almost 5 times the cost.

The post processing involved with the Formlabs has a steeper of a learning curve and leaves a lot of room for possibly destroying a part in the process.

The problem is not a fault of Formlabs, but rather a problem in the chemistry behind the resins used to create the parts. They are photopolymers, and need UV light to be cured. It is suggested that this be done through exposure to sunlight, but that takes quite a long time. I also have a sneaking suspicion that there are adverse effects of doing this, but I can’t prove any of that as of now but hopefully more on that later.

As this is a project that will be used by people other than myself, it is worth it to commit time and effort into the user experience. Atheistic should also be taken into account as this has to stand up next to the beautiful design of the Form1+. In short, a UV LED strand, a 3A switch, a power supply and a Light tight box could functionally do the trick, but in this case a polished design is as important as the functionality.

At this point, a push button switch, a rocker switch and a 16×2 Character LCD will be the UI. The software flow is as follows:

I’ll post the final code when I finish, but this chart is basically what the code running in the above video looks like.

Thanks for reading, more on the physical construction in the next post.