0
\$\begingroup\$

I'm in IT but I'd like to try some EE without any programming...

I'd like to make a circuit that outputs some custom digital signals. For example, an SOS signal:

0 1 0 1 0 1 0 0 0 1 1 1 0 1 1 1 0 1 1 1 0 0 0 1 0 1 0 1 0 
  .   .   .       _____   _____   _____       .   .   . 
      S                     O                     S

I'd like to make something that would generate signals like that on repeat, without using microprocessors. (just resistors, capacitors, inductors, transistors, OpAmps, Logic Gates, etc.)

My 1st idea is to take the desired digital signals and turn them into analog.

I'm thinking of using something like a Fourier Transform:

  1. Choose an output function
  2. Calculate the Fourier Transform
  3. Build a circuit to add several sine waves using results of the transform

However, build a (hopefully) small circuit using Fourier (with capacitors and Schmitt triggers to smoothen the signals) would probably be too impractical as I'll mainly be using prototype boards. (I'll make my PCB milling machine later)

My main question: What are some ways I can:

  1. Take some digital function (just a few dozen bits in length at most)
  2. Transform that signal into something that can be made by a simple non-programmable circuit (probably with a bunch of tiny function generators)
  3. Design a non-programmable to generate those digital signals

Edit:

  • I only want to not program the circuit. Calculations like the sinusoidal waves for a Fourier would all be done by the computer.
  • The Fourier Transform is just my 1st idea. I'm asking for more ideas and possible routes to take.
  • I don't mind too much if it's hard and complicated. A challenge will be fun anyway. I just want the final circuit (on either a prototype board or a DIY milled PCB) to be small and compact enough to carry around.
  • The length of the whole signal (which is to be looped over and over until I switch off the power) is meant to be pretty short (a few dozen bits) but it would be great if I can find some methods that would work for long signals as well.
\$\endgroup\$
9
  • 2
    \$\begingroup\$ What is your reason for wanting no programming? If the reason is time, ease, and simplicity then you are vastly underestimating the amount of hardware required and choosing the most difficult way to go about it. \$\endgroup\$
    – DKNguyen
    Oct 10 '19 at 15:23
  • \$\begingroup\$ If you want to play with the Fourier idea model it first. Be sure to examine the impact of frequency error resulting from low-accuracy components. Realistically if you wanted to build a non-software approach into hardware, you might look at a finite state machine but the idea is generally impractical unless you already have a reason to have a programmable logic device or to be making custom silicon. \$\endgroup\$ Oct 10 '19 at 15:28
  • 3
    \$\begingroup\$ "I'm thinking of using something like a Fourier Transform" I have never heard of anybody starting digital circuits with Fourier Transform. It feels like saying "I want to try something with engines so I begin with a jet engine". \$\endgroup\$
    – Oldfart
    Oct 10 '19 at 15:32
  • \$\begingroup\$ This was my senior year project! \$\endgroup\$
    – Tyler
    Oct 10 '19 at 15:44
  • 2
    \$\begingroup\$ For simple shift-register solution with programmable PISO bits, you will find a much simpler concept. Your fancy ideas show lack of understanding. \$\endgroup\$ Oct 10 '19 at 16:34
3
\$\begingroup\$

An "arbitrary waveform generator" (look it up) in its simplest form is an oscillator that drives a counter that drives a memory that drives a DAC:

schematic

simulate this circuit – Schematic created using CircuitLab

The number of address bits you need is determined by the number of steps in your waveform. The number of data bits is determined by how much resolution you want on your signal output voltage. If you just want to generate binary signals, you don't need a DAC at all.

\$\endgroup\$
4
  • 3
    \$\begingroup\$ I've seen a lot of old hardware that used this method, and we replaced it with a micro. \$\endgroup\$
    – Voltage Spike
    Oct 10 '19 at 16:10
  • \$\begingroup\$ ... and if you want to do it inexpensively and generate slow signals, you use a microprocessor. If you want to do it fast, you use an FPGA. \$\endgroup\$
    – TimWescott
    Oct 10 '19 at 17:50
  • \$\begingroup\$ @TimWescott Or even a CPLD in this case. \$\endgroup\$ Oct 10 '19 at 22:54
  • \$\begingroup\$ @CalebReister yes, of course. A small one. \$\endgroup\$
    – TimWescott
    Oct 10 '19 at 23:25
0
\$\begingroup\$

I'm thinking of using something like a Fourier Transform

That's a bad idea. Generating precise sine waves with different phases and amplitudes with an analog circuit is hard, and for some sequences you would need a lot of them! Better to stay in the time domain while using analog components to produce the required timing and bit patterns.

Any logic function can be produced with enough gates, but to make it more interesting you could use more 'analog' techniques such as ring oscillators, r/c time delays, 'gates' made from resistors, multiple voltage levels etc.

For Morse code you want a different sequence of dots and dashes for each letter. You could use r/c delays to generate the short and long pulses, with each pulse triggering the next one and diodes to combine them at the output. This is similar to the encoder circuits that were used in 'digital' radio control transmitters before TTL digital ICs became available. Here's an example:-

enter image description here

The multivibrator formed by VT6 and VT7 produces a short pulse which travels through subsequent timing stages. Each stage has a variable resistor to set the delay time, then their outputs are all combined together with diodes.

You can count pulses by charging a capacitor in steps through a resistor and diode, then compare the voltage to a fixed level adjusted to the desired count. Morse codes could be programmed as sequences of short and long pulses for each letter, eg. 3 x short, 3 x long, 3 x short for SOS.

\$\endgroup\$
0
\$\begingroup\$

Early electronic morse-code message-senders used punch-holes in moving paper tape or rotating opaque disk, read with photocells.

Much later was the hand-wired ROM made from diodes, and read out by 7490 counters and 7441 BCD-decimal decoder. (iirc this was a ham automatic callsign generator in QST magazine, or possibly Pop. Electronics.)

But in that case you're building a hard-wired computer: a non-programmable "state machine" like the ones found deep inside any microprocessor.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.