Q State</th>	M</th>	Row</th>	Col</th>	Row-Col</th></tr></thead>
ON</td>	Low</td>	VDD</td>	VEE</td>	+13.3</td></tr>
ON</td>	High</td>	VEE</td>	VDD</td>	-13.3</td></tr>
OFF</td>	Low</td>	V2</td>	V3</td>	+1.9</td></tr>
OFF</td>	High</td>	V5</td>	V4</td>	-1.9</td></tr> </tbody></table> For a pixel to be OFF (clear) the voltage difference between the electrodes is 1.9 volts and for a pixel to be ON (dark) the voltage difference is 13.3 volts. The scope output below shows the voltages on the electrodes for row 1 and column 1, as well as the latch/load clock and the M signal for one complete frame. The M signal alternates every 5 falling edges of the load/latch clock (look for the very thin yellow peaks) and the electrode voltages swap each time the M signal changes. This output shows the somewhat unrealistic, but helpfully illustrative, case where every row and every column are ON at all times. Normally only one output of the row driver IC would be activated at any given moment.</p> The MATH output shows the column voltage minus the row voltage. This alternation results in a AC signal with a peak-to-peak amplitude of 2\|VDD-VEE\|.</p> </p> The following scope output shows exactly the same signals, just zoomed in on the time axis.</p> </p> The next output still shows the same signals, but with the more realistic scenario where the rows are being activated one at a time while every pixel in every column is ON (dark). Each row is being turned dark one at a time as the row IC driver shifts through it’s 64 outputs before starting again.</p> Looking at the results of the difference between the row and column voltages, it is clear that the difference in voltage is large enough to darken the pixels in row 1 only for the time between the first and second latch clock pulses. Since the M signal changes every 5 latch clocks and that doesn’t divide evenly into 64, the voltage applied to the cells in this row will keep flipping as the row driver IC loops back around.</p> </p> Loading Data</h5> In brief:</p> The output buffer of each column driver is serially filled with 80 bits of data</li> Each bit gets read in on the falling edge of the data clock</li> Once the buffer is full the first time, the latch clock latches the buffer out to the drive circuitry</li> At effectively the same moment the frame clock shifts a 1 into the first bit of the row driver</li> The column buffers get refilled (240 data clocks), the active output of the row driver shifts to the next row and the column data is latched to the pins.</li> This continues over and over with a 1 getting shifted into the row driver every 64 latch clocks</li> </ul> Filling the Column Buffers</h6> The screen is split into two sections, each 240 pixels wide. The two halves are loaded in parallel and all the logic is the same for each half. Until I get into the software we can ignore the right half of the screen and pretend there are only three column driver ICs.</p> All three ICs have their serial inputs connected together and brought out to header pin 1. This means each IC sees all 240 bits of data but only accepts 80. This is accomplished though the CDI and CDO pins. When CDI (Chip Disable) is low the chip is enabled and will read in data from the serial input. When the CDI pin is high it won’t. The following steps go through the process of filling all three buffers.</p> Start with all buffers empty (due to the latch clock)</li> CDI1 is held low, CDO1/CDI2 and CDO2/CDI3 begin high</li> After the first 80 bits have been read into IC1, CDO1 (and thus CDI2) goes low</li> IC1 is full and so will ignore the remaining 160 bits</li> The middle set of 80 bits are read into IC2, CDO2/CDI3 goes low</li> IC1 and IC2 are both full and thus ignore the remaining 80 bits</li> The last 80 bits are read into IC3</li> </ol> The scope output below illustrates these steps. CDI1 is not shown since that pin is always held low. CDO1/CDI2 is high for the first third of the data and CDO2/CDI3 is high for the first two thirds.</p> </p> Multiplexing</h6> There are three “clock” signals which control the ability to multiplex the data, thus controlling many pixels with only a few pins.</p> The Data Clock (CP) controls the loading of data into the buffers in the column driver ICs, the state of the SDI pin is read in on each falling edge of the data clock.</li> The Latch Clock (load) has several roles It controls when the column buffers are latched to the output pins</li> It provides the clock signal to the counter IC which produces the alternating M signal every 5 latch clocks</li> It provides the clock signal to the column driver, shifting the active row each time.</li> </ul> </li> The Frame Clock (DIO1) is really the input data signal for the row driver IC, the state of which is clocked in by the latch clock. However, it’s useful to think of it as the “clock signal” which begins a single frame.</li> </ul> The following scope output shows the relationship between the data clock, latch clock and frame clock. There are 30 groups of 8 data clock pulses between each latch clock due to the data being read in one bit at a time from 8 bit chunks.</p> </p> Real Example</h5> The scope output below shows the beginning of a row where the data 01110 is being loaded, corresponding to three dark pixels with a clear pixel on either side.</p> </p> Read Part Two</a>!</p> Electronic Load 2017-05-19T00:00:00+00:00 The simplest load is a plain old resistor, and for many testing applications that will be perfectly adequate. However, when testing power supplies and batteries one often needs to set the exact current draw and have it remain constant across a range of voltages. This video</a> by Dave Jones showcases a simple design which uses an opamp in a negative feedback configuration controlling the base of a MOSFET to maintain the voltage across a sense resistor.</p> The Math</h4> Mostly I want a load that can handle 1 or 2 amps for long periods, but I’d like it to be able to go up to 5 amps for shorter periods. A 1 ohm sense resistor must then be rated for at least 25 Watts (\( P=I^2R \)). I’d also like to be able to handle up to 30 volts at 5 amps which means the MOSFET must be able to dissipate \((5A)(30V)-25W = 125W\). The figure below shows the power dissipated assuming an ideal sense resistor and MOSFET as a function of current for various supply voltages. Fortunately I had on hand a few high power MOSFETs from an old receiver which meet the criteria quite nicely.</p> </p> The IRFP450A MOSFET has a max drain-source voltage of 500 volts, a max power dissipation of 190 Watts, can handle up to 8.7 Amps at a case temperture of 100 degrees Celsius, and has a nice low drain-source on resistance of 0.4 Ohms. From figure 1 in the datasheet we can see that to obtain 5 Amps the minimum required gate-source voltage is 6 volts (and drain-source is 1.5 volts). Since at 5 amps the voltage drop across the sense resistor will be 5 volts, the opamp has to be able to output at least 11 volts and supply under test must be above 6.5 volts. Testing the opamp I’m using revealed that it can output up to Vcc-1.5V. Thus a Vcc of 12.5 volts is required.</p> The Parts</h4> LM358P Dual Opamp</li> Potentiometer</li> IRFP450A Power MOSFET (Datasheet</a>)</li> 1 Ohm 25 Watt Power Resistor</li> Large heatsink with fan</li> Thermal Paste</li> 2 standard resistors for voltage divider</li> Screw terminal</li> 9 volt battery and holder</li> Boost Converter</li> Banana jacks</li> Toggle switch</li> Panel Voltmeter</li> Copper clad board</li> Feric Chloride</li> Label backing paper</li> Laser Printer</li> </ul> The Circuit</h4> The circuit shown below is designed to connect directly to a 9V battery, but after I built it I added in a voltage boost converter in series with the battery to let me jump the voltage up to 12.5V. The voltage divider formed by R1 and R2 drop 9V down to 5V and the sense resistor of 1 Ohm gives a direct conversion to current. These can be changed such that the max output voltage from the first opamp is dropped down to a voltage equal in number to the max current you want the load to ever “ask for.”</p> A convenient result of using a 1 Ohm sense resistor is that I can use a simple panel voltmeter to measure the current to an accuracy decent enough for most of my applications. (Avoid the 2 wire meters which measure and power themselves from the same rail.) You might notice there are no dedicated connections for the meter on the circuit. I realized this too late in the process and so I just tacked the wires down at the appropriate points on the board.</p> </p> PCB Design</h5> The image below shows a PCB design for this circuit created in KiCad. The main current loop is shown by the yellow highlighter. Parts can be directly soldered to the board but items such as the sense resistor, MOSFET, pot, and the terminals for connecting power supplies under test I connected via jumper wires so they could be mounted elsewhere. The low power traces and other tolerances are wider than one would usually make them since I wanted to experiment with etching my own board.</p> The two thick traces on the right side should be covered in solder to increase their current carrying capacity.</strong></p>* </p> PCB Etching</h5> After a variety of failures and running to the store for tiny carbide drill bits I managed to create a workable board with only one bodge wire (this has been corrected in the schematic above).</p> My etching process</p> Export just the copper layer from KiCad (not mirrored)</li> Cut copper clad board to match size</li> Peel labels off of backing material and cut out a piece of backing material large enough to print the circuit on</li> Rub the shiny side down with Acetone</li> Tape to a sheet of printer paper using masking tape (print to paper first to be sure the location is correct)</li> Print with laser printer</li> Place toner side down onto copper clad board, cover with tin foil, and press down with a clothes iron for several minutes</li> Carefully remove paper (may help to soak in a bowl of water)</li> Place copper clad board in a Ferric Chloride bath and agitate until all visible copper is removed</li> Remove toner with acetone</li> Drill holes (the huge pain-in-the-ass part no one ever mentions)</li> Place components on copper free side so that the legs stick through to the copper side where soldering will happen</li> </ul> </p> The Enclosure</h4> I used a steel box I had from taking apart some old broken equipment which I decided to use for the project box. The idea is that the whole container will form part of the heatsink. To avoid drilling into steel as much as possible, I designed an adapter plate to be 3D printed which would house the controls and fit into the odd oval-ish hole in the box.</p> </p> Putting it together</h4> I drilled holes in the housing and used M2 and M3 bolts to firmly attach the adapter plate, sense resistor, MOSFET and heatsink. Before mounting, thermal paste was applied as needed, and the MOSFET was electrically isolated using a mica sheet. I glued a section of foam to the case for the circuit board to sit on top of to prevent shorting the copper traces on the metal of the chassis.</p> </p> After some testing, I found that the max continuous dissipation in this configuration was about 30 watts and added that warning to the case.</p> </p> Testing</h4> The first plot shows what what the maximum current draw is as a function of the device under test voltage. In theory this would be that voltage divided by 1.4 Ohms (Sense resistor + MOSFET on resistance).</p> </p> The second plot shows the maximum total power dissipated by the load at the same voltages.</p> </p> Future Modifications</h4> I went the battery route for extra portability, but it goes through batteries pretty fast when the fan is running so for long tests I’m going to add in a power jack.</p> I’m going to work on changing the heat dissipation setup so I can get at least 50 watts.</p> PHYS3098: Circuits 2017-04-04T00:00:00+00:00 I taught the circuits lab for physics majors three times, the first time as a grad student and the second and third times as an instructor. I really enjoyed teaching this lab, partly because I learned so much myself.</p> The second year, I did a complete rewrite of all the labs. Below are links to the full labs and summaries of what was covered in each lab.</p> Lab 1 - Instrumentation and Measurements (pdf)</a></h4> </p> Using a multimeter without letting the magic smoke out of the fuse, operating a variable DC power supply and a function generator, building circuits on breadboards, voltage divider circuits, and proper oscilloscope usage. Ends with a discussion of uncertainty and propagation thereof.</p> </div> Lab 2 - Input and Output Impedance (pdf)</a></h4> </p> Measure the input impedance of a voltmeter and an oscilloscope, and observe the effects of measurement equipment loading a circuit. Analyze resistive and capacitive voltage dividers. Measure the output impedance of a function generator.</p> </div> Lab 3 - RC Circuits (pdf)</a></h4> </p> Measure the time constant of charging and discharging RC circuits. Derive RC circuit voltages using complex analysis and use this to build integrator and differentiator circuits with outputs accurate to within 1%. I created a YouTube video</a> showing an example derivation.</p> </div> Lab 4 - Thevenin Equivalence and Filters (pdf)</a></h4> </p> Analyze a resistor circuit using Thevenin’s Theorem, construct low and high pass RC filters, create Bode plots from amplitude data, build LC bandpass and notch filters and use an oscilloscope as a simple spectrum analyzer.</p> </div> Lab 5 - Wave Behavior and Filter Design (pdf)</a></h4> </p> Use a bandpass filter to pull out the Fourier components of a square wave. Design and construct a two stage RC and a third order Butterworth low pass filter.</p> </div> Lab 6 - Filters, Diodes, and Power Supplies (pdf)</a></h4> </p> Combine three sine waves of different frequencies and design three filters to pull each one back out. Compare small signal, Schottky and Zener in a half wave rectifier. Build a variable regulated DC power supply.</p> </div> Lab 7 - LTSpice Simulations and IV Curves (pdf)</a></h4> </p> Use LTSpice to simulate a voltage divider, a high pass filter in the time domain, create a Bode plot, and the IV curve for a diode. Measure the real life current and voltage values for a diode and create an IV plot.</p> </div> Lab 8 - Transistors I (pdf)</a></h4> </p> Measure collector and base current and base-emitter voltage for NPN and PNP transistors. Create plots of collector current as a function of base-emitter voltage, and collector current as a function of base current. Design and construct a “night light” circuit which turns on an LED when the ambient lights gets dim.</p> </div> Lab 9 - Transistors II (pdf)</a></h4> </p> Construct an unbiased emitter follower. Design and construct a biased emitter follower. Construct an LC oscillator and connect to the biased emitter follow to demonstrate its use as a buffer amplifier and impedance transformer. Use the oscilloscope to build a curve tracer and examine the curves for diodes, resistors, capacitors, inductors and transistors.</p> </div> Lab 10 - Operational Amplifiers (pdf)</a></h4> </p> Construct an inverting amplifier and a summing amplifier. Build a closed loop PID constant illumination controller using eight opamps and a phototransistor.</p> </div> Lab 11 - Digital Logic and Audio Synths (pdf)</a></h4> </p> Construct NAND, NOT, AND, OR and NOR gates using NAND logic with LEDs showing the state of each gate. Using 555 timer ICs construct astable and monostable multivibrators. Link these together to form a simple audio synthesizer, often called the Atari Punk Console.</p> </div> Lab 12 - Microcontrollers I (pdf)</a></h4> </p> Set up the Arduino IDE and upload code to a SparkFun Redboard. Use the microcontroller to control an RGB LED. Read in values from a flex sensor and set the position of a servo accordingly. Control a relay via a transistor and use a scope to show why a flyback diode is needed. Display text on an LCD.</p> </div> Lab 13 - Microcontrollers II (pdf)</a> (code)</a></h4> </p> Decode the signal from an IR remote. Build a 5-bit R-2R digital to analog converter (DAC). Hook up the DAC to a common collector amplifier and a speaker. Synthesize sine waves corresponding to musical notes using direct digital synthesis (DDS). Use the remote control to select various frequencies, creating a remote controlled piano.</p> </div> Teaching an old scope new tricks. 2016-11-19T00:00:00+00:00 I have an old analog Tektronix oscilloscope I use for my home projects which has served me quite well over the last couple years. One gripe I do have is that when I switch my probe to x10 attenuation mode, the backlight on the voltage dial shows the wrong number. If I was using the proper Tek probes there would be a little pin which would connect to the metal ring around the BNC connector on the scope. This would tell the scope when I switched in to x10 mode and switch the backlight position on the voltage dial. This would be especially useful for when I take pictures of the scope display for future reference and I need the numbers in the picture to be correct, not off by a factor of 10.</p> As a poor grad student, I’m not going to go spend money on new probes just for this minor feature. Instead I decided to install a switch for each channel which would allow me to manually change the voltage backlight as needed.</p> </p> Of course the first thing to do is dive into the data sheet and figure out how the lights are connected. Fortunately the data sheets are all available online. Since this scope is modular, there is a data sheet for each of the three modules and a overall data sheet for the scope body. I have two different amplifier modules, but the lights work the same in each. Here is the data sheet for the simpler one, the 5A15N.</a></p> I found a promising looking section of the schematic (shown below, red additions mine) which noted “with probe”. When I looked up DS191 and DS192 I found that they are indeed neon indicator lamps.</p> </p> </p> The base of transistor Q191 is normally pulled high by R190. This both connects the x1 light to GND (completing its circuit) and keeps the base of the transistor Q192 low and thus the x10 light off. So I just need to make a switch to pull the base of Q191 low which will result in the base of Q192 being pulled high (by the 1 MOhm resistor) thus completing the circuit for the x10 light. From some other reading I did it seems like the Tek probes connected the base of Q182 to ground through a ~10k resistor, it would probably be fine either way, but I’ll go ahead and use the resistor. With the 150k and the 10k resistors forming a voltage divider when the switch is closed, the base of the transistor would be at (510)/(150+10) = 0.3 volts which is easily low enough to turn off Q191.</p> The modifications are shown on the schematic in red.</p> Once I settled on using a latching pushbutton style switch scavenged from an old receiver, I set about performing the requisite physical modifications. Namely, mounting the switch and drilling a hole in the front of the case. As is shown in the left image below, I went for the very high tech piece-of-wood-glued-in-place option.</p> </p> In the wiring shown below, the black wire connects to ground and the resistor lead (covered in red heat shrink tubing) connects to the wire going out to the x10 sense ring. When the switch is clicked out the two legs are internally disconnected and when it is clicked in the legs are internally connected.</p> </p> And now I have a nice easy way to switch the scope between x1 and x10 mode.</p> </p> Since I have a 3D printer I can’t help but model up some switch covers in Fusion 360 and give the whole project just a little extra finesse.</p> </p> I’m quite pleased with the final result and it will make using the scope rather more convenient.</p> Voltaic Pile 2016-10-15T00:00:00+00:00 I found the available information to be sadly lacking in data and graphs and so proceeded to do my part to rectify the situation. The details are in the Instructable I wrote</a>, but here is a brief summary.</p> For a voltaic battery constructed out of copper and zinc cells the voltage per cell is between 0.9 and 1.0 volts. The internal resistance (with a salt and vinegar electrolyte solution) is about 640 Ohms per cell.</p> </p> The graph shows how I determined the internal resistance for various situations. Knowing the voltage and the internal resistance, I calculated that it would take 710 batteries each containing 10 cells, where each cell consists of two pennies, to build a battery capable of putting out 5 volts at 0.5 amps, that is, a mediocre phone charger.</p> That comes out to $142 worth of pennies.</strong></p>* Lists of Top 100 Books 2016-09-24T00:00:00+00:00 I love reading and I’ve often thought of working my way through reading every book on a “top books” list. But which list to choose? What books show up consistently? What authors are always represented but with different works? How representative are book lists with regards to historical works?</p> I was thinking about these questions at the same time as I was interested in learning more about bash programming and AWK. This project is the result.</p> Which Book Lists to Choose?</h4> I decided to stick to top 100 lists and to avoid specific lists like “Top 100 scifi novels.” Some of the following are chosen by voting readers and some by literary experts.</p> BBC’s Big Read Top 100</a></li> The 100 Favorite Novels of Librarians</a></li> Goodreads Top 100 Literary Novels of All Time</a></li> Harvard Book Store Top 100 Books</a></li> Modern Library 100 Best Novels (Board’s list and Reader’s list)</a></li> NPR 100 Best Beach Books</a></li> </ul> Data Wrangling</h4> I downloaded the raw HTML for each page and wrote AWK scripts to pull out the title and author.</p> An example of the HTML, in this case from GoodReads.</p> <tr itemscope itemtype="http://schema.org/Book"> <td valign="top" class="number">1</td> <td width="5%" valign="top"> <a name="1885"></a> <a href="/book/show/1885.Pride_and_Prejudice" title="Pride and Prejudice"> <img alt="Pride and Prejudice" class="bookSmallImg" src="http://d202m5krfqbpi5.cloudfront.net/books/1320399351s/1885.jpg" /> </a> </td> <td width="100%" valign="top"> <a href="/book/show/1885.Pride_and_Prejudice" class="bookTitle" itemprop="url"> <span itemprop='name'>Pride and Prejudice</span> </a> <br/> <span class='by smallText'>by</span> <span itemprop='author' itemscope='' itemtype='http://schema.org/Person'> <a href="http://www.goodreads.com/author/show/1265.Jane_Austen" class="authorName" itemprop="url"><span itemprop="name">Jane Austen</span></a> </span> </code></pre> The following AWK script was used to pull out the title and author and write that information to a tab delimited file.</p>#!/usr/bin/awk #awk -f extract<name>.awk -f functionLibrary.awk <name>.html #Source: http://www.goodreads.com/list/show/13086.Goodreads_Top_100_Literary_Novels BEGIN{ FS="<[^>]+>"; OFS="\t"; lineCount=100; rankIterator=0; } FNR==1{ split(FILENAME,fileNameArray,"."); outputFile = fileNameArray[1]".table"; } /itemprop='name'/{ title=$2 #print FNR,title } /class="authorName"/{ author=$3 #print FNR,author currentLine=FNR } FNR==currentLine{ numNames=split(author,authorNameArray," "); firstNames=join(authorNameArray,1,numNames-1); #rank=weightBook(lineCount,rankIterator++); print title,authorNameArray[numNames],firstNames > outputFile; } </code></pre> The result was a file for each list with the book title and the authors name on each line (family name followed by given name).</p> Pride and Prejudice Austen Jane 1984 Orwell George The Great Gatsby Fitzgerald F. Scott Jane Eyre Brontë Charlotte Crime and Punishment Dostoyevsky Fyodor Lolita Nabokov Vladimir The Adventures of Huckleberry Finn Twain Mark Of Mice and Men Steinbeck John Wuthering Heights Brontë Emily Brave New World Huxley Aldous </code></pre> To merge the lists I used another AWK script, this time called from a bash script. This script also counted up the number of times the book shows up in a list and which lists it showed up in.</p> #!/bin/bash #usage: ./tabulateBooks.sh awk -f tabulateBooks.awk \ ../rawData/bookman_librarians.table \ ../rawData/bbc_the_big_read.table \ ../rawData/modern_library_readers.table \ ../rawData/modern_library_board.table \ ../rawData/npr_beach_books.table \ ../rawData/good_reads.table \ ../rawData/harvard_bookstore.table \ \| sort -t"," -k1.2,1gr -k2.2,2gr > tabulatedBooks.csv </code></pre> BEGIN{ FS="\t"; #Input delimiter OFS=","; #Output delimiter lineCount=100 #Number of items in the longest list } { #for every line in each file title=toupper($1) authorLast=$2 authorFirst=$3 rank=lineCount-(FNR-1) #bookArray[title]+=rank NumOfListsArray[title]+=1 FirstNameArray[title]=authorFirst LastNameArray[title]=authorLast #Pull out filename sans extension len = split(FILENAME,N1,"/") split(N1[len],N2,".") listName = N2[1] #Append which lists the book appears in and the rank it has in that list FileNameArray[title]=(FileNameArray[title] "\",\"" listName "\",\"" rank) totalRankArray[title]=(totalRankArray[title] + rank) } END{ #print "-------------------" for(title in FirstNameArray) { gsub(/^\",\"/,"",FileNameArray[title]) #Remove extra delimter # Number of lists book is in,total rank, book title, author first name, last name, lists in which book appears and rank in that list print "\""NumOfListsArray[title]"\"","\""totalRankArray[title]"\"","\""title"\"","\""FirstNameArray[title]"\"","\""LastNameArray[title]"\"","\""FileNameArray[title]"\"" } } </code></pre> Of course some duplicates slipped through since some lists had typos, title variations, etc… Here I gave in and used python to search through the merged list for likely duplicates by calculating the Jaccard Index</a> for every combination of books in the list. Once I found the duplicates I corrected the errant names in the relevant source files and recreated the merged list.</p> #!/usr/bin/python import sys ##################################### def jaccard_index(set_1,set_2): n = len(set_1.intersection(set_2)) return n / float(len(set_1) + len(set_2) - n) ##################################### fileName=str(sys.argv[1]) shingleLen=4 with open(fileName,'r') as f: data = f.readlines() lineNumA=0 for line in data: line=line.rstrip('\n') primaryShingle=[line[i:i + shingleLen] for i in range(len(line) - shingleLen + 1)] primarySet=set(primaryShingle) lineNumB=0 for ll in data: if lineNumA < lineNumB: ll=ll.rstrip('\n') secondaryShingle=[ll[k:k + shingleLen] for k in range(len(ll) - shingleLen + 1)] secondarySet=set(secondaryShingle) jac = jaccard_index(primarySet,secondarySet) if jac > .35: print "%.3f\n%s\n%s"%(jac,line,ll) print "-----------" #print lineNumB lineNumB += 1 #print lineNumA lineNumA += 1 </code></pre> This left me with a list of 443 unique books. The next step was to determine the year each book was published. Using curl I ran the title and author as search terms through Google and WolframAlpha and was able to pull out the publishing date for nearly every book. The last few I filled in by hand.</p> This script looks to see if the date is already known (since I ran this quite a few times) and if it isn’t, tries to determine the date using Google and then WolframAlpha.</p> #!/bin/bash #Usage: ./tabulateBooks.sh tabulatedBooks.csv : > tempdatesfile #Create empty file cat $1 \| while read line; do #for each line in the file do the following #The FPAT variable keeps commas inside quotes from being field seperators TA=$(echo "$line" \| awk -vFPAT='([^,])\|("[^"]+")' -vOFS=+ \ '{print $3,$5}') #Title and author's last name Stitle=$(echo "$TA" \| cut -d"+" -f1) #cut out just the title #Now remake $title and $TA with the '+' delimiter replacing spaces TA=$(echo $TA \| awk -F'[ ]' 'BEGIN{OFS="+";} {$1=$1;print;}') title=$(echo $Stitle \| awk -F'[ ]' 'BEGIN{OFS="+";} {$1=$1;print;}') sanitizedTitle=$( echo ${Stitle//\(/\\\(} ) #Replaces ( with \( sanitizedTitle=$( echo ${sanitizedTitle//\)/\\)} ) #Replaces ) with \) #Look for known dates in file (use perl regex because it works) year=$(cat tabulatedBooks_withDates.csv \| grep -iP \ "$sanitizedTitle\,\"([0-9]\|\-[0-9])" \ \| awk -vFPAT='([^,])\|("[^"]+")' '{gsub("\"","",$4); print $4}' ) #Check if year is in the range 1000 to 2999 CE if (echo $year \| grep -Eq '^[1-2][0-9][0-9][0-9]$') then printf 'Known year:%s\n' "$year" printf '\"%s\",%s\n' "$year" "$line" >> tempdatesfile continue fi #Check if year is in the range 0 to 999 CE if (echo $year \| grep -Eq '^[0-9][0-9][0-9]$') then printf 'Known year:%s\n' "$year" printf '\"%s\",%s\n' "$year" "$line" >> tempdatesfile continue fi #Check if year is between 0 and 999 BCE if (echo $year \| grep -Eq '^\-[0-9][0-9][0-9]$') then printf 'Known year:%s\n' "$year" printf '\"%s\",%s\n' "$year" "$line" >> tempdatesfile continue fi if !(echo $year \| grep -Eq '^[0-9][0-9][0-9][0-9]$') then echo "Searching for year" searchString=$(printf '%s%s' "$TA" "+published") year=$(curl --silent --user-agent "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.93 Safari/537.36" \ https://www.google.com/search?q=$searchString \| \ awk -f scrapeGoogle.awk) fi if !(echo $year \| grep -Eq '^[0-9][0-9][0-9][0-9]$') then echo "Scraping google failed, trying wolframalpha..." searchString=$(printf '%s%s' "\"$title\"" "+first+publication+date") year=$(curl --silent --user-agent "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.93 Safari/537.36" \ http://www.wolframalpha.com/input/?i=$searchString \| \ awk -f scrapeWolfram.awk) fi if !(echo $year \| grep -Eq '^[0-9][0-9][0-9][0-9]$') then #make sure $year is empty if it isn't a 4 digit number year="" echo "FAILED: $Stitle" fi printf '\"%s\",%s\n' "$year" "$line" >> tempdatesfile done : > tempdatesfile2 awk -vOFS="," -vFPAT='([^,]*)\|("[^"]+")' \ '{t=$1; $1=$2; $2=$3; $3=$4; $4=t; gsub(",,",","); \ print >> "tempdatesfile2"}' tempdatesfile rm tempdatesfile mv tabulatedBooks_withDates.csv tabulatedBooks_withDates.csv.backup mv tempdatesfile2 tabulatedBooks_withDates.csv </code></pre> These are the helper AWK scripts to interpret the downloaded HTML.</p> #For google results #!/usr/bin/awk BEGIN{ RS="<[^>]+>"; #Make each HTML tag a row divider OFS="+"; ORS=""; } /Originally published/{ if ($0=="Originally published") #Did it work? pubNR=NR #Remember row number else next #No luck, proceed to next book } NR==pubNR+3{ #Date will be 3 rows after the 'originally published' text dateArrayLength=split($0,dateArray," ") year=dateArray[dateArrayLength] #Pull out just the year print year } </code></pre> #For wolframalpha results #!/usr/bin/awk BEGIN{ FS="\""; OFS=""; } /stringified/{ c++; if(c==2){ dateArrayLength=split($4,date," ") year=date[dateArrayLength] print year } } </code></pre> At this point I have a delimited file containing the book title, author name, publishing date, number of lists the book appears in, and which lists those are and the rank in each list..</p> Graphs ’n Things</h4> Joule Thief 2016-07-25T00:00:00+00:00 The Joule Thief is a fantastic intro to analog electronic circuits. The idea of a self-oscillating voltage booster is very old, but the current internet popularity (and name) is due to Clive Mitchel</a>. I taught an intro to circuits workshop at my local makerspace using a slightly modified version of his circuit which used a capacitor to smooth the output voltage. The makes a great project for people to take home at the end of a workshop and covers soldering, resistors, diodes, LEDs, inductors, induced current, back emf, capacitors, and persistence of vision.</p> Below is my prototype for the class, the only differences are that I added a battery holder and used a slightly different switch.</p> </p> I wanted to be able to introduce all the basic circuit components and the standard circuit doesn’t have any capacitors. Adding in a small capacitor (and diode to force it to discharge through the LED) had the added benefit of keeping the LED on constantly instead of flashing at a few tens of kilohertz with an approximately 50% duty cycle. While the increase in brightness wasn’t huge, it was certainly noticeable.</p> Note: The two inductors in the schematic are a single double wound toroid. I suggest doubling up and pulling through two wires at once. Normal wire works fine, but magnet wire is nice since the insulation is so thin. The easiest mistake is to solder together the two wires at either the beginning or end of the coil. What should happen is that one wire from the beginning of the coil and the OTHER wire from the end of the coil should be connected together and then to the positive battery terminal. Those are the two I have going through the board in the center of the toroid and then connecting to the switch, which then connects to the positive terminal.</p> </p> I also wanted the circuit to build into a useful form factor. Both so that members could practice soldering and so they would have more than a breadboard circuit to take home at the end. I thought about getting a PCB made, but I wanted it to feel less like a kit and more like a DIY project.</p> I sketched up an outline in Inkscape and cut some thin plywood to the proper size. Before the class I drilled all the holes in the wood and printed out a few pages of the outline. In class, once each person had their circuit tested on a breadboard, they glued the outline to the wood and placed all the parts.</p> Download PDF to print outlines</a> Download SVG to edit outlines</a></p> </p> If wires are left long enough, most of the connections can be made without and extra jumper wire.</p> </p> The circuit will run for a few days off of a “dead” AA battery and a few weeks off a new one.</p> Using GPG 2015-05-05T00:00:00+00:00 There is a great deal of info out there about PGP and GPG but I could never find what I wanted summarized nicely in one place. This is my attempt to do that.</p> PROCESS OUTLINE</h4> Create PGP public/private key pair.</strong></li> Backup public key, private key, and emergency private key revocation certificate in a SECURE location.</strong></li> Upload public key to keyserver</strong> (e.g. pgp.mit.edu) (Keyservers share keys between each other so it is only necessary to upload to one server.)</li> Download the public keys you wish to sign.</strong> Signing is a confirmation that a public key (user ID/email) belongs to the person it claims to belong to and that you believe that the private key associated with that public key is safely kept by that person. THIS IS NOT SOMETHING TO BE DONE LIGHTLY. THIS IS HOW A WEB OF TRUST IS BUILT.</li> CONFIRM THE KEY FINGERPRINT IN A SECURE WAY</strong> (e.g. in person)</li> Sign the user IDs that you trust, you can sign any subset of a user’s IDs.</strong> (Many IDs (emails, images) can be associated with one public key.)</li> Upload the keys you’ve signed back to the keyserver.</strong> Optional: You can also ‘trust’ a key/ID. Signing a key is a assertion of the validity of the key, that is, the person with the associated private key is who they claim to be. Trusting a key is local only (trust values don’t get uploaded to a keyserver) and is an assertion of how much you believe you can trust other keys signed by that person. GPG will by default trust a key if it is signed by a key you ‘fully’ trust or by three keys you ‘partially’ trust. Only ‘ultimately’ trust yourself.</li> Test sending and receiving messages</strong></li> </ul> Note these commands work on Mac and Linux with both gpg and gpg2 (as far as I am aware).</p> CREATING A PGP KEY</h4> gpg2 --gen-key</code></p> Use 4096 RSA (1)</li> Expiration date (less than 2 years is recommended, this date can be extended later and acts as a dead man switch)</li> Enter (real) full name</li> Enter real email address (advisable to use dedicated)</li> Enter optional comment (shown along with key name to others)</li> Enter a passphrase (length at least 12, memorable)(Can be changed) A long passphrase of over 6 words from more than one language will be very resistant to brute force and dictionary attacks but can be made easy to type and remember.</li> </ul> </li> </ul> BACKUP YOUR PRIVATE AND PUBLIC KEY</h4> Export public key</p> gpg2 --export -a "User Name" > user.pub.key</code></p> Export private key</p> gpg2 --export-secret-key -a "User Name" > user.priv.key</code></p> Create emergency revocation certificate. This is the ONLY way to revoke your public key if you lose access to your private key.</p> gpg2 --output user.rev.asc --gen-revoke key_user_name</code></p> BACK THESE FILES UP IN A SECURE LOCATION (SUCH AS CD/PAPER IN A BANK VAULT, ENCRYPTED DRIVE, ETC…)</strong></p> MANAGE AND EDIT KEYS</h4> List available public keys</p> gpg2 --list-keys</code></p> List available private keys</p> gpg2 --list-secret-keys</code></p> Display fingerprint of all public keys (Can be combined with --list-secret-keys</code>)</p> gpg2 --fingerprint</code></p> Edit a key</p> gpg2 --edit-key key_user_name/email</code></p> Type “help” to see list of commands in edit mode</p> EXCHANGING, SIGNING AND TRUSTING KEYS</h4> Upload public key to keyserver</h6> This can NEVER be deleted, only revoked, so don’t clutter the server.</em></p> gpg2 --keyserver pgp.mit.edu --send-keys KEY_ID</code></p> Download public key from keyserver</h6> gpg2 --keyserver pgp.mit.edu --recv-keys KEY_ID</code></p> Sign/validate user ID (AKA public key signing)</h6> gpg2 --sign-key key_user_name/email</code></p> Will ask to confirm which user IDs to sign. You can sign specific or all user IDs.</p> Trusting keys</h6> gpg2 --edit-key key_user_name/email</code></p> gpg2> trust</code></p> Default is “I don’t know.” Level of trust is how much you trust both their understanding of PGP (so they won’t make a mistake) and how much you trust their commitment to properly validating keys. “Ultimate” is a special level reserved for your own key.</p> SENDING AND RECEIVING</h4> Decrypt file</h6> gpg2 -d <file_name></code> (Spits out text to the terminal.)</p> gpg2 -d <file_name> > file.txt</code> (Saves text to file.)</p> Encrypt file (minimal example)</h6> gpg2 --encrypt -r "recipient_name" <file_name></code></p> Encrypt, sign, specify output name</h6> Use -a to export an ASCII file (for copying into a text field and such)</p> gpg2 -es -o <output_filename> -r "Recipient" <file_name></code></p> Clearsign</h6> Encrypts with your private key so only your public key can be used to decrypt it (proves it comes from you and that the data hasn’t been tampered with).</p> gpg2 --clearsign <file_name></code></p> Use -u <user_name> to specify a non-default private key</p> Note that the keys/IDs of the sender and recipient can be seen by a third party even if they can’t decrypt the message. The flag below can hid the recipient. See the examples section for more discussion.</p> To hide the intended recipient from a third-party</h6> gpg2 --hidden-recipient -e -r "recipient_name" <file_name></code></p> EXAMPLE</h4> Recently I was playing on online game of Diplomacy (a strategy game like Risk) with friends and we decided to add a crypto element. Below I’ll go through how we communicated using pgp. Of course you don’t have to use gpg or the terminal to do this, but it does give you a better sense of what is going on behind the scenes. We started off by each creating a private/public key pair for the country we were playing as. We didn’t want to clutter key servers so all keys were shared via text on a simple message board my friend programmed on his server.</p> Sharing public key</h5> Export public key</p> gpg2 --export -a "User Name" > user.pub.key</code></p> Make a plain text file with your intro message and sign that file (only need -u option if you have a different default key)</p> gpg2 -u "yourCountry" --clearsign message.txt</code></p> This will output a file message.txt.asc</code> which will have the message in clear text and a crypto signature proving the key which was used to sign it</p> Copy the contents of the message.txt.asc</code> file into a message on the board, and then also copy the contents of the user.pub.key</code> and append to the same message.</p> Proving your identity</h5> The easiest way is to generate a key fingerprint and put that in a message on the vDiplomacy site so we know for sure which key belongs to which country.</p> gpg2 --fingerprint</code></p> Outputs something like this:</p> pub 1024R/DB9C59CF 2015-01-13 Key fingerprint = E03D 7518 B11E BE5C 82BE 2143 FB43 9F02 DB9C 59CF uid [ultimate] Austria sub 1024R/5CD5DF64 2015-01-13 </code></pre> Copy that key fingerprint into the vDip message board.</p> Checking someone’s identity</h5> First import their public key. Make a file named country_name.pub.key and copy the key into it (Including the “BEGIN” and “END” lines)</p> gpg2 --import country_name.pub.key</code></p> Now check the fingerprint</p> gpg2 --fingerprint</code></p> Lists all keys on your keyring, look for the one you just imported and check the fingerprint against that on the vDip message board.</p> Check the signature of the message</p> Copy from the “BEGIN SIGNED MESSAGE” line to the “END SIGNATURE” line into a plain text file: file_name.txt.asc</code></p> gpg2 -d file_name.txt.asc</code></p> You should see an output like this:</p> gpg: Signature made Tue 13 Jan 2015 12:45:02 PM CST using RSA key ID xxxxxxxx gpg: Good signature from "user_name" </code></pre> Communicating</h5> To send a signed, encrypted message to a single person, create a plain text file as before with the contents of your message save as something like otherCountry_msg1.txt</code></p> gpg2 -eas -u "yourCountry" -o otherCountry_msg1.asc -r "otherCountry" otherCountry_msg1.txt</code></p> Copy the contents of the newly created file otherCountry_msg1.asc</code> into a message on the board. You can make a note at the top who it is for, or just let everyone try to decrypt it.</p> To decrypt a message, copy the contents from the BEGIN to END lines into a text file named something like otherCountry_msg2.asc</code></p> gpg2 -d otherCountry_msg2.asc > otherCountry_msg2.txt</code></p> Note that if the command above is used, a third party can see who is talking, even if they can’t read the message. For example, a message between Russia and England when tried to be decrypted by Austria gave the following:</p> gpg2 -d temp.enc gpg: encrypted with 1024-bit RSA key, ID D6762868, created 2015-01-15 "Russia" gpg: encrypted with 4096-bit RSA key, ID 7D5EF8AB, created 2015-01-12 "England Anonymous" gpg: decryption failed: No secret key </code></pre> This can be partially remedied by the use of the --hidden-recipient</code> flag, but there doesn’t seem to be a way to hide the sender. Of course the third party would have to have the sender’s and recipient’s public keys for this to work. It also seems to depend some on the software being used, I haven’t quite figured out exactly how.</p>

Writing drivers for a Dot-Matrix LCD Display

2018-01-14T00:00:00+00:00

Read Part One</a> about reverse engineering the LCD.</li>
Read about the inverting voltage multiplier</a> I’m using to power the LCD.</li> </ul>
The previous post dealt with the LCD hardware and the specifics of the ICs. This post will focus on the driver code used to create the sequence of signals previously discussed. I’m using a TI dev board with the Cortex M4 core TM4C123GH6PM microcontroller.</p>
</p>
Architecture</h4>
Before diving into the details of getting pixels to actually show up in the proper locations on the screen, let’s walk though a high level overview of how the driver is going to be set up.</p>

There will be two chunks of memory allocated as frame buffers. The two buffers will switch between being written to and being read from. This will be accomplished by using two pointers, readBuffer</code> and writeBuffer</code>.</li>
Sprites will be stored in row-column order, each row right padded to the nearest byte. Each bit will represent a single pixel. Zero meaning deactive (clear), and One meaning active (dark).</li>
Sprites will be loaded into the frame buffer currently pointed to by writeBuffer</code>. Upon loading the last sprite, the higher level code will let the driver know that the frame is complete.</li>
A timer will trigger an interrupt and at each interrupt a single row of the readBuffer</code> will be loaded into the LCD controller ICs and latched out to display on the screen.</li>
After loading the last row in a frame, a check is performed to determine if the pointers to the read and write buffers should be switched.</li> </ul>System Overview</h4> The following digram shows a brief system overview limited to the portions of the system directly involved in using the LCD screen. In this post I’m going to focus on how data gets from memory (the buffer) to being displayed on the LCD. Future posts will delve into detail on how the sprites are stored and how the buffers get updated.</p> The modules involved are:</p> main.c</li> IO.c (IO.h)</li> screen.c (screen.h)</li> DisplayTests.c (DisplayTests.h)</li> </ul> The file main.c calls the appropriate initialization functions and then enters the infinite while loop. In the loop a check is performed to see if image data should be updated, that is, if a buffer is available to write to. If true, sprite states are updated and loaded into the current writeBuffer.</p> </p> Main</h5> The most relevant parts of main.c are shown below.</p> int main(void){ DisableInterrupts(); PLL_Init(); IO_Init(); EnableInterrupts(); //Down the rabbit hole we go while(1){ if(IO_Ready()) { DisplayTests_DrawDiag(); DisplayTests_DrawBorder(); IO_UpdatesCompleted(); } } } </code></pre> Input/Output (IO) module</h5> The IO module has public functions declared in IO.h. The relevant public functions are shown below. The first three are called by main.c. The last, LoadSprite(), is called by DisplayTests.c.</p> void IO_Init(void); bool IO_Ready(void); void IO_UpdatesCompleted(void); void IO_LoadSprite( const uint16_t xpos, const uint16_t ypos, const Sprite_t sprite ); </code></pre> Screen module</h5> The screen module has public functions which are only called by IO.c. No other module is aware of its existence. The header file, screen.h, contains the declarations of these public functions as well as the screen width and screen height in pixels.</p> #define SCREEN_W 480 #define SCREEN_H 64 void Screen_Init(void); void Screen_SetBufferIsFull(void); bool Screen_IsBufferAvailable(void); void Screen_ClearBuffer(void); uint8_t * Screen_GetBuffer(void); </code></pre> The Screen Driver</h4> Alright, now that the overview is out of the way, let’s get into the meat of turning a bunch of ones and zeros into pixels on a screen.</p> Initialization</h5> A few screen related constants, two arrays large enough to hold an entire screen of data, and two pointers to those arrays are initialized at the top of screen.c.</p> #define FRAME_REFRESH_HZ 11 #define LCD_REFRESH_HZ 44 #define BUFFER_SIZE (SCREEN_W*SCREEN_H/8) uint8_t ScreenBufferA[BUFFER_SIZE] = {0}; uint8_t ScreenBufferB[BUFFER_SIZE] = {0}; uint8_t *writeBuffer = NULL; uint8_t *readBuffer = NULL; </code></pre> There are five data signals which need to be handled.</p> Data Clock (CP)</li> Latch Clock (Load)</li> Frame Clock (Row Data, DIO1)</li> Column Data 1 (SDI)</li> Column Data 2 (SDI)</li> </ul> These will use pins 4-0 on port F. The TM4C line of uCs has a feature which allows bits [9-2] of the address used to access a GPIO register to act as a mask, thus enabling atomic read and write operations on any combination of pins. This is known as “bit banding” or “bit-specific addressing.” See the following sections of the datasheet</a> for more info:</p> 10.2.1.2 Data Register Operation (p. 654)</li> 2.4.5 Bit-Banding (p. 97)</li> </ul> and this webpage</a> (ctrl-f for ‘bit-specific addressing’).</p> The first three signals will use PF1, PF2 and PF3 (respectively).</p> #define DataClk_PF1 (*((volatile unsigned long *)0x40025008)) #define LatchClk_PF2 (*((volatile unsigned long *)0x40025010)) #define FrameClk_PF3 (*((volatile unsigned long *)0x40025020)) </code></pre> The two serial data signals will always be written together, so a single mask will suffice.</p> #define SerialData_PF04 (*((volatile unsigned long *)0x40025044)) </code></pre> As an example, the address for accessing PF0 and PF4 simultaneously is calculated via:</p> Address $ =\textrm{Base_Address} + ((2^4 + 2^0) \cdot 4) $</p> where the Base-Adress for the port F data register on the APB (Advanced Peripheral Bus) is 0x4002.5000. (Multiplying by 4 is equivilant to bit shifting left by 2.)</p> Now writing is as simple as:</p> DataClk_PF1 = (1<<1); //Make high DataClk_PF1 = 0; //Make low; SerialData_PF04 = (1<<4)|(1<<0); //Make both high SerialData_PF04 = 0; //Make both low SerialData_PF04 = (0<<4)|(1<<0); //Make PF4 low and PF0 high </code></pre> These are great because they can’t effect any other pins than those intended, are way faster than the standard read-modify-write sequence, and because the operations are atomic (can’t be interrupted.)</p> The Init function</h6> The Screen_Init() function has three jobs.</p> Setup the GPIO pins needed for the LCD</li> Setup the SysTick timer to trigger interrupts for sending data to the LCD</li> Initialize the writeBuffer and readBuffer pointers</li> </ul> void Screen_Init(void){ ////////////////////////////////////////////////// //Enable GPIOs for connecting to LCD // ////////////////////////////////////////////////// SYSCTL_RCGC2_R |= (1<<5); // activate port F clock while((SYSCTL_PRGPIO_R & (1<<5)) == 0){;} // Wait for clock to stabalize GPIO_PORTF_LOCK_R = 0x4C4F434B; // unlock PortF PF0 GPIO_PORTF_CR_R = 0x1F; // allow changes to PF4-0 GPIO_PORTF_DIR_R |= ((1<<4)|(1<<3)|(1<<2)|(1<<1)|(1<<0)); // make PF4-0 out (1) GPIO_PORTF_AFSEL_R &= ~((1<<4)|(1<<3)|(1<<2)|(1<<1)|(1<<0)); // disable alt funct GPIO_PORTF_DR8R_R |= ((1<<4)|(1<<3)|(1<<2)|(1<<1)|(1<<0)); // can drive up to 8mA out GPIO_PORTF_DEN_R |= ((1<<4)|(1<<3)|(1<<2)|(1<<1)|(1<<0)); // enable digital I/O GPIO_PORTF_AMSEL_R &= ~((1<<4)|(1<<3)|(1<<2)|(1<<1)|(1<<0)); // no analog GPIO_PORTF_DATA_R &= ~((1<<4)|(1<<3)|(1<<2)|(1<<1)|(1<<0)); //set to zero ////////////////////////////////////////////////// //Enable systick interrupts for writing to LCD // ////////////////////////////////////////////////// uint32_t sysTickReloadCount = (80000000/LCD_REFRESH_HZ/SCREEN_H); NVIC_ST_CTRL_R = 0; // disable SysTick during setup NVIC_ST_RELOAD_R = sysTickReloadCount-1; // reload value NVIC_ST_CURRENT_R = 0; // any write to current clears it NVIC_SYS_PRI3_R = (NVIC_SYS_PRI3_R&0x00FFFFFF)|0x20000000; // priority 1 NVIC_ST_CTRL_R = 0x07; // enable with core clock and interrupts writeBuffer = ScreenBufferA; readBuffer = ScreenBufferB; } </code></pre> Public Interface</h4> The following functions make up the public interface which is accessed by the IO.c module. The names should be fairly self explanatory.</p> uint8_t * Screen_GetBuffer(void) { return writeBuffer; } void Screen_SetBufferIsFull(void) { writeBufferIsFull = true; writeBufferAvailable = false; } bool Screen_IsBufferAvailable(void) { return writeBufferAvailable; } void Screen_ClearBuffer(void) { uint16_t i; for(i=0;i<BUFFER_SIZE;i++){ writeBuffer[i]=0x00; //zeros correspond to the default clear pixel state } } </code></pre> Interrupt Handling</h4> Each time the interrupt service routine is called, the row corresponding to the current value of rowIndex is loaded into the LCD. The value of rowIndex loops from zero up to SCREEN_H-1. A row stays active on the display until the next time the interrupt runs. The second part of the ISR only runs if the last row of a frame was just displayed, if the current frame has been displayed enough times, and if the new frame is ready. If all these conditions are met, then the read and write buffers are switched.</p> void SysTick_Handler(void){ static const uint8_t minLcdUpdatesPerFrame = LCD_REFRESH_HZ/FRAME_REFRESH_HZ; static uint8_t rowIndex = 0; static uint8_t lcdUpdates = 0; PrintNextRow(rowIndex); rowIndex = (rowIndex+1)%SCREEN_H; if(rowIndex==0 and ++lcdUpdates>=minLcdUpdatesPerFrame and writeBufferIsFull) { SwitchBuffer(); writeBufferAvailable = true; lcdUpdates = 0; writeBufferIsFull = false; } } </code></pre> static void SwitchBuffer(void) { if(writeBuffer == ScreenBufferA) { writeBuffer = ScreenBufferB; readBuffer = ScreenBufferA; } else { writeBuffer = ScreenBufferA; readBuffer = ScreenBufferB; } } </code></pre> Printing a row</h4> A few requirements</h6> The interrupt rate will be such that the entire LCD is refreshed at a rate of at least 40 Hz, that is (40Hz)*(number of rows). I found that below this rate there would visible flickering.</li> The data clock must not exceed 3.3 MHz (as per the LCD driver IC datasheets)</li> The width of a clock pulse must not be less than approx 80 ns (The datasheet says 100 ns, but in testing I found down to about 80 ns to be fine.)</li> </ul> Logical flow</h5> The flowchart below shows the function PrintNextRow() and the functions it calls. The LCD is split into a left and right half so the first bit of the left half and the first bit of the right half get sent on the same falling edge of the data clock, etc… The falling edge of the latch clock tells the LCD ICs to take their data buffers and output them to their physical pins as high or low voltages. This signal also tells the IC controlling the rows to shift to the next row. The frame clock shifts in a new high value to the row IC which then gets shifted through each row by the latch clock signal until shifting off the last pin on the IC. This way the rows can be activated one at a time.</p> </p> The following code is logically equivalent but has been modified from the simplest implementation to achieve the 3.3 MHz data rate.</p> The “for each bit in a byte” loop has been unrolled</li> The SendData() function has been integrated into the unrolled loop</li> </ul> These two changes drastically improved the data rate, actually getting over 5 Mhz. The delayns() is used to tune the data rate to close to 3.3 MHz as measured on a scope.</p> static void PrintNextRow(uint8_t rowIndex){ uint8_t bytesPerRow,colIndex; uint8_t bufferByteLeft, bufferByteRight,bitValLeft,bitValRight; bytesPerRow = SCREEN_W>>3;// divided by 8 (bytes) for(colIndex=0;colIndex<(bytesPerRow>>1);++colIndex){ bufferByteLeft = readBuffer[rowIndex*bytesPerRow+colIndex]; bufferByteRight = readBuffer[rowIndex*bytesPerRow+colIndex+(bytesPerRow>>1)]; DataClk_PF1 = (1<<1); bitValLeft = (bufferByteLeft&(1<<7))>>7; bitValRight = (bufferByteRight&(1<<7))>>7; SerialData_PF04 = ((bitValRight)<<0)|((bitValLeft)<<4); DataClk_PF1 = 0x00; //Clocks in data on falling clock edge delayns(); DataClk_PF1 = (1<<1); bitValLeft = (bufferByteLeft&(1<<6))>>6; bitValRight = (bufferByteRight&(1<<6))>>6; SerialData_PF04 = ((bitValRight)<<0)|((bitValLeft)<<4); DataClk_PF1 = 0x00; //Clocks in data on falling clock edge delayns(); DataClk_PF1 = (1<<1); bitValLeft = (bufferByteLeft&(1<<5))>>5; bitValRight = (bufferByteRight&(1<<5))>>5; SerialData_PF04 = ((bitValRight)<<0)|((bitValLeft)<<4); DataClk_PF1 = 0x00; //Clocks in data on falling clock edge delayns(); DataClk_PF1 = (1<<1); bitValLeft = (bufferByteLeft&(1<<4))>>4; bitValRight = (bufferByteRight&(1<<4))>>4; SerialData_PF04 = ((bitValRight)<<0)|((bitValLeft)<<4); DataClk_PF1 = 0x00; //Clocks in data on falling clock edge delayns(); DataClk_PF1 = (1<<1); bitValLeft = (bufferByteLeft&(1<<3))>>3; bitValRight = (bufferByteRight&(1<<3))>>3; SerialData_PF04 = ((bitValRight)<<0)|((bitValLeft)<<4); DataClk_PF1 = 0x00; //Clocks in data on falling clock edge delayns(); DataClk_PF1 = (1<<1); bitValLeft = (bufferByteLeft&(1<<2))>>2; bitValRight = (bufferByteRight&(1<<2))>>2; SerialData_PF04 = ((bitValRight)<<0)|((bitValLeft)<<4); DataClk_PF1 = 0x00; //Clocks in data on falling clock edge delayns(); DataClk_PF1 = (1<<1); bitValLeft = (bufferByteLeft&(1<<1))>>1; bitValRight = (bufferByteRight&(1<<1))>>1; SerialData_PF04 = ((bitValRight)<<0)|((bitValLeft)<<4); DataClk_PF1 = 0x00; //Clocks in data on falling clock edge delayns(); DataClk_PF1 = (1<<1); bitValLeft = (bufferByteLeft&(1<<0))>>0; bitValRight = (bufferByteRight&(1<<0))>>0; SerialData_PF04 = ((bitValRight)<<0)|((bitValLeft)<<4); DataClk_PF1 = 0x00; //Clocks in data on falling clock edge } if(rowIndex==0) FrameClock(); else LatchClock(); } </code></pre> //Latch Clock: LatchClk_PF2 static void LatchClock(void){ unsigned long i=17; //specific number doesn't matter LatchClk_PF2 = (1<<2); i=i/i; //Delay enough to keep peak at least ~80ns wide LatchClk_PF2 = 0x00; } //DIO1: FrameClk_PF3 static void FrameClock(void){ FrameClk_PF3 = (1<<3); LatchClock(); FrameClk_PF3 = 0x00; } static void delayns(void){ unsigned int i; i=i/i/i; } </code></pre> Ideas for the Future</h4> The code I have now is working quite well, but I think I could utilize a dual SPI setup to do the actual sending of each row. I believe there are some microcontrollers which can send multiple streams of data on a single SPI peripheral, but I don’t believe the one I’m using can. But I might be able to use two SPI peripherals and have them share a single clock.</p> If I get SPI working I’d also like to utilize DMA for transferring data to the SPI peripheral.</p>

Reverse Engineering an LCD dot-matrix display

2018-01-12T00:00:00+00:00

A few months ago I popped into Goodwill to see if they had any interesting electronics to take apart. I was rewarded with a fully functioning 1993 Smith Corona electric word processor for all of $5. After playing around with it for a few days and learning how it worked, I took it apart and turned it into a box of interesting electrical and mechanical doodads.</p>

One of the components was a 480x64 pixel dot-matrix style LCD display (LMG6721UHGR) which I decided to use for a project. I already had a few of the 16x2 character LCDs and a Nokia cell phone screen breakout board I could have used, but those are pretty small and I was intrigued by the idea of reusing this old display.</p>

</p>

The Hardware</h4>
The circuit board the screen is attached to has a ten pin row of standard 0.1“ headers which provided the connections back to the main control board when it was in the typewriter. The circuit board has seven large ICs and two smaller ICs. After googling for the datasheets it turns out that one of the smaller ICs is a quad opamp (LA6324N) which provides the required voltages for driving the LCD cells (more on that later). The other small IC (53003HEB-S) is some sort of counter (I haven’t been able to find a datasheet for it). Six of the large ICs (three LC7940 and three LC7941) control the 480 columns (80 columns for each chip). The seventh (LC7942) controls the 64 rows.</p>
Datasheets</p>

LC7940/LC7941 Segment Driver</a></li>
LC7942 Common Driver</a></li>
LA6324 Quad OpAmp</a></li> </ul>
</p>
</p>
My next task was to determine which signals are broken out to the header pins and how the LC794x ICs work. After a few hours of referring to data sheets, learning how LCDs work, and many continuity measurements I determined the pinout for the headers and what pins on the driver ICs are connected to what.</p>
</p>
The headers are shown as viewed in the picture of the back of the screen (above). The labels are referring to the pins on the driver ICs.</p>
Each column of pixels is controlled by the six 7940 and 7941 ICs, the pinout for which is shown below.</p>
</p>
The 7940 and 7941 are the same IC, just with their pins flipped to help with dense circuit designs. The figure above matches the lower three ICs in orientation, but since the pins are flipped on the upper three ICs the order of the pins ends up being the same. The numbers refer to the pin number in the headers pins. (I’ve noted where physical pins exist but aren’t shown in the pinout diagram because they don’t connect to anything internally.)</p>
The P/S pin is pulled low which sets the IC to serial data input mode. The pins which would be used for parallel input (DI1,2,3) are also pulled low. The screen is split into a left half and a right half. The three ICs controlling the left half get data from header pin 1 and the three ICs controlling the right half get data from header pin 2. Strangely the DISPOFF pin doesn’t seemed to be pulled up or down.</p>
CDI on the first IC of each set of three is pulled low. The CDO pin of the first IC is connected to the CDI pin of the second, and the CDO of the second connected to the CDI of the third. The CDO of the third IC in each set isn’t connected to anything.</p>
The rows are controlled from the LC7940 driver IC which is shown below rotated by 180 degrees to match the orientation in the picture of the back of the screen (above). See the datasheet</a> for the regular orientation.</p>
</p>
The RS/LS pin is pulled to logic low which sets the shift direction to “right shift”, meaning DIO1 is the input, DIO64 is the output, and the data shifts from O1 to O64. This chip behaves exactly like a shift register, so data shifted into DIOI on the falling edge of the first clock pulse is shifted out of DIO64 at the 64th falling edge. This allows chaining to control displays with more than 64 columns. In this display O1 is connected to the top row and O64 is connected to the bottom row.</p>
Driving an LCD</h5>
The driver ICs utilize seven different voltage levels. Three are from header pins 7, 8 and, via the transistor, pin 9. The remaining 4 are created by the quad opamp IC.</p>
In order from highest to lowest:</p>
VDD = V1 (logic high), V2, V3, V4, V5, VEE (LCD Gnd)</p>
Shown below are how V2 through V5 relate to VDD and VEE along with example numbers assuming VDD=3.3V and VEE=-10V.</p>
Let |dV| = |VDD - VEE|.</p>

V2 = |dV|(6/7) - |VEE| = 1.4V</li>
V3 = |dV|(5/7) - |VEE| = -0.52V</li>
V4 = |dV|(2/7) - |VEE| = -6.3V</li>
V5 = |dV|(1/7) - |VEE| = -8.2V</li> </ul>
Logic low (Vss) will be close to V3, but could be above or below it depending on the what the pot is set to (since the pot controls VEE).</p>
The image below shows how the voltage generation circuitry using 3.3 volts as logic high and with -15 volts connected to pin 9. The voltages are all measured relative to logic low. The potentiometer adjusts the voltage difference between the collector and the emitter which changes VEE. The end effect of this is to change the screen contrast.</p>
</p>
To understand why all the voltages are required (and what the yet to be mentioned “M signal” does), we have to delve into the workings of Liquid Crystal Display technology.</p>
A common LCD panel configuration consists of two polarizers at right angles to each other sandwiching the cell structure containing the “liquid crystal” as well as sheets of transparent electrodes on each side of the liquid crystal sheet. Light passing through one polarizer is then rotated 90 degrees by the liquid crystal such that it lines up with the second polarizer. Thus the default state is a “clear” pixel. When a voltage is applied to the electrodes, the crystal structure is untwisted meaning the polarization angle of the light is no longer being rotated and so will be perpendicular to the second polarizer causing the light to be blocked and the pixel to turn black.</p>
Unfortunately, things get a bit more complicated. If you apply a DC voltage to a cell it will work but not for long. The crystal structure will degrade and the electrodes will cease to be transparent. The solution is to apply an AC voltage centered on zero. The voltage across the cell can’t simply go from say 10 volts to 0 and back to 10, it must flip polarity each cycle. So if one moment electrode A is 10 volts higher than electrode B, the next moment electrode A must be 10 volts lower than electrode B. Not only does this switching need to occur when the cell is activated, but also when in it’s inactive state.</p>
See these wikipedia pages for more info: Effect of Chirality</a> and Twisted nematic field effect</a></p>
The total voltage difference across a cell is determined by the difference between the voltages output by the column drivers and the row driver. For the column drivers, selected (dark pixel) voltages are V1(VDD) and VEE and not-selected (clear pixel) voltages are V3 and V4. For the row driver the selected voltages are the same, but the not-selected voltages and V2 and V5.</p>
Which voltage is output at any given moment is a function of the M level and the Q level (corresponding to the electrode being ON or OFF).</p>
Q State</th> M</th> Row</th> Col</th> Row-Col</th></tr></thead>

ON</td> Low</td> VDD</td> VEE</td> +13.3</td></tr>
ON</td> High</td> VEE</td> VDD</td> -13.3</td></tr>
OFF</td> Low</td> V2</td> V3</td> +1.9</td></tr>
OFF</td> High</td> V5</td> V4</td> -1.9</td></tr> </tbody></table>
For a pixel to be OFF (clear) the voltage difference between the electrodes is 1.9 volts and for a pixel to be ON (dark) the voltage difference is 13.3 volts. The scope output below shows the voltages on the electrodes for row 1 and column 1, as well as the latch/load clock and the M signal for one complete frame. The M signal alternates every 5 falling edges of the load/latch clock (look for the very thin yellow peaks) and the electrode voltages swap each time the M signal changes. This output shows the somewhat unrealistic, but helpfully illustrative, case where every row and every column are ON at all times. Normally only one output of the row driver IC would be activated at any given moment.</p>
The MATH output shows the column voltage minus the row voltage. This alternation results in a AC signal with a peak-to-peak amplitude of 2|VDD-VEE|.</p>
</p>
The following scope output shows exactly the same signals, just zoomed in on the time axis.</p>
</p>
The next output still shows the same signals, but with the more realistic scenario where the rows are being activated one at a time while every pixel in every column is ON (dark). Each row is being turned dark one at a time as the row IC driver shifts through it’s 64 outputs before starting again.</p>
Looking at the results of the difference between the row and column voltages, it is clear that the difference in voltage is large enough to darken the pixels in row 1 only for the time between the first and second latch clock pulses. Since the M signal changes every 5 latch clocks and that doesn’t divide evenly into 64, the voltage applied to the cells in this row will keep flipping as the row driver IC loops back around.</p>
</p>
Loading Data</h5>
In brief:</p>

The output buffer of each column driver is serially filled with 80 bits of data</li>
Each bit gets read in on the falling edge of the data clock</li>
Once the buffer is full the first time, the latch clock latches the buffer out to the drive circuitry</li>
At effectively the same moment the frame clock shifts a 1 into the first bit of the row driver</li>
The column buffers get refilled (240 data clocks), the active output of the row driver shifts to the next row and the column data is latched to the pins.</li>
This continues over and over with a 1 getting shifted into the row driver every 64 latch clocks</li> </ul>
Filling the Column Buffers</h6>
The screen is split into two sections, each 240 pixels wide. The two halves are loaded in parallel and all the logic is the same for each half. Until I get into the software we can ignore the right half of the screen and pretend there are only three column driver ICs.</p>
All three ICs have their serial inputs connected together and brought out to header pin 1. This means each IC sees all 240 bits of data but only accepts 80. This is accomplished though the CDI and CDO pins. When CDI (Chip Disable) is low the chip is enabled and will read in data from the serial input. When the CDI pin is high it won’t. The following steps go through the process of filling all three buffers.</p>

Start with all buffers empty (due to the latch clock)</li>
CDI1 is held low, CDO1/CDI2 and CDO2/CDI3 begin high</li>
After the first 80 bits have been read into IC1, CDO1 (and thus CDI2) goes low</li>
IC1 is full and so will ignore the remaining 160 bits</li>
The middle set of 80 bits are read into IC2, CDO2/CDI3 goes low</li>
IC1 and IC2 are both full and thus ignore the remaining 80 bits</li>
The last 80 bits are read into IC3</li> </ol>
The scope output below illustrates these steps. CDI1 is not shown since that pin is always held low. CDO1/CDI2 is high for the first third of the data and CDO2/CDI3 is high for the first two thirds.</p>
</p>
Multiplexing</h6>
There are three “clock” signals which control the ability to multiplex the data, thus controlling many pixels with only a few pins.</p>

The Data Clock (CP) controls the loading of data into the buffers in the column driver ICs, the state of the SDI pin is read in on each falling edge of the data clock.</li>
The Latch Clock (load) has several roles

It controls when the column buffers are latched to the output pins</li>
It provides the clock signal to the counter IC which produces the alternating M signal every 5 latch clocks</li>
It provides the clock signal to the column driver, shifting the active row each time.</li> </ul> </li>
The Frame Clock (DIO1) is really the input data signal for the row driver IC, the state of which is clocked in by the latch clock. However, it’s useful to think of it as the “clock signal” which begins a single frame.</li> </ul>
The following scope output shows the relationship between the data clock, latch clock and frame clock. There are 30 groups of 8 data clock pulses between each latch clock due to the data being read in one bit at a time from 8 bit chunks.</p>
</p>
Real Example</h5>
The scope output below shows the beginning of a row where the data 01110 is being loaded, corresponding to three dark pixels with a clear pixel on either side.</p>
</p>
Read Part Two</a>!</p>

Electronic Load

2017-05-19T00:00:00+00:00

The simplest load is a plain old resistor, and for many testing applications that will be perfectly adequate. However, when testing power supplies and batteries one often needs to set the exact current draw and have it remain constant across a range of voltages. This video</a> by Dave Jones showcases a simple design which uses an opamp in a negative feedback configuration controlling the base of a MOSFET to maintain the voltage across a sense resistor.</p>
The Math</h4>
Mostly I want a load that can handle 1 or 2 amps for long periods, but I’d like it to be able to go up to 5 amps for shorter periods. A 1 ohm sense resistor must then be rated for at least 25 Watts ($ P=I^2R $). I’d also like to be able to handle up to 30 volts at 5 amps which means the MOSFET must be able to dissipate $(5A)(30V)-25W = 125W$. The figure below shows the power dissipated assuming an ideal sense resistor and MOSFET as a function of current for various supply voltages. Fortunately I had on hand a few high power MOSFETs from an old receiver which meet the criteria quite nicely.</p>
</p>
The IRFP450A MOSFET has a max drain-source voltage of 500 volts, a max power dissipation of 190 Watts, can handle up to 8.7 Amps at a case temperture of 100 degrees Celsius, and has a nice low drain-source on resistance of 0.4 Ohms. From figure 1 in the datasheet we can see that to obtain 5 Amps the minimum required gate-source voltage is 6 volts (and drain-source is 1.5 volts). Since at 5 amps the voltage drop across the sense resistor will be 5 volts, the opamp has to be able to output at least 11 volts and supply under test must be above 6.5 volts. Testing the opamp I’m using revealed that it can output up to Vcc-1.5V. Thus a Vcc of 12.5 volts is required.</p>
The Parts</h4>

LM358P Dual Opamp</li>
Potentiometer</li>
IRFP450A Power MOSFET (Datasheet</a>)</li>
1 Ohm 25 Watt Power Resistor</li>
Large heatsink with fan</li>
Thermal Paste</li>
2 standard resistors for voltage divider</li>
Screw terminal</li>
9 volt battery and holder</li>
Boost Converter</li>
Banana jacks</li>
Toggle switch</li>
Panel Voltmeter</li>
Copper clad board</li>
Feric Chloride</li>
Label backing paper</li>
Laser Printer</li> </ul>
The Circuit</h4>
The circuit shown below is designed to connect directly to a 9V battery, but after I built it I added in a voltage boost converter in series with the battery to let me jump the voltage up to 12.5V. The voltage divider formed by R1 and R2 drop 9V down to 5V and the sense resistor of 1 Ohm gives a direct conversion to current. These can be changed such that the max output voltage from the first opamp is dropped down to a voltage equal in number to the max current you want the load to ever “ask for.”</p>
A convenient result of using a 1 Ohm sense resistor is that I can use a simple panel voltmeter to measure the current to an accuracy decent enough for most of my applications. (Avoid the 2 wire meters which measure and power themselves from the same rail.) You might notice there are no dedicated connections for the meter on the circuit. I realized this too late in the process and so I just tacked the wires down at the appropriate points on the board.</p>
</p>
PCB Design</h5>
The image below shows a PCB design for this circuit created in KiCad. The main current loop is shown by the yellow highlighter. Parts can be directly soldered to the board but items such as the sense resistor, MOSFET, pot, and the terminals for connecting power supplies under test I connected via jumper wires so they could be mounted elsewhere. The low power traces and other tolerances are wider than one would usually make them since I wanted to experiment with etching my own board.</p>
The two thick traces on the right side should be covered in solder to increase their current carrying capacity.</strong></p>
</p>
PCB Etching</h5>
After a variety of failures and running to the store for tiny carbide drill bits I managed to create a workable board with only one bodge wire (this has been corrected in the schematic above).</p>
My etching process</p>

Export just the copper layer from KiCad (not mirrored)</li>
Cut copper clad board to match size</li>
Peel labels off of backing material and cut out a piece of backing material large enough to print the circuit on</li>
Rub the shiny side down with Acetone</li>
Tape to a sheet of printer paper using masking tape (print to paper first to be sure the location is correct)</li>
Print with laser printer</li>
Place toner side down onto copper clad board, cover with tin foil, and press down with a clothes iron for several minutes</li>
Carefully remove paper (may help to soak in a bowl of water)</li>
Place copper clad board in a Ferric Chloride bath and agitate until all visible copper is removed</li>
Remove toner with acetone</li>
Drill holes (the huge pain-in-the-ass part no one ever mentions)</li>
Place components on copper free side so that the legs stick through to the copper side where soldering will happen</li> </ul>
</p>
The Enclosure</h4>
I used a steel box I had from taking apart some old broken equipment which I decided to use for the project box. The idea is that the whole container will form part of the heatsink. To avoid drilling into steel as much as possible, I designed an adapter plate to be 3D printed which would house the controls and fit into the odd oval-ish hole in the box.</p>
</p>
Putting it together</h4>
I drilled holes in the housing and used M2 and M3 bolts to firmly attach the adapter plate, sense resistor, MOSFET and heatsink. Before mounting, thermal paste was applied as needed, and the MOSFET was electrically isolated using a mica sheet. I glued a section of foam to the case for the circuit board to sit on top of to prevent shorting the copper traces on the metal of the chassis.</p>
</p>
After some testing, I found that the max continuous dissipation in this configuration was about 30 watts and added that warning to the case.</p>
</p>
Testing</h4>
The first plot shows what what the maximum current draw is as a function of the device under test voltage. In theory this would be that voltage divided by 1.4 Ohms (Sense resistor + MOSFET on resistance).</p>
</p>
The second plot shows the maximum total power dissipated by the load at the same voltages.</p>
</p>
Future Modifications</h4>
I went the battery route for extra portability, but it goes through batteries pretty fast when the fan is running so for long tests I’m going to add in a power jack.</p>
I’m going to work on changing the heat dissipation setup so I can get at least 50 watts.</p>

PHYS3098: Circuits

2017-04-04T00:00:00+00:00

I taught the circuits lab for physics majors three times, the first time as a grad student and the second and third times as an instructor. I really enjoyed teaching this lab, partly because I learned so much myself.</p>
The second year, I did a complete rewrite of all the labs. Below are links to the full labs and summaries of what was covered in each lab.</p>

Lab 1 - Instrumentation and Measurements (pdf)</a></h4>
</p>
Using a multimeter without letting the magic smoke out of the fuse, operating a variable DC power supply and a function generator, building circuits on breadboards, voltage divider circuits, and proper oscilloscope usage. Ends with a discussion of uncertainty and propagation thereof.</p> </div>

Lab 2 - Input and Output Impedance (pdf)</a></h4>
</p>
Measure the input impedance of a voltmeter and an oscilloscope, and observe the effects of measurement equipment loading a circuit. Analyze resistive and capacitive voltage dividers. Measure the output impedance of a function generator.</p> </div>

Lab 3 - RC Circuits (pdf)</a></h4>
</p>
Measure the time constant of charging and discharging RC circuits. Derive RC circuit voltages using complex analysis and use this to build integrator and differentiator circuits with outputs accurate to within 1%. I created a YouTube video</a> showing an example derivation.</p> </div>

Lab 4 - Thevenin Equivalence and Filters (pdf)</a></h4>
</p>
Analyze a resistor circuit using Thevenin’s Theorem, construct low and high pass RC filters, create Bode plots from amplitude data, build LC bandpass and notch filters and use an oscilloscope as a simple spectrum analyzer.</p> </div>

Lab 5 - Wave Behavior and Filter Design (pdf)</a></h4>
</p>
Use a bandpass filter to pull out the Fourier components of a square wave. Design and construct a two stage RC and a third order Butterworth low pass filter.</p> </div>

Lab 6 - Filters, Diodes, and Power Supplies (pdf)</a></h4>
</p>
Combine three sine waves of different frequencies and design three filters to pull each one back out. Compare small signal, Schottky and Zener in a half wave rectifier. Build a variable regulated DC power supply.</p> </div>

Lab 7 - LTSpice Simulations and IV Curves (pdf)</a></h4>
</p>
Use LTSpice to simulate a voltage divider, a high pass filter in the time domain, create a Bode plot, and the IV curve for a diode. Measure the real life current and voltage values for a diode and create an IV plot.</p> </div>

Lab 8 - Transistors I (pdf)</a></h4>
</p>
Measure collector and base current and base-emitter voltage for NPN and PNP transistors. Create plots of collector current as a function of base-emitter voltage, and collector current as a function of base current. Design and construct a “night light” circuit which turns on an LED when the ambient lights gets dim.</p> </div>

Lab 9 - Transistors II (pdf)</a></h4>
</p>
Construct an unbiased emitter follower. Design and construct a biased emitter follower. Construct an LC oscillator and connect to the biased emitter follow to demonstrate its use as a buffer amplifier and impedance transformer. Use the oscilloscope to build a curve tracer and examine the curves for diodes, resistors, capacitors, inductors and transistors.</p> </div>

Lab 10 - Operational Amplifiers (pdf)</a></h4>
</p>
Construct an inverting amplifier and a summing amplifier. Build a closed loop PID constant illumination controller using eight opamps and a phototransistor.</p> </div>

Lab 11 - Digital Logic and Audio Synths (pdf)</a></h4>
</p>
Construct NAND, NOT, AND, OR and NOR gates using NAND logic with LEDs showing the state of each gate. Using 555 timer ICs construct astable and monostable multivibrators. Link these together to form a simple audio synthesizer, often called the Atari Punk Console.</p> </div>

Lab 12 - Microcontrollers I (pdf)</a></h4>
</p>
Set up the Arduino IDE and upload code to a SparkFun Redboard. Use the microcontroller to control an RGB LED. Read in values from a flex sensor and set the position of a servo accordingly. Control a relay via a transistor and use a scope to show why a flyback diode is needed. Display text on an LCD.</p> </div>

Lab 13 - Microcontrollers II (pdf)</a> (code)</a></h4>
</p>
Decode the signal from an IR remote. Build a 5-bit R-2R digital to analog converter (DAC). Hook up the DAC to a common collector amplifier and a speaker. Synthesize sine waves corresponding to musical notes using direct digital synthesis (DDS). Use the remote control to select various frequencies, creating a remote controlled piano.</p> </div>

Teaching an old scope new tricks.

2016-11-19T00:00:00+00:00

I have an old analog Tektronix oscilloscope I use for my home projects which has served me quite well over the last couple years. One gripe I do have is that when I switch my probe to x10 attenuation mode, the backlight on the voltage dial shows the wrong number. If I was using the proper Tek probes there would be a little pin which would connect to the metal ring around the BNC connector on the scope. This would tell the scope when I switched in to x10 mode and switch the backlight position on the voltage dial. This would be especially useful for when I take pictures of the scope display for future reference and I need the numbers in the picture to be correct, not off by a factor of 10.</p>
As a poor grad student, I’m not going to go spend money on new probes just for this minor feature. Instead I decided to install a switch for each channel which would allow me to manually change the voltage backlight as needed.</p>
</p>
Of course the first thing to do is dive into the data sheet and figure out how the lights are connected. Fortunately the data sheets are all available online. Since this scope is modular, there is a data sheet for each of the three modules and a overall data sheet for the scope body. I have two different amplifier modules, but the lights work the same in each. Here is the data sheet for the simpler one, the 5A15N.</a></p>
I found a promising looking section of the schematic (shown below, red additions mine) which noted “with probe”. When I looked up DS191 and DS192 I found that they are indeed neon indicator lamps.</p>
</p>
</p>
The base of transistor Q191 is normally pulled high by R190. This both connects the x1 light to GND (completing its circuit) and keeps the base of the transistor Q192 low and thus the x10 light off. So I just need to make a switch to pull the base of Q191 low which will result in the base of Q192 being pulled high (by the 1 MOhm resistor) thus completing the circuit for the x10 light. From some other reading I did it seems like the Tek probes connected the base of Q182 to ground through a ~10k resistor, it would probably be fine either way, but I’ll go ahead and use the resistor. With the 150k and the 10k resistors forming a voltage divider when the switch is closed, the base of the transistor would be at (510)/(150+10) = 0.3 volts which is easily low enough to turn off Q191.</p>
The modifications are shown on the schematic in red.</p>
Once I settled on using a latching pushbutton style switch scavenged from an old receiver, I set about performing the requisite physical modifications. Namely, mounting the switch and drilling a hole in the front of the case. As is shown in the left image below, I went for the very high tech piece-of-wood-glued-in-place option.</p>
</p>
In the wiring shown below, the black wire connects to ground and the resistor lead (covered in red heat shrink tubing) connects to the wire going out to the x10 sense ring. When the switch is clicked out the two legs are internally disconnected and when it is clicked in the legs are internally connected.</p>
</p>
And now I have a nice easy way to switch the scope between x1 and x10 mode.</p>
</p>
Since I have a 3D printer I can’t help but model up some switch covers in Fusion 360 and give the whole project just a little extra finesse.</p>
</p>
I’m quite pleased with the final result and it will make using the scope rather more convenient.</p>

Voltaic Pile

2016-10-15T00:00:00+00:00

I found the available information to be sadly lacking in data and graphs and so proceeded to do my part to rectify the situation. The details are in the Instructable I wrote</a>, but here is a brief summary.</p>
For a voltaic battery constructed out of copper and zinc cells the voltage per cell is between 0.9 and 1.0 volts. The internal resistance (with a salt and vinegar electrolyte solution) is about 640 Ohms per cell.</p>
</p>
The graph shows how I determined the internal resistance for various situations. Knowing the voltage and the internal resistance, I calculated that it would take 710 batteries each containing 10 cells, where each cell consists of two pennies, to build a battery capable of putting out 5 volts at 0.5 amps, that is, a mediocre phone charger.</p>
That comes out to $142 worth of pennies.</strong></p>

Lists of Top 100 Books

2016-09-24T00:00:00+00:00

I love reading and I’ve often thought of working my way through reading every book on a “top books” list. But which list to choose? What books show up consistently? What authors are always represented but with different works? How representative are book lists with regards to historical works?</p>
I was thinking about these questions at the same time as I was interested in learning more about bash programming and AWK. This project is the result.</p>
Which Book Lists to Choose?</h4>
I decided to stick to top 100 lists and to avoid specific lists like “Top 100 scifi novels.” Some of the following are chosen by voting readers and some by literary experts.</p>

BBC’s Big Read Top 100</a></li>
The 100 Favorite Novels of Librarians</a></li>
Goodreads Top 100 Literary Novels of All Time</a></li>
Harvard Book Store Top 100 Books</a></li>
Modern Library 100 Best Novels (Board’s list and Reader’s list)</a></li>
NPR 100 Best Beach Books</a></li> </ul>
Data Wrangling</h4>
I downloaded the raw HTML for each page and wrote AWK scripts to pull out the title and author.</p>
An example of the HTML, in this case from GoodReads.</p>
<tr itemscope itemtype="http://schema.org/Book"> <td valign="top" class="number">1</td> <td width="5%" valign="top"> <a name="1885"></a> <a href="/book/show/1885.Pride_and_Prejudice" title="Pride and Prejudice"> <img alt="Pride and Prejudice" class="bookSmallImg" src="http://d202m5krfqbpi5.cloudfront.net/books/1320399351s/1885.jpg" /> </a> </td> <td width="100%" valign="top"> <a href="/book/show/1885.Pride_and_Prejudice" class="bookTitle" itemprop="url"> <span itemprop='name'>Pride and Prejudice</span> </a> <br/> <span class='by smallText'>by</span> <span itemprop='author' itemscope='' itemtype='http://schema.org/Person'> <a href="http://www.goodreads.com/author/show/1265.Jane_Austen" class="authorName" itemprop="url"><span itemprop="name">Jane Austen</span></a> </span> </code></pre> The following AWK script was used to pull out the title and author and write that information to a tab delimited file.</p>#!/usr/bin/awk #awk -f extract<name>.awk -f functionLibrary.awk <name>.html #Source: http://www.goodreads.com/list/show/13086.Goodreads_Top_100_Literary_Novels BEGIN{ FS="<[^>]+>"; OFS="\t"; lineCount=100; rankIterator=0; } FNR==1{ split(FILENAME,fileNameArray,"."); outputFile = fileNameArray[1]".table"; } /itemprop='name'/{ title=$2 #print FNR,title } /class="authorName"/{ author=$3 #print FNR,author currentLine=FNR } FNR==currentLine{ numNames=split(author,authorNameArray," "); firstNames=join(authorNameArray,1,numNames-1); #rank=weightBook(lineCount,rankIterator++); print title,authorNameArray[numNames],firstNames > outputFile; } </code></pre> The result was a file for each list with the book title and the authors name on each line (family name followed by given name).</p> Pride and Prejudice Austen Jane 1984 Orwell George The Great Gatsby Fitzgerald F. Scott Jane Eyre Brontë Charlotte Crime and Punishment Dostoyevsky Fyodor Lolita Nabokov Vladimir The Adventures of Huckleberry Finn Twain Mark Of Mice and Men Steinbeck John Wuthering Heights Brontë Emily Brave New World Huxley Aldous </code></pre> To merge the lists I used another AWK script, this time called from a bash script. This script also counted up the number of times the book shows up in a list and which lists it showed up in.</p> #!/bin/bash #usage: ./tabulateBooks.sh awk -f tabulateBooks.awk \ ../rawData/bookman_librarians.table \ ../rawData/bbc_the_big_read.table \ ../rawData/modern_library_readers.table \ ../rawData/modern_library_board.table \ ../rawData/npr_beach_books.table \ ../rawData/good_reads.table \ ../rawData/harvard_bookstore.table \ | sort -t"," -k1.2,1gr -k2.2,2gr > tabulatedBooks.csv </code></pre> BEGIN{ FS="\t"; #Input delimiter OFS=","; #Output delimiter lineCount=100 #Number of items in the longest list } { #for every line in each file title=toupper($1) authorLast=$2 authorFirst=$3 rank=lineCount-(FNR-1) #bookArray[title]+=rank NumOfListsArray[title]+=1 FirstNameArray[title]=authorFirst LastNameArray[title]=authorLast #Pull out filename sans extension len = split(FILENAME,N1,"/") split(N1[len],N2,".") listName = N2[1] #Append which lists the book appears in and the rank it has in that list FileNameArray[title]=(FileNameArray[title] "\",\"" listName "\",\"" rank) totalRankArray[title]=(totalRankArray[title] + rank) } END{ #print "-------------------" for(title in FirstNameArray) { gsub(/^\",\"/,"",FileNameArray[title]) #Remove extra delimter # Number of lists book is in,total rank, book title, author first name, last name, lists in which book appears and rank in that list print "\""NumOfListsArray[title]"\"","\""totalRankArray[title]"\"","\""title"\"","\""FirstNameArray[title]"\"","\""LastNameArray[title]"\"","\""FileNameArray[title]"\"" } } </code></pre> Of course some duplicates slipped through since some lists had typos, title variations, etc… Here I gave in and used python to search through the merged list for likely duplicates by calculating the Jaccard Index</a> for every combination of books in the list. Once I found the duplicates I corrected the errant names in the relevant source files and recreated the merged list.</p> #!/usr/bin/python import sys ##################################### def jaccard_index(set_1,set_2): n = len(set_1.intersection(set_2)) return n / float(len(set_1) + len(set_2) - n) ##################################### fileName=str(sys.argv[1]) shingleLen=4 with open(fileName,'r') as f: data = f.readlines() lineNumA=0 for line in data: line=line.rstrip('\n') primaryShingle=[line[i:i + shingleLen] for i in range(len(line) - shingleLen + 1)] primarySet=set(primaryShingle) lineNumB=0 for ll in data: if lineNumA < lineNumB: ll=ll.rstrip('\n') secondaryShingle=[ll[k:k + shingleLen] for k in range(len(ll) - shingleLen + 1)] secondarySet=set(secondaryShingle) jac = jaccard_index(primarySet,secondarySet) if jac > .35: print "%.3f\n%s\n%s"%(jac,line,ll) print "-----------" #print lineNumB lineNumB += 1 #print lineNumA lineNumA += 1 </code></pre> This left me with a list of 443 unique books. The next step was to determine the year each book was published. Using curl I ran the title and author as search terms through Google and WolframAlpha and was able to pull out the publishing date for nearly every book. The last few I filled in by hand.</p> This script looks to see if the date is already known (since I ran this quite a few times) and if it isn’t, tries to determine the date using Google and then WolframAlpha.</p> #!/bin/bash #Usage: ./tabulateBooks.sh tabulatedBooks.csv : > tempdatesfile #Create empty file cat $1 | while read line; do #for each line in the file do the following #The FPAT variable keeps commas inside quotes from being field seperators TA=$(echo "$line" | awk -vFPAT='([^,])|("[^"]+")' -vOFS=+ \ '{print $3,$5}') #Title and author's last name Stitle=$(echo "$TA" | cut -d"+" -f1) #cut out just the title #Now remake $title and $TA with the '+' delimiter replacing spaces TA=$(echo $TA | awk -F'[ ]' 'BEGIN{OFS="+";} {$1=$1;print;}') title=$(echo $Stitle | awk -F'[ ]' 'BEGIN{OFS="+";} {$1=$1;print;}') sanitizedTitle=$( echo ${Stitle//$/\\\(} ) #Replaces ( with \( sanitizedTitle=$( echo ${sanitizedTitle//$/\\)} ) #Replaces ) with \) #Look for known dates in file (use perl regex because it works) year=$(cat tabulatedBooks_withDates.csv | grep -iP \ "$sanitizedTitle\,\"([0-9]|\-[0-9])" \ | awk -vFPAT='([^,])|("[^"]+")' '{gsub("\"","",$4); print $4}' ) #Check if year is in the range 1000 to 2999 CE if (echo $year | grep -Eq '^[1-2][0-9][0-9][0-9]$') then printf 'Known year:%s\n' "$year" printf '\"%s\",%s\n' "$year" "$line" >> tempdatesfile continue fi #Check if year is in the range 0 to 999 CE if (echo $year | grep -Eq '^[0-9][0-9][0-9]$') then printf 'Known year:%s\n' "$year" printf '\"%s\",%s\n' "$year" "$line" >> tempdatesfile continue fi #Check if year is between 0 and 999 BCE if (echo $year | grep -Eq '^\-[0-9][0-9][0-9]$') then printf 'Known year:%s\n' "$year" printf '\"%s\",%s\n' "$year" "$line" >> tempdatesfile continue fi if !(echo $year | grep -Eq '^[0-9][0-9][0-9][0-9]$') then echo "Searching for year" searchString=$(printf '%s%s' "$TA" "+published") year=$(curl --silent --user-agent "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.93 Safari/537.36" \ https://www.google.com/search?q=$searchString | \ awk -f scrapeGoogle.awk) fi if !(echo $year | grep -Eq '^[0-9][0-9][0-9][0-9]$') then echo "Scraping google failed, trying wolframalpha..." searchString=$(printf '%s%s' "\"$title\"" "+first+publication+date") year=$(curl --silent --user-agent "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.93 Safari/537.36" \ http://www.wolframalpha.com/input/?i=$searchString | \ awk -f scrapeWolfram.awk) fi if !(echo $year | grep -Eq '^[0-9][0-9][0-9][0-9]$') then #make sure $year is empty if it isn't a 4 digit number year="" echo "FAILED: $Stitle" fi printf '\"%s\",%s\n' "$year" "$line" >> tempdatesfile done : > tempdatesfile2 awk -vOFS="," -vFPAT='([^,]*)|("[^"]+")' \ '{t=$1; $1=$2; $2=$3; $3=$4; $4=t; gsub(",,",","); \ print >> "tempdatesfile2"}' tempdatesfile rm tempdatesfile mv tabulatedBooks_withDates.csv tabulatedBooks_withDates.csv.backup mv tempdatesfile2 tabulatedBooks_withDates.csv </code></pre> These are the helper AWK scripts to interpret the downloaded HTML.</p> #For google results #!/usr/bin/awk BEGIN{ RS="<[^>]+>"; #Make each HTML tag a row divider OFS="+"; ORS=""; } /Originally published/{ if ($0=="Originally published") #Did it work? pubNR=NR #Remember row number else next #No luck, proceed to next book } NR==pubNR+3{ #Date will be 3 rows after the 'originally published' text dateArrayLength=split($0,dateArray," ") year=dateArray[dateArrayLength] #Pull out just the year print year } </code></pre> #For wolframalpha results #!/usr/bin/awk BEGIN{ FS="\""; OFS=""; } /stringified/{ c++; if(c==2){ dateArrayLength=split($4,date," ") year=date[dateArrayLength] print year } } </code></pre> At this point I have a delimited file containing the book title, author name, publishing date, number of lists the book appears in, and which lists those are and the rank in each list..</p> Graphs ’n Things</h4>
Joule Thief 2016-07-25T00:00:00+00:00 The Joule Thief is a fantastic intro to analog electronic circuits. The idea of a self-oscillating voltage booster is very old, but the current internet popularity (and name) is due to Clive Mitchel</a>. I taught an intro to circuits workshop at my local makerspace using a slightly modified version of his circuit which used a capacitor to smooth the output voltage. The makes a great project for people to take home at the end of a workshop and covers soldering, resistors, diodes, LEDs, inductors, induced current, back emf, capacitors, and persistence of vision.</p> Below is my prototype for the class, the only differences are that I added a battery holder and used a slightly different switch.</p> </p> I wanted to be able to introduce all the basic circuit components and the standard circuit doesn’t have any capacitors. Adding in a small capacitor (and diode to force it to discharge through the LED) had the added benefit of keeping the LED on constantly instead of flashing at a few tens of kilohertz with an approximately 50% duty cycle. While the increase in brightness wasn’t huge, it was certainly noticeable.</p> Note: The two inductors in the schematic are a single double wound toroid. I suggest doubling up and pulling through two wires at once. Normal wire works fine, but magnet wire is nice since the insulation is so thin. The easiest mistake is to solder together the two wires at either the beginning or end of the coil. What should happen is that one wire from the beginning of the coil and the OTHER wire from the end of the coil should be connected together and then to the positive battery terminal. Those are the two I have going through the board in the center of the toroid and then connecting to the switch, which then connects to the positive terminal.</p> </p> I also wanted the circuit to build into a useful form factor. Both so that members could practice soldering and so they would have more than a breadboard circuit to take home at the end. I thought about getting a PCB made, but I wanted it to feel less like a kit and more like a DIY project.</p> I sketched up an outline in Inkscape and cut some thin plywood to the proper size. Before the class I drilled all the holes in the wood and printed out a few pages of the outline. In class, once each person had their circuit tested on a breadboard, they glued the outline to the wood and placed all the parts.</p> Download PDF to print outlines</a> Download SVG to edit outlines</a></p> </p> If wires are left long enough, most of the connections can be made without and extra jumper wire.</p> </p> The circuit will run for a few days off of a “dead” AA battery and a few weeks off a new one.</p> Using GPG 2015-05-05T00:00:00+00:00 There is a great deal of info out there about PGP and GPG but I could never find what I wanted summarized nicely in one place. This is my attempt to do that.</p> PROCESS OUTLINE</h4> Create PGP public/private key pair.</strong></li> Backup public key, private key, and emergency private key revocation certificate in a SECURE location.</strong></li> Upload public key to keyserver</strong> (e.g. pgp.mit.edu) (Keyservers share keys between each other so it is only necessary to upload to one server.)</li> Download the public keys you wish to sign.</strong> Signing is a confirmation that a public key (user ID/email) belongs to the person it claims to belong to and that you believe that the private key associated with that public key is safely kept by that person. THIS IS NOT SOMETHING TO BE DONE LIGHTLY. THIS IS HOW A WEB OF TRUST IS BUILT.</li> CONFIRM THE KEY FINGERPRINT IN A SECURE WAY</strong> (e.g. in person)</li> Sign the user IDs that you trust, you can sign any subset of a user’s IDs.</strong> (Many IDs (emails, images) can be associated with one public key.)</li> Upload the keys you’ve signed back to the keyserver.</strong> Optional: You can also ‘trust’ a key/ID. Signing a key is a assertion of the validity of the key, that is, the person with the associated private key is who they claim to be. Trusting a key is local only (trust values don’t get uploaded to a keyserver) and is an assertion of how much you believe you can trust other keys signed by that person. GPG will by default trust a key if it is signed by a key you ‘fully’ trust or by three keys you ‘partially’ trust. Only ‘ultimately’ trust yourself.</li> Test sending and receiving messages</strong></li> </ul> Note these commands work on Mac and Linux with both gpg and gpg2 (as far as I am aware).</p> CREATING A PGP KEY</h4> gpg2 --gen-key</code></p> Use 4096 RSA (1)</li> Expiration date (less than 2 years is recommended, this date can be extended later and acts as a dead man switch)</li> Enter (real) full name</li> Enter real email address (advisable to use dedicated)</li> Enter optional comment (shown along with key name to others)</li> Enter a passphrase (length at least 12, memorable)(Can be changed) A long passphrase of over 6 words from more than one language will be very resistant to brute force and dictionary attacks but can be made easy to type and remember.</li> </ul> </li> </ul> BACKUP YOUR PRIVATE AND PUBLIC KEY</h4> Export public key</p> gpg2 --export -a "User Name" > user.pub.key</code></p> Export private key</p> gpg2 --export-secret-key -a "User Name" > user.priv.key</code></p> Create emergency revocation certificate. This is the ONLY way to revoke your public key if you lose access to your private key.</p> gpg2 --output user.rev.asc --gen-revoke key_user_name</code></p> BACK THESE FILES UP IN A SECURE LOCATION (SUCH AS CD/PAPER IN A BANK VAULT, ENCRYPTED DRIVE, ETC…)</strong></p> MANAGE AND EDIT KEYS</h4> List available public keys</p> gpg2 --list-keys</code></p> List available private keys</p> gpg2 --list-secret-keys</code></p> Display fingerprint of all public keys (Can be combined with --list-secret-keys</code>)</p> gpg2 --fingerprint</code></p> Edit a key</p> gpg2 --edit-key key_user_name/email</code></p> Type “help” to see list of commands in edit mode</p> EXCHANGING, SIGNING AND TRUSTING KEYS</h4> Upload public key to keyserver</h6> This can NEVER be deleted, only revoked, so don’t clutter the server.</em></p> gpg2 --keyserver pgp.mit.edu --send-keys KEY_ID</code></p> Download public key from keyserver</h6> gpg2 --keyserver pgp.mit.edu --recv-keys KEY_ID</code></p> Sign/validate user ID (AKA public key signing)</h6> gpg2 --sign-key key_user_name/email</code></p> Will ask to confirm which user IDs to sign. You can sign specific or all user IDs.</p> Trusting keys</h6> gpg2 --edit-key key_user_name/email</code></p> gpg2> trust</code></p> Default is “I don’t know.” Level of trust is how much you trust both their understanding of PGP (so they won’t make a mistake) and how much you trust their commitment to properly validating keys. “Ultimate” is a special level reserved for your own key.</p> SENDING AND RECEIVING</h4> Decrypt file</h6> gpg2 -d <file_name></code> (Spits out text to the terminal.)</p> gpg2 -d <file_name> > file.txt</code> (Saves text to file.)</p> Encrypt file (minimal example)</h6> gpg2 --encrypt -r "recipient_name" <file_name></code></p> Encrypt, sign, specify output name</h6> Use -a to export an ASCII file (for copying into a text field and such)</p> gpg2 -es -o <output_filename> -r "Recipient" <file_name></code></p> Clearsign</h6> Encrypts with your private key so only your public key can be used to decrypt it (proves it comes from you and that the data hasn’t been tampered with).</p> gpg2 --clearsign <file_name></code></p> Use -u <user_name> to specify a non-default private key</p> Note that the keys/IDs of the sender and recipient can be seen by a third party even if they can’t decrypt the message. The flag below can hid the recipient. See the examples section for more discussion.</p> To hide the intended recipient from a third-party</h6> gpg2 --hidden-recipient -e -r "recipient_name" <file_name></code></p> EXAMPLE</h4> Recently I was playing on online game of Diplomacy (a strategy game like Risk) with friends and we decided to add a crypto element. Below I’ll go through how we communicated using pgp. Of course you don’t have to use gpg or the terminal to do this, but it does give you a better sense of what is going on behind the scenes. We started off by each creating a private/public key pair for the country we were playing as. We didn’t want to clutter key servers so all keys were shared via text on a simple message board my friend programmed on his server.</p> Sharing public key</h5> Export public key</p> gpg2 --export -a "User Name" > user.pub.key</code></p> Make a plain text file with your intro message and sign that file (only need -u option if you have a different default key)</p> gpg2 -u "yourCountry" --clearsign message.txt</code></p> This will output a file message.txt.asc</code> which will have the message in clear text and a crypto signature proving the key which was used to sign it</p> Copy the contents of the message.txt.asc</code> file into a message on the board, and then also copy the contents of the user.pub.key</code> and append to the same message.</p> Proving your identity</h5> The easiest way is to generate a key fingerprint and put that in a message on the vDiplomacy site so we know for sure which key belongs to which country.</p> gpg2 --fingerprint</code></p> Outputs something like this:</p> pub 1024R/DB9C59CF 2015-01-13 Key fingerprint = E03D 7518 B11E BE5C 82BE 2143 FB43 9F02 DB9C 59CF uid [ultimate] Austria sub 1024R/5CD5DF64 2015-01-13 </code></pre> Copy that key fingerprint into the vDip message board.</p> Checking someone’s identity</h5> First import their public key. Make a file named country_name.pub.key and copy the key into it (Including the “BEGIN” and “END” lines)</p> gpg2 --import country_name.pub.key</code></p> Now check the fingerprint</p> gpg2 --fingerprint</code></p> Lists all keys on your keyring, look for the one you just imported and check the fingerprint against that on the vDip message board.</p> Check the signature of the message</p> Copy from the “BEGIN SIGNED MESSAGE” line to the “END SIGNATURE” line into a plain text file: file_name.txt.asc</code></p> gpg2 -d file_name.txt.asc</code></p> You should see an output like this:</p> gpg: Signature made Tue 13 Jan 2015 12:45:02 PM CST using RSA key ID xxxxxxxx gpg: Good signature from "user_name" </code></pre> Communicating</h5> To send a signed, encrypted message to a single person, create a plain text file as before with the contents of your message save as something like otherCountry_msg1.txt</code></p> gpg2 -eas -u "yourCountry" -o otherCountry_msg1.asc -r "otherCountry" otherCountry_msg1.txt</code></p> Copy the contents of the newly created file otherCountry_msg1.asc</code> into a message on the board. You can make a note at the top who it is for, or just let everyone try to decrypt it.</p> To decrypt a message, copy the contents from the BEGIN to END lines into a text file named something like otherCountry_msg2.asc</code></p> gpg2 -d otherCountry_msg2.asc > otherCountry_msg2.txt</code></p> Note that if the command above is used, a third party can see who is talking, even if they can’t read the message. For example, a message between Russia and England when tried to be decrypted by Austria gave the following:</p> gpg2 -d temp.enc gpg: encrypted with 1024-bit RSA key, ID D6762868, created 2015-01-15 "Russia" gpg: encrypted with 4096-bit RSA key, ID 7D5EF8AB, created 2015-01-12 "England Anonymous" gpg: decryption failed: No secret key </code></pre> This can be partially remedied by the use of the --hidden-recipient</code> flag, but there doesn’t seem to be a way to hide the sender. Of course the third party would have to have the sender’s and recipient’s public keys for this to work. It also seems to depend some on the software being used, I haven’t quite figured out exactly how.</p>

The Screen Driver</h4>
Alright, now that the overview is out of the way, let’s get into the meat of turning a bunch of ones and zeros into pixels on a screen.</p>

Printing a row</h4>

Electronic Load

Future Modifications</h4>
I went the battery route for extra portability, but it goes through batteries pretty fast when the fan is running so for long tests I’m going to add in a power jack.</p>
I’m going to work on changing the heat dissipation setup so I can get at least 50 watts.</p>

PHYS3098: Circuits

Teaching an old scope new tricks.

Voltaic Pile

Lists of Top 100 Books

Graphs ’n Things</h4>

Joule Thief

Using GPG

Upload public key to keyserver</h6>
This can NEVER be deleted, only revoked, so don’t clutter the server.</em></p>
`gpg2 --keyserver pgp.mit.edu --send-keys KEY_ID</code></p>`

Decrypt file</h6>
`gpg2 -d <file_name></code> (Spits out text to the terminal.)</p>`
`gpg2 -d <file_name> > file.txt</code> (Saves text to file.)</p>`

Chris Greenley

Mojo Toolchain

Characterizing a DC motor

Dumping an external EEPROM

Dive Computer Teardown - Versa Pro

Dive Computer Teardown - Genesis ReSource

DIY Suunto Vyper Data Cable

Tube Based Night Light

C Structs

Enabling PWM on the TM4C123 microcontroller

Building an inverting charge pump

Writing drivers for a Dot-Matrix LCD Display

Reverse Engineering an LCD dot-matrix display

Chris Greenley

Mojo Toolchain

Characterizing a DC motor

Dumping an external EEPROM

Dive Computer Teardown - Versa Pro

Dive Computer Teardown - Genesis ReSource

DIY Suunto Vyper Data Cable

Tube Based Night Light

Types of Tubes</h5> I tried two dual triode tubes, an Amperex 12AU7/ECC82 and an RCA 12AX7.</p>

C Structs

Enabling PWM on the TM4C123 microcontroller

Building an inverting charge pump

Writing drivers for a Dot-Matrix LCD Display

Architecture</h4> Before diving into the details of getting pixels to actually show up in the proper locations on the screen, let’s walk though a high level overview of how the driver is going to be set up.</p>

Main</h5> The most relevant parts of main.c are shown below.</p>

The Screen Driver</h4> Alright, now that the overview is out of the way, let’s get into the meat of turning a bunch of ones and zeros into pixels on a screen.</p>

Printing a row</h4>

Reverse Engineering an LCD dot-matrix display

Electronic Load

The Parts</h4> LM358P Dual Opamp</li> Potentiometer</li>

Future Modifications</h4> I went the battery route for extra portability, but it goes through batteries pretty fast when the fan is running so for long tests I’m going to add in a power jack.</p> I’m going to work on changing the heat dissipation setup so I can get at least 50 watts.</p>

PHYS3098: Circuits

Teaching an old scope new tricks.

Voltaic Pile

Lists of Top 100 Books

Which Book Lists to Choose?</h4> I decided to stick to top 100 lists and to avoid specific lists like “Top 100 scifi novels.” Some of the following are chosen by voting readers and some by literary experts.</p>

Data Wrangling</h4> I downloaded the raw HTML for each page and wrote AWK scripts to pull out the title and author.</p> An example of the HTML, in this case from GoodReads.</p>

Graphs ’n Things</h4>

Joule Thief

Using GPG

Upload public key to keyserver</h6> This can NEVER be deleted, only revoked, so don’t clutter the server.</em></p> gpg2 --keyserver pgp.mit.edu --send-keys KEY_ID</code></p>

Decrypt file</h6> gpg2 -d <file_name></code> (Spits out text to the terminal.)</p> gpg2 -d <file_name> > file.txt</code> (Saves text to file.)</p>

The Screen Driver</h4>
Alright, now that the overview is out of the way, let’s get into the meat of turning a bunch of ones and zeros into pixels on a screen.</p>

Future Modifications</h4>
I went the battery route for extra portability, but it goes through batteries pretty fast when the fan is running so for long tests I’m going to add in a power jack.</p>
I’m going to work on changing the heat dissipation setup so I can get at least 50 watts.</p>

Upload public key to keyserver</h6>
This can NEVER be deleted, only revoked, so don’t clutter the server.</em></p>
`gpg2 --keyserver pgp.mit.edu --send-keys KEY_ID</code></p>`

Decrypt file</h6>
`gpg2 -d <file_name></code> (Spits out text to the terminal.)</p>`
`gpg2 -d <file_name> > file.txt</code> (Saves text to file.)</p>`