choosing-components-for-the-power-control-conditioning-monitoring-module

Find the following types of components

• Fixed Regulators
• Adjustable Regulators
• Low cost sensing for current/voltage

Recall the following design goals:

• Swappable components with easy to solder packages.
• Low cost.
• Fixed regulators should have high PSRR
• Adjustable regulators should be able to crank some current
• Sensing should be low cost and we need two of them

revisiting-the-currentfan-module

• Rework the circuit to allow for lower power output so we don’t need a heatsink

choosing-components-for-the-currentfan-driver-module

Find the following types of components

• Digital to analog converter (DAC)
• Power and Mode MOSFET
• PWM MOSFET
• Sense Resistor
• PTC Thermistor

Recall the following design goals:

• Swappable components with easy to solder packages.
• Low cost.
• SPI DAC part with 8- 10 bits.
• MOSFET capable of carrying half an amp in a surface mount package.
• Moderately accurate sense resistor.
• 
  

Approaching Thermocouples

I want to convert the electrical output of a thermocouple to a unitized digital temperature value stored in an Arduino's memory.

Thermocouples:

1. Produce small signals (~41 microvolts per C  delta temperature)
2. Do not produce an absolute temperature but instead a voltage (current?)  between junctions of dissimilar metals
3. The produced voltage is not linearly related to the delta temperature.
4. The currents produced are very small so the measurement system must have high impedance since  we  will be measuring voltage (not current) we don't want to load it down. We want to look a the potential developed across a break in the current loop, physically located at the cold junction.

Common approaches:

1. Use an digital "all in one" single chip solution that deals with  all of the  physical characteristics of a thermocouple and produces a digital output signal.
2. Use an analog "all in one" single chip solution that produces a high level low impedance analog output. 
3. Use a precision instrumentation amplifier with high input impedance, and low offset voltage , An AtoD converter with an abundance of bits (so we don't need so much gain in the InAmp and handle cold junction compensation linearization and unit conversion with  semiconductor temperature sensor  and software running on a microcontroller. 
4. Use the crappiest analog components possible, the least precise,cheapest AtoD converter possible, use the worst, cheapest cold junction sensor  possible. Layout the board for thermal stability and low noise and leakage, design in good thermal contact between the crappy temperature reference and the cold junction. Choose terminal blocks (metallic composition?), trace widths and thicknesses for thermocouple measurement. Add a terminal block "cozy" to enclose the cold junction terminal and temperature reference to get the cold junction terminal temperature closer to the cold junction sensor measurement.  And still produce  a temperature measurement with the  required accuracy and precision and low cost.

Approaches 1 and 2 are constrained to just a single type of thermocouple, since they are hardwired for a particular type.

Approaches 3 and 4 depend on software to convert raw digital measurements to temperature units for any type of thermocouple.

Any of the approaches can have an analog multiplexer added to measure more thermocouples (sequentially)  reducing  measurement rate and the cost per measurement.

We would like to be able to detect faults in the measurement, such as opens and shorts. (some of the all in one solutions have this feature built in)

Questions:

1. Approaches 1 and 2 are uninteresting (except for the PCB thermal design aspects) so they have no questions
2. How to get low offset voltage and high input impedance with approach 3
3. How to get low offset voltage and high input impedance with approach 4
4. How to model the system to determine how good each block must be in approach 3?
5. How to model the system to determine how crappy each block can be in approach 4?
6. How to test that the measurement system meets the design goal once it's built?

Structure of KiCad

I've been having trouble understanding the vocabulary and relationships between parts of KiCad. 

What are these and how do they interact resulting in design files ready for manufacturing?

Or, using KiCad to go from "screen to stuff"

Frequently used  KiCad words.

• schematic
• an diagram of an abstract circuit.
• a circuit diagram
• stored by eeschema in a .sch file
• contains symbols?
• contains or makes use of a net or netlist?
• makes use of components? component libraries?
• never makes use of a module or footprint?
• module
• possibly an alias for a footprint
• I often see descriptions such as "add a module to KiCad"
• Libraries of modules are stored in .mod files
• component
• possibly an alias for symbol
• I often see descriptions such as "add a component to KiCad"
• Components have pins which in turn have names
• Libraries of components are stored in .lib files
• net
• net name
• netlist
• symbol
• possibly an alias for component
• library
• I often see descriptions such as "add a library to KiCad"
• A library that contains "components" is stored in a .lib file
• A library that contains "modules" (aka footprints) is stored in a .mod file
• footprint
• possibly an alias for a module
• a footprint has pads
• pads have netnames
• project
• port, power port
• pin
• an attribute of a component
• pins have  a name
• pad
• footprints have pads, pads have names
• Legend
• text block in the lower right of a "page" on a schematic (eeschema) or PCB (pcbnew)
• Design Rule, Design Rule Check(ing)
• Component Library Editor
• does this edit libraries or components?
• Module Editor
• edit footprints?
• libraries of footprints?
• 
  

Files used or generated by KiCad.

• .sch
• possibly created with eeSchema
• .pro
• .svg
• .pro
• defines connections between a the various files that make up a  "project"
• .kicad_pcb
• .brd
• .net 
• contains,among other things, a "netlist" 

These must correspond to some of the common KiCad words and to each other.

Software Executables
Here's what I find under Linux and what I think their inputs and outputs are:

• /usr/local/bin/pcbnew (10.6 MB)
• /usr/local/bin/bitmap2component (1.6 MB)
• /usr/local/bin/eeschema (4.8 MB)
• .sch and .net files
• /usr/local/bin/gerbview (2.0 MB)
• /usr/local/bin/cvpcb (5.8 MB)
• .cmp files
• /usr/local/bin/pcb_calculator (1.6 MB)
• A calculator, may not read or write files
• /usr/local/bin/kicad (1.1 MB)
•  Seems to be a "launcher for the others"

KiCad workflow.
  What to run, in sequence, creating which intermediate results to go from idea to PCB ?

From https://wiki.apertus.org/index.php?title=KiCAD_Evaluation

component = a symbol of a part in the schematic viewer

footprint = Module = a physical part (eg. chip) in the PCB layout editor

netlist = basically a file (*.net) that lists all connections from each component's pin to another one. Used to connect schematic and board together plus a component/footprint association file (*.cmp)

sources:
http://kicadhowto.org/

understanding-the-arduino-module

• Create a schematic symbol for the Arduino
• Create a block diagram for the Arduino module.

understanding-the-led-driver-module

• Find a component to use for the LED module (earlier than usual)
• Utilize the block diagram on the component datasheet.
• 
  

choosing-components-for-the-power-control-conditioning-monitoring-module

Find the following types of components

• Fixed Regulators
• Adjustable Regulators
• Low cost sensing for current/voltage

Recall the following design goals:

• Swappable components with easy to solder packages.
• Low cost.
• Fixed regulators should have high PSRR
• Adjustable regulators should be able to crank some current
• Sensing should be low cost and we need two of them
• 
  

choosing-components-for-the-relay-module

Find the following types of components

• Relay
• Transistor (NPN)
• Opto isolator
• LED
• Kickback diode

Recall the following design goals:

• Swappable components with easy to solder packages.
• Low cost.
• Relay can handle up to 250V AC (though we suggest using it at 24V DC)
• NPN can easily handle/switch coil current.
• Surface mount opto isolator

choosing-components-for-the-currentfan-driver-module

Find the following types of components

• Digital to analog converter (DAC)
• Potentiometer
• MOSFET
• Sense Resistor

Recall the following design goals:

• Swappable components with easy to solder packages.
• Low cost.
• SPI DAC part with 8- 10 bits.
• MOSFET capable of carrying half an amp in a surface mount package.
• Moderately accurate sense resistor.

choosing-components-for-the-thermocouple-module

Find the following types of components:

• Quad op amp for making a instrumentation amplifier
• Temperature sensor with a simple analog output
• Analog digital converter with 2+ inputs (so we don’t need an external mux)

Recall the following design goals:

• 16+ bit input
• Low cost
• 1 degree C accurate (aim for .5 C accurate)
• Swappable components
• Easy to solder components
• 
  

understanding-the-current-fan-driver-module

• Create a current source with a voltage input, using an op amp.
• Add in an optional DAC to control the current source with voltage readback

understanding-the-thermocouple-module

• Create a block diagram for the thermocouple measurement circuit
• 
  

Creating A Schematic Skeleton *

• Create a schematic with a heirarchical page for each block in the block diagram.
• Add some hierarchical labels within one of the sheets.
• Exit the sheet and import the heirarchical pin to the top level heirarchy symbol.

It seems that KiCAD is lacking drawing features, such as the ability to align  and distribute objects, making drawing diagrams such as this time consuming.

Project Creation *

-- Create a new repo in GitHub for a project.
-- Create a new project in the KiCAD launcher of your choice of name and location.
-- Create a blank schematic file.
-- Create a blank layout file.
-- Push your files to the repo.

A tedious, boring console log of my process:

-- Create a new repo in GitHub for a project.

10 easy steps, no GUI or web browser needed.



1 ➜ workspace git:(master) ✗ mkdir benchbuddy

2 ➜ workspace git:(master) ✗ cd benchbuddy

3 ➜ benchbuddy git:(master) ✗ git init

4 Initialized empty Git repository in /home/george/workspace/benchbuddy/.git/

5 ➜ benchbuddy git:(master) hub create benchbuddy

6 Updating origin

7 created repository: georgeredinger/benchbuddy

8 ➜ benchbuddy git:(master) touch README.md

9 ➜ benchbuddy git:(master) ✗ git add .

10 ➜ benchbuddy git:(master) ✗ gcam "initial commit"

11 [master (root-commit) 376124e] initial commit

12 1 file changed, 0 insertions(+), 0 deletions(-)

13 create mode 100644 README.md

14 ➜ benchbuddy git:(master) git push -u origin master

15 Counting objects: 3, done.

16 Writing objects: 100% (3/3), 215 bytes, done.

17 Total 3 (delta 0), reused 0 (delta 0)

18 To git@github.com:georgeredinger/benchbuddy.git

19 * [new branch] master -> master

20 Branch master set up to track remote branch master from origin.

21 ➜ benchbuddy git:(master)

22 benchbuddy git:(master) ✗ ls

23 README.md

24 ➜ benchbuddy git:(master) ✗


-- Create a new project in the KiCAD launcher of your choice of name and location.
File -> New blank project, in the git directory, then from the command line:


➜ benchbuddy git:(master) ✗ git add .
➜ benchbuddy git:(master) ✗ gst
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# new file: benchbuddy.pro
#
➜ benchbuddy git:(master) ✗ gcam "blank project"
[master 6b57b7e] blank project
1 file changed, 86 insertions(+)
create mode 100644 benchbuddy/benchbuddy.pro
➜ benchbuddy git:(master) git push
Counting objects: 5, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (4/4), 1019 bytes, done.
Total 4 (delta 0), reused 0 (delta 0)
To git@github.com:georgeredinger/benchbuddy.git
376124e..6b57b7e master -> master
--- Create a blank schematic file.
➜ benchbuddy git:(master) ✗ gcam "add blank schematic"
# On branch master
# Untracked files:
# (use "git add <file>..." to include in what will be committed)
#
# benchbuddy-cache.lib
# benchbuddy.sch
nothing added to commit but untracked files present (use "git add" to track)
➜ benchbuddy git:(master) ✗ git push
Everything up-to-date
➜ benchbuddy git:(master) ✗
-- Create a blank layout file.
➜ benchbuddy git:(master) ✗ git add .


➜ benchbuddy git:(master) ✗ gcam "add blank layout file"
[master eade405] add blank layout file
3 files changed, 151 insertions(+)
create mode 100644 benchbuddy/benchbuddy-cache.lib
create mode 100644 benchbuddy/benchbuddy.kicad_pcb
create mode 100644 benchbuddy/benchbuddy.sch
➜ benchbuddy git:(master) git push
Counting objects: 8, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (6/6), done.
Writing objects: 100% (6/6), 1.63 KiB, done.
Total 6 (delta 0), reused 0 (delta 0)
To git@github.com:georgeredinger/benchbuddy.git
6b57b7e..eade405 master -> master
➜ benchbuddy git:(master)

-- Push your files to the repo. 

woops, I pushed to github between each step, 

Mechanical Constraints *

• Measure or look up the dimension of an Arduino Uno. Compare against other versions of Arduino.
• Verify the pin pitch of the stackable connectors on the edge of the Arduino.
• Enter the board outline of the Arduino into PCBnew for a rough 2D guideline.

The board outline looked good in KiCAD, but the in the "printed" version it's  a little hard to see.

Design Constraints *

The task for this unit is to create a list of 5 design constraints for this project. What are our limitations during the design? What kinds of statements should we write down to guide our decisions on a daily basis?

1. Time
   Time is the first constraint because it is the most limited resource in a 10 week course. 
   There's limited time to learn the material
   Limited time for boards and part to arrive
   Limited time to troubleshoot the end product
2. Cost
   Increasing cost can save time, using "an all in one" thermocouple measurement IC would speed  up time time it takes to get a calibrated temperature out of the system. Not using one could result in no "bench buddy" ever getting a thermocouple voltage  converted to conventional units.
3. Availability of components
   If the parts can't be acquired before the end of the class, we have to have a longer class. I like that idea.
4. buildability
   Can the board be built? How much skill is required. 
5. Testability
   How will it be tested, how long will it take, cost, etc
6. 
   

The Importance and The Role of Failure

• List your biggest failure in a project ever on the forum thread for this course unit.

I am a man of many failures, I've burned things up, dropped them, deleted them, or simply have failed to figure them out.

Possibly my most spectacular was when I was using a crucible made from a 4 inch steel pipe to melt aluminum with a homemade furnace in  the driveway in front of my house. I used a beautiful surplus industrial blower  fed with a hose from a propane tank to make the fire inside the furnace. I had a 1.5 inch conduit connecting the furnace to the blower output with a slight downward angle from furnace to blower.  I had my sand mold prepared and standing by ready to pour in the liquid metal. I had no way to measure the temperature of inside of the furnace. I knew it was too hot when the conduit going between the furnace and the blower  began to smoke and droop and molten metal began to come out of the fan. 

Metal melting furnaces I  have built since then have had a drain hole at the lowest point. Crucibles I have used since then have had melting points above the maximum that the furnace can produce.

Most of these failures have  been "private failures"  and so not particularly traumatic.  For me, the ones that hurt the most are when I've promised something and it's turned out  that I cannot  make it happen. For me,even minor "promise failures"--such as going over a time estimate for contract work--seem to sting more than much more spectacular private ones.

• In the event you’ve never had a big failure, explain why you think that is.