How the Type G Gate Worked

apollo 3 input NOR gate
An image of the silicon die inside the Type G 3 input NOR gate used to power the Apollo Guidance computer.

Previously I went through the three input NOR gate that ran the Apollo Guidance Computer and how the circuit works. Previous to that I also told the story of how this chip partially funded Silicon Valley as we know it today. This post builds on that and goes through how the silicon works, and the simplicity of the circuit. Quite a famous image of the chip, fairly detailed image of the silicon inside the device spurred on this post, and taught me lots about silicon that I want to pass on.

apollo 3 input NOR gate schem annotated
The schematic of the 3 input NOR gate. From the schematic of the Apollo Guidance Computer. Annotated with my own designators for reference.

The above schematic of the 3 input NOR gate is also shown in previous posts. It is from the NASA Apollo Guidance Computer schematic, but I have annotated it so that I can reference to specific parts. It is a handy schematic considering it was right at the start of the development of semiconductors. The first image in the post is the best image of the silicon, but is not very big. The biggest image I can find is not quite as sharp, but is much better to annotate, it is the same chip. The first annotation shows the pinout of the device, and how those pins actually connect to the pins.

apollo 3 input NOR pin out
The silicon of the 3 input NOR gate with annotations to show which pin is connected. The pin numbers are from the schematic.
Showing how pins are connected
An image showing how the pins coming off of the silicon are connected into pins of the flat pack.

The noted parts of the above images are pins 5 and 10, and are the starting points to deciphering the layout. If you look at pin 5 and 10 on the schematic, they correspond to GND and power respectively. They are the only pins that are shared between both NOR gates. Apart from that the two sides look remarkably similar, and are basically a mirrored version. To figure which is ground and which is power, the resistors need to be taken into account.

apollo 3 input NOR gate resistors
The resistors on the silicon of the device. Shown above as brown lines they are P doped silicon that act like a resistor.

The above image shows the resistors found on the device. They tend to just be a thin section of P doped silicon, and above connect two sections of aluminum to form a resistor. It is also noted that there is big section of brown surrounding the whole circuit. Although it functions like a resistor and is made in the same way, it is puterly for ESD purposes, protecting the circuit. This big ring also is a big hint that it is connected to ground (pin 5). the second hint is that GND has no resistors attached to it on the schematic, but power has two. They are R1 and R2, connecting to pin 9 and 1 respectively, and are pull up resistors. Pin R3 to R8 are simply the base resistors for the transistors. They are all roughly the same size, and are there are 6 of them. The transistors are also fairly obvious in the centre of the silicon.

apollo NOR gate transistors
The centre silicon from the Apollo 3 input NOR gate. The transistors have been shown, and the collector, base and emitter also shown,

The above image is showing the heart of the device. the 6 transistors that make it resistor-transistor logic. As you can see in the above image, all the collectors are connected together, connected to pins 1 and 9. If you look closely, the base and emitter of each transistor sit inside a brown section like the resistors. This is P doped silicon and forms the base-emitter junction. This allows the base and emitter to sit anywhere within that P doped silicon detection to work. This means that the transistors do not conform to the standard Collector-base-emitter topology. All of the emitters are also connected together via the aluminium placed on the top, but the P doped sections of each device are seperate. As all the transistors of each device have common emitters, it doesn’t matter that they are all connected together, by design, only one of the transistors needs to be on for it to function.

Ken Shirriff transistor side view
A great image showing how the transistor works from a side view by Ken Shirriff.

The above image found on Ken Shirriff’s blog shows how the transistor works with the emitter and base in the P doped silicon. I may do some more posts about it, but his blog is a great place to find more information on silicon reverse engineering.

Electronics world 1963
A cutout from electronics world in 1963 showing the new process of planar technology. This method was used to make the NOR gate.

The above image is an interesting one I found while researching this chip. A section in electronics world 1963 showing how micrologic is made. The type G chip was part of the second batch of micrologic circuits. This section was useful to see how silicon was actually manufactured, and in some ways, still is today.

The NOR Gate That Got Us To The Moon

Type G micrologic
The Fairchild Type ‘G’ Micrologic gate for the Apollo Guidance Computer – this is the flat pack verison

In a previous post I talked about how the going to the moon kick started the silicon age. If you haven’t read it, it is short but really interesting story about how NASA made Integrated circuits cheap, and partially funded what we now know as Silicon Valley. In this post I am going to take a slightly closer look at the circuit that ran the famous type “G” Micrologic gate that ran the Apollo Guidance Computer.

apollo 3 input NOR gate
The official NASA schematic of the Type G micrologic gate found in the Apollo Guidance Computer

As you can see in the above image, the circuit was not particularly complicated. You have to remember that this is very early logic, before CMOS or NMOS or any other fancy IC technologies. This is basically two 3 input NOR gates, they both run off the same power, with pin 10 at the top, and the negative which was likely ground being shared on pin 5. The output for the left NOR gate is pin 1, and the output for the right is pin 9. The three inputs for the left are pins 4, 2 and 3, with the right having pins 6, 7, and 8 as inputs. Simply put, the output is “pulled” high to power when all the inputs are OFF. The resistor between pin 10 and pin 1 (or 10 and 9) are a simple pull up resistor as you would find in most electronic circuits. As expected with a NOR gate, the output will be only be ON when all the inputs are OFF. When any of the inputs are ON the output of that gate will be pulled to ground. One two, or all the inputs can be on, but it just needs one to turn OFF the output. The resistors going into the base of the transistor are just to limit the current.

3 input NOR
My breadboarded version of the 3 input NOR gate, it is made with BC547 transistors and a DIP switch. the output has been inverted with the LED.

I made a simple recreation of this circuit using BC547 NPN transistors, but most NPN transistors would work, these were ones I found in my parts box. As you can see in the image above, I have made it on a breadboard, with the inputs being a DIP switch attached to the power (5V in this case). The base resistors for the transistors are 1K and the pull-up to 5V is a 10K. I recommend making up this circuit if you want to learn a bit more about logic, and is a cheaper method than going out to buy 74 series logic chips! As you can see in the images there are a number of states that I showed the circuit in, and notice that if any of the switches are on, the circuit turns on, this is slightly against what I mentioned earlier, but thats due to the output LED using the transistor as a current sink, not a source, so the output is inverted. Basically, when the output is 0 the LED turns on. The only time the LED is off (output high) is when no switches are on, meaning all the transistors are off.

apollo 3 input NOR gate
An image of the silicon die inside the Type G 3 input NOR gate. We will be going through how the layout works in a future post.

The final point for this post is why the circuit is actually quite inefficient. Modern logic is amazingly low power compared to this. One of the biggest issues is that it is always taking power in some way. When the inputs are off, there is still some leakage through the pull up resistor, when an input is on, then there is current going through the resistor to ground. Also, by the nature of the transistors there is always parasitic leakages, and inefficiencies in the process. They are only small numbers, but the AGC used over 3000 of these circuits, so the small leakages soon add up to draw some hefty power needs, especially for battery powered operations.

If you enjoyed this post, take a look at the rest of my blog, there is lots about space, electronics and random history. I am always open to ideas and feedback, and where is best to post links to my posts.

Semi Autonomous Robotic Platform

As part of my degree I had to complete a project as part of the third year in the field of robotics and electronics. I chose to make a robotic platform, a simple idea that could be completed to a high quality with the right amount of effort. What is a robotic platform I hear you ask? well it essentially is a small buggy/rover that that moves around an assigned area completing simple jobs such as transporting goods, picking up parcels or any job that needs a moving vehicle. Usually autonomous, and very expensive, the majority of systems are very application specific. Some simple systems without any sort of control system can cost tens of thousands of pounds, and are not easy for the average employee to operate. Tackling the problem of expensive, application specific robotic platforms was the basis of my project.

4WD robotic platform
The Nexus 4 wheeled drive mecanum robot has an arduino based control system, and mecanum wheels, but will set you back $1500

Named the Semi Autonomous Robotic Platform, the idea was very simple, make a modular system, with building blocks that could be easily interchanged, and didn’t cost the world. These modules were things like motor controllers, sensors and power systems. If a user had a working platform built from this system, it would take minimal effort to swap out any of these modules to bigger motors or better sensors. This means a user can make a robot and only buy the bits they need, and even make their own modules, as long as they fit to the standard written as part of the project.

system block diagram
The initial block diagram of the system, showing how the modules can be controlled in hierarchy structure.

In most robotic systems, mainly to keep costs cheap, there is one controller that controls everything. This idea makes sense for small integrated systems that don’t need to change, but doesn’t really work when systems need to be dynamic. For instance, say you decide that your DC motors driving your robot aren’t giving you the control you want. You source some stepper motors, but this means completely changing the motor controller and therefore the software that controls it. Because one controller is in charge of everything, the software for the whole system needs to be re-written, and re-tested. That small change could have affected any of the other systems that that controller is in charge of. Make a change that breaks something important, you could set back a project weeks. This shows how painful a setup like this can be, especially when it starts to become a complex robot. Add on top of that the potential for computer intensive algorithms being used on the robot, like route planning or SLAM, and that controller suddenly has a lot to do. My system design separates these jobs out to a selection of individual controllers, such as a system specifically for motor control, or power systems. These controllers can deal with the nitty gritty hardware, and leave the master controller to orchestrate a higher level version of control.

Final Year Project
My design, near the end of the project, with the mecanum wheels, ultrasonic sensors and multiple controllers.

The added benefit of separating out all these jobs means that multiple engineers can work on the same robot, at the same time on different areas and not be worried about breaking the other person’s design. The system specification defines how the modules interact in terms of communication speeds/type, the way to alert other modules and how those communications are scheduled. The master controller (shown in the system block diagram in green) schedules all these communications and decides which modules need specific information. Warnings, control signals and user inputs are all calculated and scheduled, then communicated to and from the required modules. A power system doesn’t care that a user has pressed a button to scroll through an LCD screen, and the master controller means it doesn’t see it.

The above video shows how the robot moves with its mecanum wheels, and how it can easy move around environments. I will explain the more technical parts of the project in a later post, but this simple idea became a very heavy hardware based project, rather than the software project it started as. I learnt about mechanical design, PCB design and good techniques associated with electronic design. For these reasons, the robot won the “Best Project” award for 2017. Thank you to: Cubik Innovation for help with electronic design, and providing PCBs, VEX Robotics for donating the wheels, and Altium Designer for providing their electronic design software. I would not have been able to produce the robot I did without them.

How Going To The Moon Kick-started the Silicon Age

In the late 1950’s, there were three people who were at the epicenter of a huge breakthrough in the world of electronics, the invention of the Integrated Circuit (IC). Jack Kilby of Texas Instruments, Kurt Lehovec of Sprague Electric Company, and Robert Noyce of Fairchild Semiconductor. In August 1959, Fairchild Semiconductor Director of R&D, Robert Noyce asked Jay Last to begin development on the first Integrated Circuit. They developed a flip-flop with four transistors and five resistors using a modified Direct Coupled Transistor Logic. Named the type “F” Flip-Flop, the die was etched to fit into a round TO-18 packaged, previously used for transistors. Under the name Micrologic, the “F” type was announced to the public in March 1961 via a press conference in New York and a photograph in LIFE magazine. Then in October, 5 new circuits were released, the type “G” gate function, a half adder, and a half shift register.

The Type F flip flop
Junction-isolated version of the type “F” flip-flop. The die were etched to fit into a round TO-18 transistor package
Type F life image
Physically-isolated Micrologic flip-flop compared to a dime from LIFE magazine March 10, 1961

These first few integrated circuits were relatively slow, and only replaced a handful of components, while being sold for many times the price of a discrete transistor. The only applications that could afford the high prices were Aerospace and Military systems. The low power consumption and small size outweighed the price drawbacks, and allowed for new and more complex designs. In 1961, Jack Kilby’s colleague Harvey Craygon built a “molecular electronic computer” as a demonstration for the US Air Force to show that 587 Texas Instruments IC’s could replace 8,500 discrete components (like transistors and resistors) that performed the same function. In 1961, the most significant use of Fairchild Micrologic devices were in the Apollo Guidance Computer (AGC). It was designed by MIT and used 4,000 type “G” three input NOR gates. Over the Apollo project, over 200,000 units were purchased by NASA. The very early versions were $1000 each ($8000 today) but over the years prices fell to $20-$30 each. The AGC was the largest single user of IC’s through 1965.

apollo guidance computer logic module
Apollo logic module assembled by Raytheon to be used in the AGC
Type G micrologic
Philco Ford also produced the Fairchild Type ‘G’ Micrologic gate for the Apollo Guidance Computer – this is the flat pack verison

Note that although Fairchild designed and owned the type “G” device, they were mostly made by Raytheon and Philco Ford under licence from Fairchild. Over this time many semiconductor manufacturers such as Texas Instruments, Raytheon and Philco Ford were also making large scale silicon production for other military equipment. These included the LGM-30 Minuteman ballistic missiles, and a series of chips for space satellites. This major investment from the government and the military kick started the development of the increasingly complex semiconductor, and eventually forced the prices low enough for non military applications. The processes improved and by the end of the Apollo program, hundreds of transistors could be fitted into an IC, and more complex circuits were being made. Eventually the costs of adding more transistors to a circuit got extremely low, with the difficulty being the quality of manufacturing. It could be argued that NASA and the Pentagon paved the way for silicon device production as we know it today.

Four Bit Carry Adder/Subtractor Circuit

After creating my 1 bit full adder design found in a previous post, I decided to go for something a little more complicated. I wanted to prove to myself that the ripple carry system worked, so the obvious choice is to make a multi bit device. 4 bits seemed like a good amount, it’s a value used in some early ALU’s so it can be used in a future project. To make it more interesting I added in the ability to make the device a Subtractor at the same time. When you look at the schematic, it only requires one more device per adder, so it’s not even an expensive thing to implement, but adds lots of functionality. As with the 1 bit adder, I have attempted to build this adder using only single logic chips.

4 bit adder-subtractor circuit

The first stage is to know the logic circuit, its widely known and can be found pretty easily all over the web. I’m not going to explain how it’s created (I can always make a separate post on that) but I can describe how to use it. The aim is for the device to take two 4 bit inputs (0 – 15), along with a carry from another adder. So the adder needs to be able to output a value between 0 and 31. In binary this can be shown as 5 bits, so we have 2 outputs. This the S output is a 4 bit bus, and the Co output bumps this up to the 5 bits we need to make 31. A truth table can be made for this but it would be 32 lines long, so too much for this post. You could regard it as a personal challenge if you want to attempt it on your own.

So I got onto Altium and made a schematic of this circuit using some of the low voltage 7400 LVC series individual logic gates that I used on the previous adder I made. They come in SOT23-5 packages which are leaded a nice size to solder. Plus they are a size where it’s possible to probe the pins fairly easily. Luckily Altium shows the components as their logic symbols. Below I have shown the first two adders, the third and fourth are basically the same as the second one, which is the idea of the ripple carry adder.

The first two adders of the four found on the board

I also added a few LEDs to show what parts are on and off. This means the user can see the inputs and outputs. These LEDs run off the 5V input voltage, and have 220Ω current limiting resistors in series with them. Also, I have put in some 0.1 inch header pins so it can be attached into a breadboard and maybe even a micro.

The LEDs for the carry bits and outputs
The LEDs for the input bits

As a base of my circuit, I have decided on a double sided 100mm x 100mm board. This is quite big as you can see for the circuit I have made, but gives plenty of space for a soldering iron to get access. As well as this, it gives a nice amount of space for multimeter probes. I also tried to keep the individual logic chips in a similar arrangement as the schematic. This is meant to be used as a learning device, so it’s useful for the chips to line up with the diagram. The header pins for the inputs and outputs are placed on opposite sides of the board to make it more obvious for the user to see it. And the pins have designators written on the board so the user can see what each pin does. The input and output busses are placed in fairly logical places, and grouped together. There is no point having all the A inputs intertwined with the B inputs. The pins for the power and ground are on opposite sides with their own headers, only one needs to be connected for it to work. The LEDs that are directly attached to the pins are placed closer to the logic circuitry, but labeled clearly on the silkscreen. Most of the routing to the LEDs is on the underside of the board, else the top could get confusing. All the designators for components have been made half the normal size due to the small amount of parts used in the project. The below images show the PCB layout I created with the top copper being red, bottom copper being blue, and the silkscreen shown in yellow.

Top Copper

As you might be able to see, I have tried to keep all the power on the bottom side of the board. This leaves lots of space for the logic signals on the top, where the user is more likely to see. As you can see, most of the inputs and outputs of the circuit are also on the bottom side. This is because the way the busses work and input into the adder needs lots of crossing over and would add confusion into the design. This is why labels were used instead.

Bottom Copper

To make it easier to see, I made a larger image of the first and last adder in the series. As you can see, the only real difference in them is that the first has the add/subtract input shown by an LED, whereas the last shows the carry from the previous adder (C0). This is because the A/D bit is attached to all the adders, but the first bit doesn’t have a carry bit input. The carry on that adder is the input for the A/S. It serves the function of inverting the first bit, so that it works like 2’s complement when in subtract mode.

The layout of the first adder in the series
The layout of the last adder in the series

As noted above I used 7400 LVC series logic gates. The SOT23-5 package chips have the suffix of “BVD”. See the datasheets for each of the devices for more information. I have written a simple bill of materials below:

12x SN74LVC1G86DBVT – XOR gate
8x SN74LVC1G08DBVT – AND gate
4x SN74LVC1G32DBVT – OR gate
17x DO-214 LED’s
17x 0805 220Ω resistors
6x 5-pin 0.1″ header pins

The main downside to this type of adder is that is is very slow. Especially when you get to high bit amounts that you are trying to add. This adder will take at least 4 times as long as a single adder to add the two numbers together because the signal has to propage through 4 full adders. This problem is known as propagation delay, each logic chip will take a very short time to compute the output. Although this time is not perceivable by the human eye, if there are 100’s of logic gates in a row, then the delays start to add up and be a problem. If this circuit is to be used in a computer, it could need to make calculations thousands, or maybe millions of times a second, and a carry bit adder is not generally good at that. There are other, faster adders that I will show in a future post.

One Bit Adder Project

One thing that has always been interesting to me is using logic circuitry in electronics. It’s easy to implement something on a microcontroller in just a few lines of code, but the real challenge comes from making a boolean project using real logic gates. It’s something we all learn about if you have taken a basic computer science class, or even digital electronics. One of the first circuits you ever learn about is the adder. It’s pretty simple, teaches you how to cancel down boolean equations, and only has a few inputs and outputs. I have decided to try and make the circuit using real components, and see if I can get it to work.

full adder layout

The first stage is to know the logic circuit, its widely known and can be found pretty easily all over the web. I’m not going to explain how it’s created (I can always make a separate post on that) but I can describe how to use it. The aim is for the device to take two 1 bit inputs, along with a carry from another adder. So the adder needs to be able to output a value between 0 and 3. In binary this can be shown as 2 bits, so we have 2 outputs. The S output represents bit 1, and the Co output represents bit 2. Below is the truth table I used, if you want a little challenge, try and get the above circuit using boolean algebra.

A B Ci Co S
0 0 0 0 0
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1

So I got onto Altium and made a schematic of this circuit using some of the low voltage 7400 LVC series individual logic gates. They come in SOT23-5 packages which are leaded and a nice size to solder. Plus they are a size where it’s possible to probe the pins fairly easily. Luckily Altium shows the components as their logic symbols.

1 bit adder 1 schematic

I also added a few LEDs to show what parts are on and off. This means the user can see the inputs and outputs. These LEDs run off the 5V input voltage, and have 220Ω current limiting resistors in series with them. Also, I have put in some 0.1 inch header pins so it can be attached into a breadboard and maybe even a micro.

1 bit adder 1 schematic

As a base of my circuit, I have decided on a double sided 50mm x 50mm board. This is quite big as you can see for the circuit I have made, but gives plenty of space for a soldering iron to get access. As well as this, it gives a nice amount of space for multimeter probes. I also tried to keep the individual logic chips in the same arrangement as the schematic. This is meant to be used as a learning device, so it’s useful for the chips to line up with the diagram. The header pins for the inputs and outputs are placed on opposite sides of the board to make it more obvious for the user to see it. The pins for the power and ground are on the same side on both headers. The LEDs that are directly attached to the pins are kept close to them, and the track is fairly obvious to show where the signal is from. The silkscreen labels which LED designates which input/output. All the designators have been made half the normal size due to the small amount of parts used in the project. The below images show the PCB layout I created with the top copper being red, bottom copper being blue, and the silkscreen shown in yellow.

1 bit adder 1 PCB top

As you might be able to see, I have tried to keep all the power on the bottom side of the board. This leaves lots of space for the logic signals on the top, where the user is more likely to see. As you can see, not all signals are on the top side due to circuit constraints, but signals that do swap over are generally short jump, and straight lines, This makes it more obvious where the tracks go without having to flip the board.

1 bit adder 1 PCB bottom

As noted above I used 7400 LVC series logic gates. The SOT23-5 package chips have the suffix of “BVD”. See the datasheets for each of the devices for more information. I have written a simple bill of materials below:

2x SN74LVC1G86DBVT – XOR gate
2x SN74LVC1G08DBVT – AND gate
1x SN74LVC1G32DBVT – OR gate
5x DO-214 LED’s
5x 0805 220Ω resistors
2x 5-pin 0.1″ header pins

How a Voltage Regulator Works: LM7805

Voltage regulators are one of the first electronic components you get introduced to as a hobbyist. Really useful when starting out, it simply takes a voltage that is too high, and reduces it down to a set voltage that you want, usually defined by the component. Solves the problem of having batteries or power supplies being a different voltage to the thing you are powering (such as your Arduino), and at as little as 50p from ebay they are easily acquired. Sounds like a great solution, but there is an issue, they are terribly inefficient. They are known to get very hot when used at high currents, and often need hefty heatsinks to stop the magic smoke from being released. To demonstrate why they get so hot we need to think about what happens during use. Remembering Kirchoff, the current going into a system is the same as the current going out of the system. If we use a simplified version of the regulator, the only thing this device changes is the voltage of the output. Due to the minimal current lost powering the circuit we assume the vast majority of power lost is in heat. Using the basic equation of:

Power (W) = Voltage (V) x Current (I)

So if we use an example of the LM7805 made by On Semiconductor (previously Fairchild) that can regulate 5V at 1A. It’s a pretty standard component, and is very typical of a voltage regulator.

If we use a 9V input the power going in is 9V x 1A = 9W.

The output power is 5V x 1A = 5W.

This means that there is 4W of power being dissipated from the regulator as wasted heat. This is a large amount when considering the size of the packages available. When thinking about problems excessive heat can cause in a circuit, it can quite easily damage itself and other components around it when not designed properly. It is why there are often big chunks of aluminium attached to the back of the components to act as a heat sink.

7805
7805 chip in a TO-220 package. Notice the heat sink on the rear with a screw mount.

This post isnt meant to dissuade you from using regulators, they have their place in electronic circuits, and are a great starting point. All electronic engineers need to have a broad understanding of the advantages and disadvantages of linear voltage regulators to be able to handle them properly.

How it Works

LM78xx schematic 2 coloured
Schematic of the silicon inside an LM78xx device, coloured relating to the function of each area.

The above schematic can be found on the datasheet, but it’s been coloured in to show the different sections of the circuit.

The most important component in the above schematic is Q16 (Red), it controls the current between the input and output, therefore the voltage. It is placed in a darlington pair configuration with Q15 (Orange). In this configuration Q16 is amplifying the current amplified by Q15. This means that Q15 can be used to introduce error feedback. The Blue section contains a voltage divider that scales the output voltage so that it can be used by the bandgap circuit. This bandgap circuit is found in the yellow section (Q1 and Q6). This bandgap reference produces an error signal that is fed into Q7 (orange). A bandgap is used because it can provide a stable output even when the temperature of the device changes.

The orange section takes this error and amplifies it through Q15 and the darlington configuration described earlier. The purple section has overheating protection (Q13) and excessive output current protection (Q14). Occasionally on these schematics you also find excessive input voltage protection marked as Q19 in this section. These shutdown the regulator in fault conditions like overcurrent or getting too hot. The Green section is known as the “start up” circuit, because it provides the initial current needed to power the bandgap circuitry. This gives a jumpstart to the circuit when it needs it.

I chose the LM7805 because 5V is a common value to be used, but the LM78xx series has many different preset voltage versions. The bandgap circuit is trying to get its input to 1.25V, this is from the voltage divider found in the blue section. As R20 is a variable resistor, the voltage divider can be calibrated during manufacture to output exactly 1.25V at any chosen output voltage. This is great for a manufacturer because they make lots of the same chip, and it can be made to suit any voltage output they want. This is also similar to the way some adjustable voltage regulators work, such as the LM317. In adjustable chips, the voltage divider is made by the designer externally, meaning it can be applied to any situation with a simple change of resistors.

Basic Configuration

Looking at the datasheet, there are many applications for the device. but the simplest one is just an input and an output. All that’s needed is a couple of decoupling capacitors to smooth out AC signals and random noise. Voltage regulators work best with clean, smooth power. There is also the need, due to the voltage drop across the transistors, for the input voltage to be at least 2V above the required output. This is always a good rule of thumb to go by when it comes to regulators.

LM78xx basic configuration
LM78xx basic configuration

I would recommend people read the datasheet and have a play with different voltage inputs and current outputs, see how easy it is for it to get hot. In that datasheet there are some other good applications using the device, you can turn it into an adjustable voltage output, constant current supply and high current supply. These are also good projects for learning more about transistors and op amps. Equally, there are other types and brands of regulator out there, some cheap, and some quite expensive, it is worth shopping around for  the ones that suit you.

Interfacing a PIC and a 16×2 LCD

So in a recent project I had to implement a 16×2 LCD  on a PIC16F1827, but the system will work on most PIC microcontrollers, with slight changes to the code. For this project I am using MPLAB X v3.40, a free development environment, and a PICKIT 3, which can be bought at a number of stores online.

Setting up the MPLAB project

  1. Start off by loading up MPLAB X, if you don’t have it already, install it from the Microchip website microchip.com/mplab/mplab-x-ide.
  2. Start a new project, by going to File->New Project… or by pressing Ctrl+Shift+Nnew project
  3. The project we want is a standalone project, it should be chosen by default. Next choose the device we want, write in the box PIC16F1827 there should only be one. We want to use the PicKit 3 for the programmer. I am using XC8 as the compiler, this is available from the Microchip to9 stawebsite. Finally choose the name of the project, and where you want to keep it. Then click finish.
  4. It wont look like mush at the moment, but under Projects on the right, there should now be your newly created project, with a drop down, and a set of folders. Something like this: 
  5. To start the project, we need a main.c. So right click on Source Files, go to New->C Main File… then in the Dialog, change the name to main. After pressing okay, it should look like this: 

Connecting the LCD

LCDs have what is known as a parallel connection. This means that we send data 8 bits at a time, rather than serial where it is one at a time. The datasheet for the PIC is found on the microchip website here. The pinout is found on page 4.

PIC pinout

Register Select (RS) pin, this decides which of the two registers that is getting written to. Either the instruction register (what the screen does) or the data register (what is shown on the screen). This is connected to A4 on the PIC.

Read/Write (RW) pin, this decides whether you are writing to or reading from the LCD. This is connected to pin A3.

Enable (E) pin, is to tell the LCD when data needs to be transferred. Pulsing this pin will write or read to the registers the data on the data pins. This is connected to pin  A2.

These pins are defined at the top of the code, to make life easier for us later on.

#define LCD_RS LATAbits.LATA4   //LCD Command/Data Control
#define LCD_RW LATAbits.LATA3   //LCD Read/Write Select
#define LCD_E LATAbits.LATA2    //LCD Enable Line

Data Pins (D0-D7), are the pins that transfer the information between the LCD and the PIC. These are connected to pins B0-B7. So B0 is connected to D0, and so on until B7 is connected to D7.

Vdd and Vss are connected to 5v and GND respectively.

Contrast (Vo) is connected to a 10k pot between the 5v  and  GND.

If the LCD you are using has connections for a backlight, follow the datasheet for instructions, on mine I connect it t0 5v and GND.

The Code

Below is the function I create to send data to the LCD.

#define LCD_CMD 0
#define LCD_TXT 1 

void LCD_DATA (unsigned char data, int type)
{
    __delay_ms(100);   // short delay

    LATB = 0x00;       // reset the register to 0
    LATB = data;       // set B output to the data we want to send
    __delay_ms(1);     // short delay for data to set

    if (type == LCD_CMD)
    {
        LCD_RS = 0;    // command mode
    }
    else
    {
        LCD_RS = 1;    // character/data mode
    }

    LCD_RW = 0;        // start the pulse
    __delay_ms(1);     // small delay
    LCD_E = 1;         // enable LCD data line
    __delay_ms(1);     // small delay
    LCD_E = 0;         // disable LCD data line
    __delay_ms(5);
}

Calling this function in the main, like follows will send data to the LCD. Notice the #define at the top, these are declaring LCD_CMD and LCD_TXT. Basically, when the type is LCD_CMD the LCD is sent into command mode, by setting the RS pin. Equally, sending LCD_TXT will clear the RS pin, putting the LCD in character mode.

The information on the data pins will then get written to the LCD, by clearing RW. To actually tell the LCD that it needs to be sent new instructions the enable pin needs to be pulsed. Once this happens, the screen should be updated with the new information.

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>

#define _XTAL_FREQ 500000

#define LCD_RS LATAbits.LATA4   //LCD Command/Data Control
#define LCD_RW LATAbits.LATA3   //LCD Read/Write Select
#define LCD_E LATAbits.LATA2    //LCD Enable Line

#define LCD_CMD 0
#define LCD_TXT 1 

void LCD_DATA (unsigned char data, int type)
{
    __delay_ms(100);   // short delay

    LATB = 0x00;       // reset the register to 0
    LATB = data;       // set B output to the data we want to send
    __delay_ms(1);     // short delay for data to set

    if (type == LCD_CMD)
    {
        LCD_RS = 0;    // command mode
    }
    else
    {
        LCD_RS = 1;    // character/data mode
    }

    LCD_RW = 0;        // start the pulse
    __delay_ms(1);     // small delay
    LCD_E = 1;         // enable LCD data line
    __delay_ms(1);     // small delay
    LCD_E = 0;         // disable LCD data line
    __delay_ms(5);
}


int main(int argc, char** argv) {
 
    // write "hello world!" on the first line
    LCD_DATA('h', LCD_TXT);
    LCD_DATA('e', LCD_TXT);
    LCD_DATA('l', LCD_TXT);
    LCD_DATA('l', LCD_TXT);
    LCD_DATA('o', LCD_TXT);
    LCD_DATA(' ', LCD_TXT);
    LCD_DATA('w', LCD_TXT);
    LCD_DATA('o', LCD_TXT);
    LCD_DATA('r', LCD_TXT);
    LCD_DATA('l', LCD_TXT);
    LCD_DATA('d', LCD_TXT);
    LCD_DATA('!', LCD_TXT);
 
    while (1)
    {
 
    }
 
 return (EXIT_SUCCESS);
}

Current Sensing: High Side vs. Low Side

Occasionally, you will be designing an electronic project, and there will be a need to to measure the current being drawn by a particular section, or  even the whole thing. When designing, prototyping, or even testing the design you can use a calibrated multimeter. In the field though, or inside a real product, how can you monitor current.

A very popular way is to use a very low value power resistor in series with the load you want to measure. As current flows through it it will induce an e.m.f (voltage) across the resistor. This resistor voltage can then be measured by an ADC in a microcontroller. The value will be linearly proportional to the current running through it. Using Ohm’s law you can deduce that the voltage across the the resistor is equal to the currentresistance. As the resistor may be slightly off, the device might need calibration.

An issue with this though, you want the minimum voltage drop possible across the resistor. This reduces power loss, and minimises the effect you will have on the load. For this reason a very small resistor needs to be used. There are plenty of resistors out there for this purpose, known as shunt or sense resistors. This tiny voltage could be as small as 0.1v, or maybe even lower, way too small for a standard ADC to pick up reliably. For this reason There is a need for an amplifier, to multiply this voltage by 20 or 50 times. This enables the swing to be measured across the range of the ADC. So if you have a 5v ADC, and the maximum voltage across the resistor will be 0.1v, the amplifier will need to have a gain of 50. There are two main categories of current sensors like this, High side and Low side.

schematics-project-1

The above image shows the basic configuration of these two types of measurement. The difference is based off on the location of the sense resistor. Low side sensing is between load and ground, with high side sensing between power and the load. It shouldn’t make much difference, the voltage across the Sense resistor will always be the same.

One reason for not using the the low side method is for the fact it is based off the ground reference. If anything between the power and the high side of the load is shorted, the current sensor wont pick it up. It is just one thing thing that you can’t then implement into your design.

Also be careful when choosing the amplifier and the resistors you intend to use. There are many amplifiers on the market designed for this specific purpose. The TSC101 is an amplifier I recently included in a project, for this exact purpose. A high side current sensor, with a precision trimmed preset gain of either 20, 50, or 100. Adding in a laser precision trimmed power resistor to this, and there is an output for a microcontroller, a very simple current sensing application. for less than £2 in your application.