CC Blog Projects Research & Design Hub

Controller for a Cifra 5 (Digit5) Flip Clock

Written by Carlo Tauraso

Using a PIC16F84A MCU, an L293D Dual H-Bridge Motor Driver, and a DS3231 Real-Time Clock

In this article, I discuss making a synchronization circuit for the antique “Cifra 5” (Digit5) flip clock model, so that remote “receiver” clocks work even when disconnected from a central “signaler” clock and two-wire bus.

  • How can I make a synchronization circuit?
  • What’s a fun project with an old flip clock?
  • What can I build with a PIC16F84A?
  • PIC16F84A MCU
  • L293D Dual H-Bridge Motor Driver
  • DS3231 Real-Time Clock

During a visit to the building of an old, disused factory, I was impressed by the system adopted to connect the clocks in various production departments. To provide an accurate time reference for all workers, they had to create a synchronization network. The workshop environments were noisy, so they used “flip clocks” with large and clearly visible numbers. A flip clock, unlike a clock with hands or a digital display, typically shows the time by use of a spinning wheel that sequentially flips numbers on rings of flat flaps. The clocks were connected to a two-wire bus and synchronized through an electronic signal sent from a central clock. This device was called “signaler clock,” or clock equipped with controller movement, whereas the others were called “receiver clocks,” or clocks equipped with remote movement.

I noticed that, unfortunately, many clocks were broken, and the central clock was lost. I did some research on the ‘net and I discovered that the “Cifra 5” (Digit5) clock model was designed in 1954 by Gino Valle for Solari and C., a small Italian company that exported it all over the world. Digit5 is an electromechanical flip clock, which won the “Compasso d’Oro” (Golden Compass”) in 1956. It has four flaps of 10 digits each to make up all the hours of the day. The funny thing is that you can see it in the 007 film, You Only Live Twice (1967), based on the novel by Ian Fleming. It counts down in the launch console of spaceship Bird One used by SP.E.C.T.R.E. (Special Executive for Counter-Intelligence, Terrorism, Revenge and Extortion) to trap a Soviet space capsule in orbit. The small model called “Cifra 3” (Digit3), designed at the end of the sixties, is recognized as a twentieth century design icon throughout the world, and is part of the permanent collections of the Museum of Modern Art in New York and the New Design Museum in London.

Why not make a synchronization circuit for the Digit5? In this way, each receiver clock works even disconnected from the original two-wire bus. After an external cleaning and an overhaul of the internal mechanisms, I was able to get it working again after almost 50 years! This clock is a little jewel that combines aesthetic design and electromechanical genius.

For a historical clock, you need a historical microcontroller (MCU); therefore, my choice could only fall on the “legendary” PIC16F84 produced by Microchip USA. I have used the updated version marked with “A” suffix. The firmware developed in assembler is easily understandable, even for MCU programming newbies.

During the design, I faced some tricky problems. You have to reverse the supply voltage polarity at regular time intervals to advance the palette accurately. It is essential to calculate the instructions execution time for delay routines and establishing the first pulse polarity. You also need to consider the frequency drift of the quartz crystal generating the MCU clock signal. Small changes become significant in the long run.

I have decided to publish this basic and inexpensive solution, so all owners of these kinds of clocks can try to put them back into operation or check if they work correctly. The project is a basis for future developments and a useful experiment for those approaching MCU programming.

FLIP CLOCK DIGIT5 AND THE “FIRST PULSE” PROBLEM

The Digit5 clock is an electromechanical flip clock enclosed in a metal case, with a rather large, rectangular section (11 x 6 x4.3”) that can either be fixed to the wall or placed on a desk. It weighs about 3kg, and thanks to the generous size of its digits, it is easily readable even from several meters away. Wall attachment requires a special bracket. By adjusting a screw, the angle of the clock may be altered in relation to the wall.

Upon removing the back cover, we find a wonderful, well-assorted set of metal levers and gears that bring to mind eighteenth-century automatons. However, the Digit5’s real heart consists of a bipolar electric motor equipped with a coil with two different windings, so it can work at 12V or 24V. Before installing the clock, you must choose the voltage, using some jumpers numbered from 1 to 4 and positioned near the input connector. In Figure 1, you can see them in the lower left corner. Connecting the different pairs changes the input voltages. If you connect position 1 with 2 and 3 with 4, you get 12V, whereas if you connect 2 with 3 you get 24V. Using different voltages avoided the voltage drop determined by the resistance of the cables for long connections between the controller and remote clocks.

FIGURE 1 
The Flip Clock Digit5
FIGURE 1
The Flip Clock Digit5

Under the slotted wheel (near the input connector), the motor rotates the two-pin disc moving the whole mechanism. This disk can only rotate clockwise. With each turn, the pins entering the slot cause the rotation of the main wheel, which causes the flip rotation for hours and minutes. The disk rotates halfway every minute. Wrong polarity on the first pulse causes a constant 1 minute delay, as the disc remains locked for the first minute until the next polarity reversal.

The problem is well described by a sibylline sentence from the user manual: “In the event clock shows the constant difference of one minute, it must be advanced for one minute on master clock time and then wires of terminals must be inverted” [1]. The designers made the installer’s life easier by inserting a red dot on the rotor. This simple trick allows us to know the polarization of the next pulse. During the initial clock setting, whether or not the red dot is visible, you have to apply a different polarization to the input, as you can see in Figure 2.

FIGURE 2 First Pulse right polarization
FIGURE 2
First Pulse right polarization

When the case is open, you can rotate the two-pin disk by hand; when the case is closed, you can use a small cylindrical knob on the back cover.

CRYSTAL DRIFTS

Quartz crystals are mostly used as resonators in electronic circuits. In some projects, they are fundamental as a reference. The developer must definitely take into account that crystals are susceptible to frequency drift, causing clocks to lose accuracy over time. In a quartz crystal oscillator, a thin slab of quartz is placed between two electrodes. A voltage applied to the electrodes on the crystal causes it to change shape. When the voltage is removed, the crystal generates a small voltage as it elastically returns to its original shape (a property known as inverse piezoelectricity). The quartz oscillates at a stable resonant frequency, behaving like an RLC circuit.

Typically, the most significant environmental factor affecting drift is temperature. The change in accuracy of a given frequency is measured in parts per million (ppm). Shifts in temperature can increase drift by tens of ppm over even a standard temperature range. In many other applications, a change of 50ppm in excess is negligible; however, in an application like this, this small error addition can cause an advance of several minutes over a year. This is even truer if you use the clock signal to synchronize the MCU instructions execution.

If you consider, for example, a 4MHz clock frequency with an excess variation of 50ppm, it means that the frequency reaches 4,000,200Hz. Considering that an instruction execution time is equal to four cycles, we would have a number of instructions per second equal to 1,000,050. In a delay routine, 1 minute would no longer last 60 seconds, but rather 59.997 seconds. Therefore, in 1 hour we would have an advance of about 0.18 seconds, which becomes 4.3 seconds in 24 hours, and about 26 minutes in one year.

In the first prototype, I used a 32.768kHz crystal in a cylinder package with a frequency tolerance of ±20ppm. This is much more accurate than commonly used quartz crystals with an error per year of about 10 minutes. Not satisfied with the result, I decided to replace the crystal with a DS3231 IC circuit— a real-time clock with an integrated, temperature-compensated, crystal oscillator.

The DS3231 incorporates a 32.768 kHz, temperature-compensated, crystal oscillator (TCXO). It includes an internal temperature sensor that the IC circuit references to adjust the frequency of the crystal. The TCXO provides a stable and accurate reference clock at the 32K pin. The controller reads the output of the on-chip temperature sensor and uses a look-up table to determine the capacitance required, so the accuracy remains about ±2ppm from 0°C to 40°C, which is the equivalent of just over ±1 minute each year. As shown in Figure 3, the function of an inverted parabola describes the temperature dependence of the frequency accuracy [2]. This accuracy is typically ±20ppm at room temperature (25C°) and decreases at more extreme high and low temperatures. The effect of the temperature compensation is to flatten the parabolic curve; the DS3231 has a narrow accuracy band in a temperature range from 0 to 40°C for the S or SN version. The IC is factory calibrated, and it does not require calibration or development effort–an ideal solution for this project.

FIGURE 3 
DS3231S Temperature vs Frequency Accuracy from Maxim Integrated Datasheet [2]
xa
FIGURE 3
DS3231S Temperature vs Frequency Accuracy from Maxim Integrated Datasheet [2] xa
DESIGN AND CONSTRUCTION – THE CTRLCIFRA5 BOARD

The circuit consists of three integrated circuits: the PIC16F84A MCU, the L293D dual H-bridge motor driver, and the DS3231, a real time clock with an integrated, temperature-compensated, crystal oscillator. The PIC16F84A MCU is a “legendary” MCU manufactured by Microchip USA since 1996. It uses a Harvard architecture. Therefore, the device has a program-memory bus separated from the data-memory bus. This improves bandwidth over traditional von Neumann architecture. A two-stage instruction pipeline allows all instructions to execute in a single cycle, except for program branches. The pipeline overlaps fetch and execution of instructions, so one instruction is executed while the next instruction is fetched. In firmware, this information is used to calculate the exact instructions execution time in delay routines. The PIC address 1Kx14bits program memory; it has up to 68 bytes of RAM, 64 bytes of Data EEPROM memory and 13 I/O pins.

In the circuit, I use two PORTB I/O pins: RB1 and RB2 configured as outputs. They are connected to two L293D input pins: IN1 (pin 2), IN2 (pin7). As shown in the schematic in Figure 4, the L293D consists of two separated H-bridges, with the first connected to the IN1-IN2 pin pair and the second to the IN3-IN4 pin pair. The EN1 pin is an enable line pulled up to 5V, so the associated driver controlled by IN1 and IN2 is always enabled. Normally, we use this type of circuit to control DC motor spin direction, with logic level presented from the two input pins. When either one of these lines is brought high while the other is pulled low, then a different direction is chosen. When IN1 is high and IN2 is low, the voltage output is presented to OUT1 and OUT2 pins with OUT1=+VMotor and OUT2=GND. Instead, when IN1 is low and IN2 is high, the voltage output is presented to OUT1 and OUT2 pins with OUT1=GND and OUT2=+VMotor.

FIGURE 4 
The CtrlCIFRA5 schematic and parts list.
FIGURE 4
The CtrlCIFRA5 schematic and parts list.

The Digit5 clock has a small motor, which every minute must receive an impulse of about 1 second alternately polarized first in one way and then in the other. So, to make the clock work, the PIC will bring high logic level IN1 and low IN2 for the first minute, and low logic level IN1 and high IN2 for the second minute, and so on. In this way, a polarity reversal will occur every minute. The 5V logic voltage is applied to the L293D V+ pin (pin 16), and it is separated from the clock’s supply voltage, which is higher up to 12V or 24V, connected to the +VMotor pin (pin 8).

The PIC needs a clock oscillator to control the speed of the CPU and step it through its operations. The time will only be as accurate as the reference used; therefore, the PIC synchronization signal depends on the accuracy of the instruction execution time. I directly used the 32.768kHz square wave signal from the DS3231 32kHZ pin (pin 1). It is an open-drain pin, and it requires an external pull-up resistor R1. The square-wave frequency is stable and accurate, thanks to TXCO, which compensates for variations caused by changes in temperature. The IC adjusts the internal capacitive load to maintain a consistent frequency across temperatures. The output is corrected every 64 seconds. If you use the circuit in an indoor environment, it works well.

The L293D works at 5V whereas the PIC16F84A and DS3231 work even at lower voltages (3.3V). You can power-up the circuit with a voltage of 12V or 24V depending on how the flip clock input voltage has been set. Note: do not use higher voltages, because you could irreparably damage the motor coil, the heart of the clock. The 12V or 24V voltage is connected to two lines. One goes to the input of the LM7805 (VR1) voltage regulator powering 16F84A (U1), L293D (U2), DS3231 (U3) at 5V, and the other goes directly to the L293D +VMotor pin and will be used to generate clock pulses. In Figure 4 you can see the schematic as well as the parts list (copied here):

  • C1=47µF cap
  • C2=10µF cap
  • R1, R2=4.7KΩ res
  • VR1=78L05 voltage regulator
  • U1=PIC16F84A MCU
  • U2=L293D dual H-bridge
  • U3= DS3231SN RTC

For a simple and small assembly, I have created a small, rectangular PCB (48mm x 32mm). The DS3231 is normally offered in a 16-pin, 300-mil SO package. To make PCB integration easier, I purchased a breakout board. (You can easily find it on Amazon, eBay or other platforms, using the keyword “DS3231 RTC module for Pi.”) Be careful to buy the original DS3231S or DS3231SN version, and not the DS3231M. The M variant uses a MEMS oscillator, which is less accurate—only ±5ppm compared to the ±2ppm of the SN original variant.

The small board has a 5 pins header connector (V+, DATA, CLOCK, NC, GND) with 2.54mm pitch and a CR927 3V lithium battery. You just have to make a few changes. Remove the battery. Replace the 5-pin female strip connector with a 5-pin male strip connector. Connect a wire from the DS3231 pin 32K (pin1) to the NC (not connected) pin of the male strip connector. At the end, you can insert the modified module directly on the PCB in correspondence of five metallized holes near the PIC. The board modification sequence is given in Figure 5.

In Figure 6 you can see the PCB top and bottom copper layers. It is a small card with a simple scheme to connect the DS3231 breakout board to the boundary components. On the right and left sides of the board, there are 2mm holes to fix the circuit in a box.

FIGURE 5 
The DS3231 board modification sequence.
FIGURE 5
The DS3231 board modification sequence.
FIGURE 6 
The CtrlCIFRA5 PCB details.
FIGURE 6
The CtrlCIFRA5 PCB details.

Assembly takes place by soldering first resistors, capacitors, the voltage regulator, two sockets for PIC and L293D, and then welding the DS3231 module to the board. In Figure 7 you can see the assembled prototype board, with a view from above, and the relative pinout for power and the output first pulse polarization.

FIGURE 7 
The prototype board, top view.
FIGURE 7
The prototype board, top view.
INSTRUCTION EXECUTION TIME OR COUNTERS?

When we work on something time-critical, we have different ways to control the timeline. Using a MCU such as a PIC, the following two are the most used: 1) write your own delay function and examine the assembly code determining how long it takes to execute and 2) configure a counter to count external clock pulses applied through port pins. In real applications, there are many cases where you may have to face similar problems. Assume you have to analyze a speed signal on your bike or any sensor signal in the form of square wave; assume you are sampling an audio signal with a specific frequency; assume you have to measure the time elapsed between two events; assume you have to trigger an activity after a predetermined time, or ensure that an instruction sequence runs without being interrupted.

In this project, we really need to generate output pulses at specific time intervals, and we use the DS3231 32kHz clock as the CPU clock. We write our own delay routines, and we try to get the exact number of clock cycles it will take to execute. In the PIC 16F84A, there is also an 8-bit timer/counter (TIMER0) able to count the rising and falling edge of a square wave signal applied to pin RA4. Therefore, the same problem can be solved by applying the DS3231 32khz signal to pin RA4 and counting the input pulses (rising or falling edges). We chose the first method because we save a little bit in terms of power consumption, and because the development technique can be a general and useful tool in all cases where we need to answer the question “How long does it take to execute?”

The PIC is a RISC processor that had an easy way to determine cycle count. Using this method, we also realize how the mathematical implications of a relatively simple problem can be much more complex. The firmware logical flow in its final version will be simpler and more understandable even for those approaching this type of problem for the first time. The use of Timer0 would have been a little more complicated, especially for the 59-second delay routine, since the counter is limited to 8 bits; (you have had to manage the overflow and the related interrupt signal). In the next section, we will see in detail a simple development method that can be used to write your own delay routines, and the algorithm to search the parameters value to obtain a certain number of instruction cycles and consequently a specific time delay. So, let’s get started.

THE FIRMWARE: WAIT FOR THE RIGHT MOMENT

The firmware, developed in assembler, has two main functions: one pulls RB1 and RB2 at high logic level alternately with 1-second pulses; the other simply waits for the remaining 59 seconds. In a design that measures time, it is essential to calculate the instruction execution time. In this case, I use a 32.768kHz clock signal. Considering that one instruction cycle is four oscillator cycles, in 1 second the PIC executes 8,192 instruction cycles. However, not all instructions are executed in a single instruction cycle. Instructions that have a conditional branch (INCSZ, BTFSS etc.) or instructions that will change the Program Counter (GOTO, CALL, RETURN) require two instruction cycles to be fulfilled. Therefore, during development, you have to take into account not only the execution time of the delay routines but also of the external instructions.

In general, you reduce the number of cycles associated with delay routines by the number of cycles lost executing external instructions. To make the overall execution time as accurate as possible, I have concentrated the logic flow in a single loop, instead of dividing it into a double procedure, one for the RB1 line and one for the RB2. I defined a variable P1 and initialized it with the value 66, corresponding to the binary value 0100 0010. Every time I have to generate a sync pulse, I move the value to the PORTB through the W register and execute the instruction “swapf P1,1” so the upper and lower nibbles of P1 are exchanged.

In this way, in the first execution RB1 is set to a high logic level, since the second bit of the binary value is equal to one; in the second execution RB2 is set to a high logic level, since the third bit is equal to one; and so on, alternating the second and third bit. I have developed two delay routines: “Delay1” and “Delay59”—one for the duration of the single pulse sent every minute, and one to wait the following 59 seconds.

Finally, I also considered a small delay due to the initialization of the PORTB, and the variable P1. It is a minimum delay of 0.244ms, together with the power-up timer that causes a wait of 72ms after power appears. It allows the voltage to rise to an acceptable and solid level. This small delay occurs at start-up, but remains constant during circuit operation, so it does not affect the overall accuracy of the project. After start-up, each loop cycle lasts exactly 1 minute. You can do these measurements easily using the MPLAB debugging system and activating the “Stopwatch” window. By placing a breakpoint on the instruction “movwf PORTB” you can see that it is executed after 60+c, 120+c, 180+c seconds and so on, with c corresponding to the initial delay (72,244 ms). The delay routines code (DELAY1, DELAY59) is based on nested loops, some counters, and DECSFZ + GOTO instructions. I used a code generator that calculates loop counters using an optimum search algorithm.

Let’s see concretely how these routines can be developed, and the details of the algorithm used. We start from a basic cycle consisting of a single counter loop. Our goal is to determine the value to assign to the counter to obtain a certain number of instruction cycles.

1-Loop 1-Counter
Delay
	movlw	value
	movwf	C1
D_0
	decfsz	C1, f
	goto	D_0
	return

Looking at the instructions sequence, the counter c1 is valued (1 byte = from 0 to 255) through the register w, then a loop is entered; at each step, the counter is decreased by 1, until it reaches zero. This is a routine, so we will have to consider that the delay already includes 4 cycles corresponding to the call and return instructions. Formally we define: cn = nth-counter, Nc = total number of instruction cycles of the routine (including call and return instructions).

If we count the cycles necessary for each instruction we find:

movlw = 1 cycle
movwf = 1 cycle
decfsz = 1 cycle if c1 is not 0,
	     2 cycles if c1 = 0
goto = 2 cycles

So, assuming c1 is not 0, we have five cycles to which we have to add the three cycles of the loop (decfsz+goto) repeated as many times as the counter value. When c1 reaches zero, the decfsz (decrement f skip if 0) skips the next instruction, so you don’t have to count the goto. Thus:

If (Nc – 9) is not divisible by 3, we have to decrement Nc until it becomes so; at the end we add as many NOP as the number of cycles of decrease. For example, if we want to develop a 498-cycle routine we decrease it to 495 and add 3 nop at the end of the routine.

And the ultimate routine is:

Delay
	movlw	0xA2
	movwf	C1
D_0
	decfsz	C1, f
	goto	D_0
	nop
	nop
	nop
	return

Now, let’s see how to add an extra counter and a second cycle to increase the number of delay cycles. The bold parts are those added to the basic cycle seen in the previous paragraphs.

2-Loops 2-Counters
Delay
	movlw	value1
	movwf	C1
	movlw	value2
	movwf	C2
D_0
	decfsz	C1, f
	goto	D_1
	decfsz	C2, f
D_1
	goto	D_0
	return

If we count the cycles we arrive at a new equation.

We substitute the value found in the starting equation and we obtain:

The solution is (101, 7). The search algorithm is always the same; we set the first counter to 0 and we get the integer part of the second counter. We substitute the value found in the starting equation, and we get the value of the first counter. If (Nc + 1273) is not divisible by 5, we decrement Nc and add at the end as many nop as there are decrements. The resulting routine corresponds to the one found in the project firmware (Delay1).

FIGURE 8 
2-Loops 2-Counters solutions example.
FIGURE 8
2-Loops 2-Counters solutions example.

Let’s see geometrically some solutions on the Cartesian plane (Figure 8). We have learned how to add a counter and a loop, creating delays of up to 39 seconds. We can proceed with the last step by developing the 3-loop and 3-counter routine. In the project, we also have to develop a routine that has to wait 59 seconds, and the 2-counter system just shown is not enough. The bold parts are the added ones.

3-Loops 3-Counters
Delay
	movlw	value1
	movwf	C1
	movlw	value2
	movwf	C2
	movlw	value3
	movwf	C3
D_0
	decfsz	C1, f
	goto	D_1
	decfsz	C2, f
D_1
	goto	D_2
	decfsz	C3, f
D_2
	goto	D_0
	return

We count the cycles and arrive at the new equation:

— ADVERTISMENT—

Advertise Here

The necessary and sufficient condition (nsc) for this equation to admit integer solutions is that (Nc + 460535) is divisible by GCD (7, 1792, 458752), that is, by 7. In the project, we need a 59-second routine corresponding to 483,328 cycles. Let’s see how to proceed. 483,328+460,535 = 943,863, which is not divisible by 7; therefore, we decrease the value up to 943,859. We first set c= 0 and c= 0 and determine c3 considering only its integer part.

Thus, we have:

The solution is (181, 14, 2). The resulting routine corresponds to the one found in the project firmware (DELAY59). Let’s see geometrically some solutions in 3D space (Figure 9).

FIGURE 9 
3-Loops 3-Counters solutions example.
FIGURE 9
3-Loops 3-Counters solutions example.

For each delay, we have a surface. To simplify the plot, I have considered only two delays—49 seconds and 59 seconds. Analyzing the “DELAY59” routine, you can see that it executes fewer loops than the 59-second delay (483,316 against 483,328 instruction cycles). The missing 12 cycles compensate the delay produced by the instructions outside the routine. Without this compensation, the execution of external instructions produces a small error that accumulates every minute. In normal applications, 12 clock cycles correspond to 12µs at 4MHz, a very short period of time that we would normally ignore. The DELAY1 routine also does not last exactly 1 second for the same reasons.

CTRLCIFRA5 SETUP AND TEST

For the clock set-up, you can follow a simple procedure. You must take the time from a digital clock, perhaps radio controlled, as a reference. Remove the back cover and advance the time on the flip clock by turning the two pins disk, until 2 minutes after the reference clock time. I have chosen 2 minutes to have time to close the cover and connect the circuit output to the clock input. Pay attention to the correct polarization. If the red dot is visible, then you have to connect the positive to the right pin of the clock (looking from the backside). If it is not visible, you have to connect the positive to the left pin. The positive pin for the first pulse on the PCB header connector has the label CK+. Close the back cover, and wait for the reference clock to indicate the time set on the flip clock. As soon as the seconds reach the value 00, power-up the circuit. In Figure 10 you can see the connection diagram between clock and PCB, and the final result.

FIGURE 10 
ctrlANT+ and GPS 64st screens
FIGURE 10
ctrlANT+ and GPS 64st screens
CONCLUSION AND FUTURE EXPANSIONS

It was a lot of fun bringing back to life a clock stopped for about 50 years. This project can be useful for all those who have to develop a time-dependent firmware. I faced various kinds of problems, from the quartz crystal’s reliability to the calculation of instruction execution time. It would be interesting to expand this project, for example, using the programmable interrupts at different time intervals by replacing the clock at 32K, adding a switch to advance the minutes, adding a heartbeat LED, or adding some other features connecting the PIC with the DS3231 I2C interface. For the moment, I hope this circuit will be interesting for all of you. See you in the next one. 

REFERENCES
[1] Cifra 5 (Digit5) Clock User Manual
https://solariudineclocks.xoom.it/site/index.html@page_id=16&lang=en.html
[2] DS3231 Maxim Integrated Datasheet:
https://datasheetspdf.com/datasheet/DS3231.html

RESOURCES
Analog Devices | www.analog.com
Microchip Technology | www.microchip.com
Texas Instruments | www.ti.com

Code and Supporting Files

PUBLISHED IN CIRCUIT CELLAR MAGAZINE • SEPTEMBER 2023 #398 – Get a PDF of the issue

Keep up-to-date with our FREE Weekly Newsletter!

Don't miss out on upcoming issues of Circuit Cellar.


Note: We’ve made the Dec 2022 issue of Circuit Cellar available as a free sample issue. In it, you’ll find a rich variety of the kinds of articles and information that exemplify a typical issue of the current magazine.

Would you like to write for Circuit Cellar? We are always accepting articles/posts from the technical community. Get in touch with us and let's discuss your ideas.

Sponsor this Article
+ posts

Carlo Tauraso (carlotauraso@gmail.com) studied computer engineering at the University of Trieste in Italy and wrote his first assembler code for the Sinclair Research ZX Spectrum. He is currently a senior software engineer, who does firmware development on network devices and various types of micro-interfaces for a variety of European companies. Several of Carlo’s articles and programming courses about Microchip Technology PIC MCUs (USB-PIC, CAN bus PIC, SD CARD, C18) have been published in Italy, France and Spain. In his spare time, Carlo enjoys playing with radio scanners and homemade metal detectors.

Supporting Companies

Upcoming Events


Copyright © KCK Media Corp.
All Rights Reserved

Copyright © 2024 KCK Media Corp.

Controller for a Cifra 5 (Digit5) Flip Clock

by Carlo Tauraso time to read: 19 min