homemade_hardware

All posts in this category.

Homemade Hardware – Final

 

For my Homemade Hardware final, I decided to continue and pressure the keyboard design. The keyboard itself, is highly influenced by the Roli Seaboard and it’s approach towards multidimensional midi controllers, but rather then an expansive, software specific solution, I wanted to make a ‘cheap-as-possible’ multidimensional midi keyboard controller.

The Roli Seaboard (small version)

Prototyping

I started prototyping the idea of how the keyboard would actually function and ended up using a dual sensor setup for each key, where the pressure is determined by an FSR (force sensing resistor) sitting at the bottom of each key, and your finger position is determined by a soft-pot at the top.

Once everything was working on the breadboard, I moved to Eagle to start designing the board that would read the sensors, and send them over serial to the Raspberri Pi, which would function as the synth, turning the data into either sound/midi commands sent to the computer.

Schematics

Bill of materials:

  1. Atmega328 micro controller
  2. 2x 4051 multiplexers
  3. 16mhz resonator
  4. resistors, capacitors and header pins

I created two boards, one prototype (through hole) and one final (SMD) boards. I started by laying down the parts which I would need, and position them, the two boards are near identical, just the parts (symbols) are different to match the different PCB techniques.

Board schematics

After making the through hole version I wasn’t able to find a 16 channel multiplexer in a surface mounted version, and so decided to use 2×8 channel multiplexers and use the same control pins, so they are chained to the same select pins coming from the micro-controller.

 

Left: through hole board design | Right: surface mount board design

Fabrication

I started with toner transfer, which went surprisingly well. My times were:

  1. Run the board with the vinyl print through the laminator 5 times
  2. Iron each side of the board for 4 minutes, keep constant movement (I listened to dub music which really helped set the down tempo loopy mood for ironing)

After toner transfer was done I acid etched the board which took about 25 minutes for 3 boards.

Assembly

After cleaning the boards from the remaining toner, I started placing the parts I would need to solder and created a solder stencil. One thing that really helped me smooth the solder stencil process was to get rid of unused pins on the Atmega328, which was quite straight forward in Illustrator.

Solder stencil after some Illustrator work

The settings I used for the laser cutter:

  1. Raster mode
  2. Speed: 10
  3. Power: 15

After some more dub music, and quality time with the pick and place machine I was able to get 4 boards soldered and re-flowed. Out of 4 boards, I got 2 working ones which is A LOT compared to my previous ratio when making boards with the Othermill.

Programming was a breeze thanks to this nifty little thing, and I was able to burn the boot-loader and upload my sketch in a matter of minutes, here is the test app I uploaded

After beep testing the boards I drilled and hand soldered all the header pins in place and tested my board with a second Arduino that reads the serial out from the board, and IT WORKS!

Prototype board

Final board

Special thanks to Shir David for help with shooting.

Up ahead

I am currently working on fabrication aspects of the keyboard, such as enclosure, soft key molding and general design thing and would like to continue developing this into a functional ‘multidimensional‘ keyboard.

Homemade Hardware – Week 08 Board

For this week’s assignment we had to make our very own acid etched SMD board. Since we’re getting closer and closer to the final, I decided it would be a good idea to start realizing the final project.

The project

I decided to try and build a two dimensional MIDI keyboard, yes, much like the ROLI seaboard, but different. To start, I realized this project would depend on my ability to plan one key correctly and then realize the full keyboard, so I started sketching how just one key module would look, work and function.

I started prototyping the key and decided to use two sensors per key:

  1. A linear variable resistor (for your finger’s Y position on the key)
  2. An FSR, to sense how hard your pressing down on the key

After getting it to work on the Arduino I went on to make the actual schematics using the ATTiny85 as my MCU, and attaching two status LED’s that would indicate how hard you pressed each of the sensors.

I took the time to fully brush my understanding of Eagle’s wireless networks so my designs could be modular and I don’t have to to decipher where lines are going once the project becomes bigger. For the MCU and I finished my design of the ATTiny85, we started in class, and adjusted its size a bit so it fits. After finishing the schematics I made the board and tried to tidy it up, so it’s small, but not too small (the taste of bad experience with small boards still remains from the Othermill).

After printing I went on to printing and making vinyl toner transfer sheets in order to start my board.

The toner transfer went pretty well, I realized out of 8 boards I designed only 4 came out right, all the rest had at least one issue somewhere. Due to that, it made no sense placing boards that are problematic in the acid bath (that would just take time for nothing), so I cut the rest using the band-saw and went to over to acid etch, with the help of the wonderful David Lockard.

After about 30 minutes of acid, I took the board out, let it cool in water, and started placing the parts

Drilling holes
One of the final boards

Homemade Hardware – Scale board

For this week we had to start prototyping week 8’s board. We had to decide on a concept and start prototyping the board and components for it. After some thought, I decided to either go for a musical instrument, or a weight scale. Given the time scope of the assignment, I decided to go with the weight scale board.

 

Load cells

Since I decided to go with a weight scale board, I started researching into load cells using Arduinos. I used Sparksfun guide to load cells and amplifiers and this Instructable to get comfortable with the idea of using a load cell. I ordered an HX711 amplifier breakout board and a 100 grams load cell. As the board came without header pins, I started by soldering header pins on the breakout board.

 

 

After soldering the the HX711 amp breakout board, I downloaded the HX711 library from the Arduino and connected the load cell to the amp board to the arduino and started measuring. Unfortunately, the load cell didn’t come with threads (screws) and has to be mounted before it could be used accurately because the measurement  hits the amplifier (I ordered 3mm threads so I can mount the scale between two laser cut panels I’ll cut).

Designing a board

To get started with designing the board, I found Sparksfun Github repo that has Eagle schematics for the HX711 breakout board, and so I downloaded it and started deleting parts I don’t really need for my board. I also inserted an ATTiny85 into the board got a basic header layout for power and ground, and for the load cell connections.

Initial board design schematic in Eagle

Homemade Hardware – The story of the R

For this week’s class we had to make an LED letter, that is controlled by a sensor. After some class debate, I got the letter R, and started working on the design. This blog post will recap all my process in the creation of my LED letter. To make it short and concise here is a rundown of everything that happened over the last week in the creation process:

  • I cut my finger 3 times
  • I broke a drill 1/32″ bit
  • I drilled 3 R’s, soldered them entirely and only then realized I had a problem
When I came out of the class the first thing I did, was to cut last week’s board (kind of getting my feet wet before I start cutting this week’s assignment). This process went surprisingly smooth (which says nothing about what’s about to come next).

Design Process

I started by designing the R, I wanted something classic but also the ability to fit all components nicely without having to struggle with getting everything on top of it.

One important thing I realized during the making process is that it’s probably better (at least for my soldering skills) to use an endmill, and make very wide traces, 1/64″ in picture above.

Fab, Fab & Fab

I started by using an engraving bit, which in return led to some really nice looking circuits, but that was literally impossible to solder, plus got me injured while putting the bit on, yes it’s sharp who would have thought so right?

After 4 versions of the same R I was able to get it right, using the 1/32″ end mill bit and with a ton of patience. One thing this homework has thought me well, was to solder, as every single one of the try outs was actually soldered to completion. Some of the reasons it didn’t work on the first tryouts are me using engraving bit, using a double sided board (both sides are conductive, I know now) and poor soldering skills which led some of the boards to essentially not work.

Coding and making it light up

I decided to use a pot to drive the LED’s. instead of having it turn the LED’s on and off, I decided to continue with the breathing effect from the previous week, and add an off feature when the chip reads the pot value to be less then 10, all other values control the ‘breathing speed’ of the effect. Here is how the part that controls the LED’s look:

Demo

Here is a demo video of the R in action

Homemade Hardware – Week 02

For this week’s homework, we had to finish soldering our chip programming shield for the Arduino, and design our circuit with Eagle. I started by practicing soldering, time and time again (and got burned multiple times in the process), and after finishing the shield we started in class it looked something like this

Shield with ATTiny85 socket for the Arduino Uno

During the weekend, I got my Soldering station delivered (thanks Amazon), and decided to re-watch the videos in the lab, plus the NASA soldering tutorials and practice more. To do so, I used an Arduino Proto shield, and soldered two sockets, one for the ATTiny85, and one for the 328, so I have scaling options in the future.

As these proto-bords are two sided, I kept most of the wiring on the bottom, resulting in a clean shield that is easy to carry plus put on and off. One thing I would improve in it, is having female headers on the I/O, so that I can keep the shield on while I use the Arduino as a power source for other circuits. Even though it could use a couple of further mods, the shield acctully saved me a lot of time in programming the chips, since using it feels more like a ‘plug and play’ instead of reorganizing the breadboard whenever something doesn’t work.

After the soldering, I started practicing Eagle in order to create the board for the next class. I actually found the workflow of typing commands to Eagle quite meditating after you dive into a long board design session (with the headphones on), and discover a couple of hours have passed (Oh no). As discussed in class I started with the Schematic view, and was looking for a ATTiny85 schematic symbol online, but all the ones I found wer’e surface mounted, and as we will be covering that topic down the road, decided to use a standard 8-pin socket, which in terms of holes will fit perfectly with the ATTiny85 socket.

My circuit in schematic view in Eagle

After thinking about how the sensor would connect, I suddenly realized since it has it’s own logic board, it would probably make most sense to have headers that would connect to the appropriate place in the circuit but would allow me to mount the sensor’s logic board in a different location (Nice! now to the board design part).

Board view for my circuit

After trying many different configurations, I landed onto this one which is able to fit all the electronics needed in the circuit into a rather small form-factor, but giving appropriate space between lines. One thing I did realise while designing in board view, is that my VCC and GND, were just symbols, and meant I didn’t have any way to ‘wire’ them up, and so I had to go into Schematic view and create headers where power and ground actually connect to the circuit.

Hello Homemade Hardware – Week 01

After this semester’s round of confusion, class swaps and drops I joined the Homemade Hardware class. Prototyping, building and thinking about logic in hardware, was something I really enjoyed doing last semester, and so is seemed like a direct line, in which I could keep on pursuing knowledge in ‘hardware-land’. Enough talking, off to building!

I started by reviewing some of the labs, and essentially working out my soldering, drawing and ‘Arduino’ing’ skills that have faded a little since winter break started. I chose to use the ATTiny85 chip, and decided I would use moisture sensor to drive two status LED’s, one that shows whether there is enough moisture in a plant’s soil, and one to show that it needs more water. After running and the boot-loader, and following the tutorial on programming the ATTiny using the Arduino as the ISP, I was able to get the Blink demo sketch running (YAY, great success, well kind of).

Blinking LED using the ATTiny85 chip

After getting it to work, I decided to test my setup, and therefore used the Arduino to program a small applications that reads a moisture sensor on analog port 1 (A1), and creates a smooth ‘breathing’ LED effect on one of two status LED’s depending on the readings.

After getting the applications to function appropriately and measuring moisture sensor using the Arduino’s serial monitor, it was time to build the circuit using the ATTiny85.

The design for the circuit I wanted to build

After all that was in place I only had to implement the code using the correct naming conventions for the ATTiny85 chip I/O, which sounds trivial but it did take me a reasonable amount of time to figure out, implement the code using the Arduino as an ISP and assamble everything on the breadboard.

Here is a video demonstrating the final circuit doing its thing