A tale of five revisions

As can be seen in my previous post, i am currently working on an analog synthesizer, as a project to maintain and develop my analog/macro-circuit skills.

I started out doing some research, and decided to base my build on Thomas Henry's VCO-1 design.
I stripped some of the extra features off, (Sine converter/ pwm input) and proceeded to breadboard the resulting design, which immediately worked as designed.

What follows is an interesting study in what can go wrong with a design.

REV 1

I then started laying out a small two-sided design in eagle, aiming to fit everything within a single 5*5 cm square (this being minimum unit for  both the student hackspace i frequent, as well as the http://www.seeedstudio.com pcb service). This being a one-off side project in a busy period, i may have rushed the design a bit more than i should have, something repeated head -> desk moments later would confirm.

Revision 1 was etched, soldered and powered, but refused to work.
As an evening of inspection and probing gave little results i reinspected my circuit diagram, revealing that my oscillator had somehow between the original and my schematic become non-inverting.

REV 2

Revision two was mostly identical to revision one except for some inverted signs.
It took some time to get running, as i had broken one of my own rules for home etched (non-plated) designs to optimize space and minimize vias. After some debugging i discovered that one of my top-side component pads were unsoldered.
When i had corrected this, the oscillator immediately started running, and watching my scope i slowly turned up the voltage to full drive voltage. And, not watching the PSU, i then proceeded to run it well past the maximum.

I would later find out that the circuit working must have required some other mistake in the soldering.

REV 3
Believing that the second revision worked, i proceeded to revise the circuit to ease correct soldering (at the cost of some extra vias), re-etched, and soldered up the third revision of my circuit.
It never worked, and through several sessions of debugging i made no progress, and decided to scrap the current prototype and start anew. 


REV 4
Still convinced that the basic circuit was correct, and that the problem with the third revision was some artifact of my production process, i then adapted the circuit for production-grade pcb (less phobia of vias and top-level connections), and proceeded to order a set from seeed.
When the boards arrived, i then carefully tested all the transistors before soldering them, working off the theory that some of the components might be defective or have the wrong pinout.

Turns out, the footprint for my monolithic pair was just .. wrong. checking both the datasheet and the component, i then proceeded to solder the component "cross-legged", and the oscillator worked.
I am fairly certain that i checked all the footprints against the datasheets, and i have no idea how this managed to slip by me through four revisions.


Revision five will hopefully be a stable, correct implementation (although a greenwired rev.4 still works), and i hope someone out there will see this and at least be spared one of these mistakes.

The pleasure of finding things out.

In this case, "things" is the limits of my own stupidity.
I am currently working on a partially modular analog synth.
For my oscillator, i am basically using This for the basic schematic design, although i am using a monolithic pair for the exponentiator, cut some of the frills, and routed it double-sided (Having an almost unbroken ground plane on one side) leaving a significantly smaller circuit board than the original. Anyway, i etched the first prototype and quickly soldered it up on friday, aand... it didnt work. worse, the OTA got ... hot. I didn't have much time for debugging, but i made a thorough inspection of the board (which after hosting several basic soldering courses i consider myself good at). i discovered one or to weak joints, and one small short, but nothing that should make it that bad. Today, i glance at the schematic, and instantly see the problem:

Original schematic:

My eagle schematic:

Palm, meet face.

Further reports of my adventures in (synthetic music / stupidity) will follow.

7400 logic E-reader, Part 2: Block diagrams!

In this post i will go into the workings of the circuit. I intend to mostly do this by large scale diagrams instead of exact wiring schematics, partially because it is implemented as a Big Mess Of Wire on my breadboard, and because i don't think anyone would be very interested in seeing exactly how i connect four 4-bit timers together to make a 16-bit timer, especially as the exact devices in use are not important to the project (the timer in use, 74hc193, was selected as "fast enough", and then by local price/availability)

I also assume that anyone wanting to attempt this probably will be competent and interested enough to both be able and willing to figure that out themselves. (if you for some strange reason should want to copy this, i think i will advice a counter with up/!down select instead of upclock + downclock). If someone has any questions about any specifics, i will gladly answer them.

I hope to get a rudimentary partlist and video of it operating out shortly.

The basic idea behind the project is that by generating the sweep from the digital address signal, i can generate a sweep with relatively few components without having to worry about any sync pulses, stable clocks or similar problems. (click to embiggen)

By feeding the same address directly into a pixel lookup table, i can generate a 256 by 256 B/W (or black and green) image from nothing but five ics and thirty-odd resistors.

The pixel lookup can be simplified by splitting it into a pixel-font lookup and a text lookup, allowing us to store one page of text (32*32 characters) in 10 address bits (1K) worth of data.

Page control can then be implemented by manipulating the remaining adress bits of the text eprom (up to six bits = 64 pages on a 27C512) and scrolling by manipulating the line part of the sweep between the dac and lookup.

I could only fit two counter + two adders on my breadboard, so i can currently only scroll 8 or 16 pages (with or without using the carry from the last adder), but this could quickly be expanded by moving parts of the circuit off the breadboard (and onto stripboard).

This could easily be combined with a "chapter select" counter or switch, allowing full use of the eprom in question.

Limitations / possible gotchas:

Newer eproms/other types of memory could have issues with my current method of addressing (e.g tying !oe and !cs low to ground and just feeding the address directly), although i think this could be remedied by a octal d-latch and clocking the relevant pins on the ic in question.

At least with my current setup with a breadboard and slow (10MHz) scope, there is a trade off between flicker and warping. This is probably fixable, as the point where flicker ends is just about exactly where the warping starts to become noticeable (a few MHz). I currently get around this by reversing the x scan direction, as this effect is greatest as the sweep returns. With the "normal" sweep direction, this is affects the first character on every line, but with the current configuration, this is only visible on the last char, which usually is a space.

Neat tidbit:

The Dacs are nothing but a 74hc buffer, one 10K resistor and seven 10K trimpots. I originally made a quick calculation, and concluded that i didn't have high enough precision resistors for a "pure" R-2R dac, but this solution allows me to adjust away any nonlinearities in my pixel distribution.

Ideas for further improvement:

Partially modularizing the ic into modules roughly equivalent to the block diagram. This will make further improvement / experiments easier to implement/unimplement

ZIF socket, to simplify switching "books"

Replacing the text lookup with a dual-port sram, allowing me to use it as a text display for another project. Unless timing* becomes an to big of an issue, i will probably implement this shortly.

8-bit blanking -> image display

Using the unused top half of the 8-bit ascii set for EE schematic symbols (and then documenting the circuit, using itself)

* my timing abuse, vs what the chip will accept.

Edit:

Rough parts:

6x 74HC193 4-bit counter, for sweep and scroll

3x 74HC14 6-bit Schmitt inverter, for clock and reset generation, and for inverting y-axis

2x 74HC283 4-bit adder, for scrolling

1x 74HC151 8-bit mux, for sub-line select

2x 74HC541 8-bit buffer, one for each DAC

2+x 27C512 eprom

1x pot, for clock speed manipulation

1x quad-encoder

some 4000 logic chips i had lying around, for my improvised encoder decoder.

14-trimmer pots, some odd resistors and caps

a breadboard and a large (but not large enough) jumper wire set.

7400 Logic E-reader

This is my entry for the Open 7400 logic competition.
This post will consist of mostly images and basic descriptions, with another post coming soon with more technical descriptions and diagrams.

My project is an e-reader created entirely from discrete 74HC(T)00 components, some resistors and caps, two eproms, the odd 4000 chip.
The basic concept involves simultaneously feeding a 16-bit counter into two 8-bit R-2R DACs and a lookup table containing pixel data to be fed into the Z-axis (intensity input) of my old analog scope. This table is in effect implemented by having one eprom, containing ascii text, feed into another, containing a 8x8 pixel font. By manipulating the address lines of the text-eprom, further functionality like scrolling is achieved.
I might move parts of the circuit onto stripboard later, to free up space on my breadboard for more functionality (like chapter support or autoscroll).

Note: The front page says EEPROM instead of EPROM. I don't have access to a burner right now, so i can't fix it (ironically, if it did use an eeprom, i could).


Edit: Part 2 (link)