Embedded Developer

Currently taking a few weeks break and after a few days away from the computer I decided to do a little bit of research into the PicoW and NuttX. So time for a quick attempt at getting the system up and running.

I have for the last few years been working on the Meadow F7 board for Wilderness Labs. This board aims to provide a full .NET development environment bringing embedded development to a wider audience. There are three main technologies underpinning this board:

• Mono
• Nuttx
• FreeRTOS

I spend much of my time working with NuttX and FreeRTOS so as you can gather, I’m not worried about working with C or C++. This gives a few options for working with the board:

• Native development using the Pico SDK
• NuttX
• FreeRTOS

I decided to start with a look at NuttX as I am currently spending a lot of time working with this RTOS.

Let’s Follow the Guide

First thing to do is head over the the documentation for NuttX on the RP2040. The getting started guide is really good and I thought I would be able to use the copy of the Pico SDK I had already on my machine.

This is where I hit my first problem. NuttX requires a specific version of the Pico SDk and using this version would impact any other Pico development that I would undertake in the future. To overcome this I decided to take a second copy of the Pico SDK specifically for use when developing with NuttX.

Having said we would follow the guide, we are deviating already.

So first up we create a development environment for the PicoW (all instructions are for working on a Mac but should also work on Linux).

mkdir NuttX-PicoW
cd NuttX-PicoW
git clone -b 1.1.2 https://github.com/raspberrypi/pico-sdk.git
export PICO_SDK_PATH=$PWD/pico-sdk

Now we need to clone the NuttX OS and applications repositories:

git clone https://github.com/apache/nuttx.git nuttx
git clone https://github.com/apache/nuttx-apps.git apps
cd nuttx

Now we have the NuttX components cloned we need to make sure we are on the current releases. This is done using git to checkout the correct branches. At the time of writing the current release is 12.1 so the following commands will checkout the correct branches:

cd apps
git checkout releases/12.1
cd ../nuttx
git checkout releases/12.1

Now we have the correct branches we need to configure the system to work with the PicoW. There are several different boards and configurations available using the RP2040, not just the pico. The following command will list all of the available board configurations available for the Pico series of boards (not just the PicoW but all of the Pico boards):

./tools/configure.sh -L | grep pico

For NuttX 12.1 this returns the following list:

raspberrypi-pico:lcd1602
raspberrypi-pico:waveshare-lcd-1.3
raspberrypi-pico:usbmsc
raspberrypi-pico:nshsram
raspberrypi-pico:nsh-flash
raspberrypi-pico:nsh
raspberrypi-pico:audiopack
raspberrypi-pico:composite
raspberrypi-pico:st7735
raspberrypi-pico:displaypack
raspberrypi-pico:spisd
raspberrypi-pico:smp
raspberrypi-pico:enc28j60
raspberrypi-pico:ssd1306
raspberrypi-pico:usbnsh
raspberrypi-pico:waveshare-lcd-1.14
raspberrypi-PicoW:lcd1602
raspberrypi-PicoW:waveshare-lcd-1.3
raspberrypi-PicoW:usbmsc
raspberrypi-PicoW:nshsram
raspberrypi-PicoW:nsh-flash
raspberrypi-PicoW:nsh
raspberrypi-PicoW:audiopack
raspberrypi-PicoW:composite
raspberrypi-PicoW:st7735
raspberrypi-PicoW:displaypack
raspberrypi-PicoW:spisd
raspberrypi-PicoW:smp
raspberrypi-PicoW:enc28j60
raspberrypi-PicoW:ssd1306
raspberrypi-PicoW:usbnsh
raspberrypi-PicoW:waveshare-lcd-1.14
raspberrypi-PicoW:telnet

The configuration that is interesting here (to get started) is the raspberrypi-PicoW:usbnsh configuration. This will redirect the console output from NuttX over USB to the host machine using serial communication. This will allow a simple terminal application to connect to the board without the need for any additional hardware. So let’s configure NuttX and build the system.

First up, clean the system and set the configuration:

make distclean
./tools/configure.sh -l raspberrypi-PicoW:usbnsh

This should clear any previous configurations (distclean) and then set the board type and specific configuration to be built.

Now we should be able to build the system.

make

You can also tell make to use as many cores on your system as possible with the command make -j. After a short time the system will compile the NuttX OS and applications and create a UF2 file that can be uploaded to the PicoW.

The board can be programmed by starting the board in bootloader mode (press and hold the BOOTSEL button while plugging in the USB cable). The Pico should now present itself as a USB drive on the host computer. Drag and drop the nuttx.uf2 file onto the Raspberry Pi Pico drive on the host computer. The file will be copied to the board and the board will restart.

Connecting to NuttX

Time to check that the board has been programmed correctly. Open your favourite terminal application and set your connection settings to 115200,n,8,1 and connect to the serial port presented by the PicoW. The default is something like usbmodem01. Connect to the PicoW and hit enter a couple of times. On doing this you should be presented with something like this:


NuttShell (NSH) NuttX-12.1.0
nsh>
nsh>


If you have got this far then you have successfully built NuttX and deployed the OS to the PicoW. Typying help in the serial console should reveal the list of deployed applications.

Conclusion

At this point we have NuttX running on the PicoW. This opens up some new channels for investigation:

• Using both cores on NuttX
• C++ application development

In the next post we will look at enabling C++ development in NuttX.

Threaded insert in pillar

Way back in 2019, Hackaday posted an article on Threading 3D Printed Parts: How to Use Heat-set Inserts which discussed how to use brass inserts in 3D printed parts to make connecting parts easier and more robust. The article presented the changes you should make to prints in order to make adding the inserts easier to locate and some of the tools that could be purchased to make using these inserts easier.

I have been using these type of inserts for a few years now and this month came up with a slight variation on the method discussed in the above article. The process of laying out the part remains the same, the change made is to the method of fixing the brass threaded insert into the 3D printed part.

The original article discussed using special tools for heating the threaded insert and pushing the heated part into the 3D printed model. This article presents an alternative to a specialist part by using nothing more than some scrap protoboard. The beauty of this technique is that it does not require any special tools.

Requirement

I regularly use a number of different microcontroller development boards and debug probes for firmware development. These boards commonly have components on the bottom of the boards and / or through hole parts where the legs of the components protrude through the board and potentially damage desks / work surfaces.

A 3D printed mount or frame keeps any components away from work surfaces protecting them from scratches and also reduces the possibility of shorting components on the boards themselves.

The process will be illustrated with a Spresense board and external adapter.

The technique should meet the following requirements:

• Use tools that any maker should have in their workshop
• Present a flat surface around the insert
• Keeps tools clear of any melted material

3D Design

The external Spresense adapter board has four mounting holes and the intention is to use two of the holes to acts as locators and two holes to fix the board in place. The mount will have four pillars under the holes in the external adapter board. Two of these will have printed pins to act as locators. Two of the pillars will use threaded inserts to allow screws to fix the board in place. A picture is worth a thousand words so here is how the final design looks:

Fusion 360 design for Spresense mount

Adding the Threaded Insert

The starting point of the process is the 3D printed frame with the objective of embedding the threaded insert securely into the printed part. The pillar is a simple cylinder with a hole running through to the base of the frame.

Pillar on mount

The first step is to prepare the threaded insert for insertion into the frame. This is done by using a screw matching the insert mating the two through a piece of protoboard:

Threaded insert on protoboard

Next up, the insert in placed in the hole in the pillar and the protoboard is used to hold the insert in place. The tip of a hot soldering iron is placed on the head of the screw and a slight pressure is applied using the protoboard:

Adding threaded insert (stage 1)

Continue applying pressure using the protoboard as the part sinks into the 3D printed part:

Adding threaded insert (stage 2)

By continuing to apply pressure, the protoboard will finally hit the top of the pillar. At which point remove the soldering iron and hold the protoboard in place for a few seconds. This will allow the PLA to set around the insert.

Adding threaded insert (stage 3)

Finally, remove the screw from the board to reveal the insert which should now be firmly embedded into the pillar.

Threaded insert in pillar

Conclusion

The technique presented uses simple tools which are available in many makers workshops or are relatively cheap to purchase. It achieves the objectives set out earlier in this post as well as those in the original Hackaday article.

Finally, here is the assembled board and mount.

Spresense external carrier board on mount

The first post about the NE555 presented the theory of operation of the NE555 using an astable clock circuit. This circuit is the basis of a simple low frequency (by todays standards) digital clock or PWM circuit. A clock can be used to synchronise the various components in a digit circuit and PWM is useful in circuits for such things as light (LED) brightness.

This post will look at how the circuit in the first post can be modified to provide a variable clock for a digital circuit. A variable clock can prove useful when debugging a digital circuit.

Basic Astable Circuit

A simple astable circuit looks something like the following:

Astable Logical Layout

The two resistors R₁, R₂ and the capacitor control the timing and characteristics of the pulses seen on the output pin of the NE555.

Timing Calculations

The timing calculations given in the data sheet for the NE555 are as follows.

Note that in the following calculations, resistance is expressed on Ohms, capacitance in Farads and time in seconds.

Charge Time

The charge time depends upon the capacitor and the two resistors R₁ and R₂ as current flows through the two resistors to charge the capacitor. The time taken to charge is given as:

t_charge = 0.693 * (R₁ + R₂) * C

Discharge Time

The discharge time is only dependent upon the capacitor and R₂ as current does not flow through R₁ when the circuit is discharging. The time take to discharge is given as:

t_discharge = 0.693 * R₂ * C

Period

The period is the sum of the two timings t_charge and t_discharge. This can be expressed as:

Period = 0.693 * (R₁ + (2 * R₂)) * C

Frequency

The frequency of a signal is defined as ¹/_Period. The period of a signal from an astable NE555 is:

Frequency = 1.44 / ((R₁ + 2 * R₂) * C)

Duty Cycle

The duty cycle of a signal is the percentage of time the signal is high compared to the period of the signal. Thus the duty cycle is given by the following formula:

Duty Cycle (%) = 100 * (R₁ + R₂) / (R₁ + 2 * R₂)

Fixed Clock

A fixed clock can be set up easily by changing one or more of the two resistors R₁, R₂ or the capacitor and a simple spreadsheet will allow you to calculate the circuit characteristics. Doing this allows for the creation of a low (by modern standards) frequency clock quickly and cheaply.

Variable Clock

A variable clock can be useful in debugging digital circuits. The ability to slow the speed of the system can allow the system to be probed easily while maintaining the ability to run the circuit using a free running clock.

As with a fixed clock, the clock characteristics can be changed by varying the value of one or more of R₁, R₂ or the capacitor.

Variable capacitors and resistors are both available but variable resistors (potentiometers) are more readily available to the hobbyist and so we will follow this option.

This gives two options, changing R₁ or R₂. Looking at the calculations above it is clear that R2 has the most impact on virtually every operating characteristic of the NE555 and is the only one that can influence the discharge time.

Looking at the t_discharge formula:

t_discharge = 0.693 * R₂ * C

the discharge time could theoretically be reduced to zero if R₂was allowed to approach 0 Ohms. This can be prevented by replacing R₂ with a combination of a fixed value resistor and a potentiometer. The fixed resistor provides for a lower limit for the discharge time of the capacitor.

A quick spreadsheet shows how the circuit will behave as R₂ and C are varied:

NE555 Calculations

From the results above it looks like a minimum value for R₂ of 1 KOhm and a maximum of 100 KOhm would give a reasonable frequency for a low speed clock.

Schematic

Lowering the value of R₂ 1 KOhm and adding a 100 KOhm potentiometer results in the following schematic:

Variable Speed Clock Schematic

The value of the fixed resistor and the potentiometer gives a range of 1 KOhm to 101 KOhm. The additional 1 KOhm of resistance should not impact the frequency too much when the potentiometer is set to its maximum resistance as the calculation is dominated by the 100 KOhm potentiometer.

So that is the theory, how does this work in practice?

Potentiometer Set to 0 Ohms

If we set the potentiometer to 0 Ohms then according to the calculations above, the frequency should be about 48 KHz. The output on the oscilloscope is:

Potentiometer set to 0 Ohm

Potentiometer Set to 100 KOhms

Changing the potentiometer to 100 KOhms we should get a frequency of 712 Hz. The output on the oscilloscope is:

Oscilloscope output when potentiometer set to 100 KOhm

And Somewhere in the Middle

By slowly changing the resistance of the potentiometer we can achieve a steady slow clock of approximately 1 kHz:

NE555 generating a 1 KHz signal

Conclusion

Clocks provide the heartbeat of most digital circuits, computers certainly require a regular pulse to synchronise the various components in the circuit. The NE555 provides a simple way to generate a variable clock albeit at low frequencies.

The output on the oscilloscope varies from the ideal values given by the calculations. This can be explained by the variations in the tolerances of the various components in the circuits and from the capacitance of the breadboard itself.

It is essential that when a computer (or any other electrical device) starts, that it starts in a known good state. For a computer, this is accomplished with a power on reset circuit. This circuit is responsible for holding the various reset signals in a known state for a defined period of time when power is applied. Some computers also utilise a reset switch to manually trigger this same reset process.

This post will look at a simple reset circuit from the 1980s using the NE555 timer.

Requirements

The circuit under consideration should perform the tasks:

1. Provide two reset signals, one high (Reset) and one low (Reset).
2. Hold the reset lines in a known state when power is applied.
3. Provide a manual reset facility.

All of the above can be achieved using a modified monostable NE555 circuit.

Schematic

The modified schematic for the monostable circuit looks like this:

NE555 Reset Circuit Schematic

The basic theory of this circuit is that a low pulse on the trigger pin generates a single shot pulse on the output pin of the NE555.

The resistor and capacitor in the right-hand part of the circuit form a standard monostable configuration. This circuit is taken from the NE555 datasheet. Using the formula in the datasheet, the period of the stable, high pulse on the output is given by the formula:

Period = 1.1 * R * C

Using the values in the circuit, R = 47K and C = 10uF. Plugging these values into the equation we find that the period of the stable pulse is 0.517 seconds.

The inverter provided by the 74LS04 allows for the generation of both a high and a low (Reset and Reset) signals from the circuit.

The resistor and capacitor on the left hand side of the circuit debounce the switch connected to the trigger of the circuit. They also hold the trigger under the 1.67V threshold for a short period of time following startup. This provides the power on reset element of the circuit.

This circuit can also be viewed using the logical layout discussed in the previous aricle on the theory of operation:

NE555 Logical Layout

Implementation

Putting the above circuit together on breadboard gives something like the following:

NE555 Reset Circuit on Breadboard

Observations

In the following, all images from the oscilloscope will show the NE555 output in yellow and where present, the signal on the trigger pin will be in blue.

At startup, it is expected that there should be a short (500ms approx) signal on the output pin of the NE555.

NE555 Power on Reset Oscilloscope Output

So far, so good. The next requirement is to allow the user to manually reset the system. This is done using the switch connected to the trigger pin on the NE555. Pressing the button shows the following on the oscilloscope:

NE555 Reset Circuit Short Button Press

The short press on the button generates the required reset pulse on the output pin of the NE555.

The datasheet for the NE555 warns against holding the trigger pin low for a period of time longer than the duration of the output pulse. So in this case, the trigger pin should not be held low for longer than 517ms. This could be a problem as it is easy to exceed this period in normal use. So what happens if the trigger pin is held low for an extended period of time? Changing the scale on the oscilloscope to 250ms per division and we see the following:

NE555 Reset Circuit Multiple Button Presses on Oscilloscope

The leftmost pulse is the result of a short press of the button. As expected, the output of the NE555 goes high for 517ms.

The middle pulse shows what happens when the button is pressed and held for an extended period of time. In this case, the button was pressed for about 2s. As you can see, the reset pulse remains high for the duration of the button press and then returns low.

The rightmost pulse shows what happens when the switch is pressed once more for a short period. As you can see, the NE555 returns to its normal mode of operation and generates a 517ms pulse.

Conclusion

The NE555 really does deserve it’s reputation as a versatile chip. This simple circuit provides a digital circuit with the ability to start in a known state by providing a reset pulse when power is applied to the system. It also provides a mechanism for resetting a system on demand using a switch connected to the trigger pin.

And now for a piece of history, circuits such as this appeared in many of the early 8-bit computers from the 1980s.

Oscilloscope Trace

Ohhhh no, not another post about the NE555 timer! I’m sorry to say, yes, this is another article (or two) about the NE555, how it works and some applications.

I blog for two main reasons:

• As an aide-memoire
• Hopefully others will find these posts useful

So this first post will cover the theory behind the operation of the NE555 using the astable circuit as an example.

Logical Layout of the NE555

The NE555 has four logical units and they can be viewed logically in the following layout:

NE555 Logical Layout

These logical units are:

1. Resistor ladder
2. Two comparators
3. S-R latch
4. Discharge circuit

These components allow the engineering of a wide number of circuits using this versatile chip. This series of articles will cover four applications:

• Astable circuit (a.k.a a clock)
• Reset circuit
• Button debouncing a push switch
• Button debouncing with selection (i.e. latching switch)

Let’s start with looking at the four logical components identified above.

Resistor Ladder

Resistor Ladder

The resistor ladder in the original chip used 5K resistors. The use of three equal value resistors supply ¹/₃ * V_cc and ²/₃ * V_cc to the two comparators.

Comparators

Comparators

The two comparators compare two of the input voltages to the two values from the resistor ladder, namely, ¹/₃ * V_cc and ²/₃ * V_cc. They output a high value if the voltage on the positive input is greater than the voltage on the negative input.

The top comparator has the negative input connected to ²/₃ * V_cc and the positive input connected to the threshold pin. This comparator will out a high value when the threshold is greater than ²/₃ * V_cc and a low value at all other times.

The lower comparator has the negative input connected to ¹/₃ * V_cc and the positive input connected to the trigger input. This comparator will output a high value when the trigger is less than ¹/₃ * V_cc and a low value at all other times.

S-R Latch

S-R Latch

The S-R latch uses the output from the two comparators to determine if the output of the NE555 should be turned on or off. The inverted output from the latch (Q) is connected to the output pin of the NE555 through an invertor.

Q is also connected to the base of the transistor connected to the discharge pin.

Discharge Circuit

Discharge Circuit

The discharge pin is connected to ground through a transistor. The base of the transistor is connected to the inverted output of the S-R latch. So the discharge pin is connected to ground when the S-R latch is in the reset state.

So How Does it Work?

An astable circuit can be used to understand how the various components of the NE555 work together and it is this circuit we will examine next.

Astable Circuit

One of the circuits that can be constructed using the NE555 is a low frequency PWM circuit, known in NE555 parlance as an astable circuit. This can be used in a wide variety of applications from flashing LEDs to the provision of a low frequency clock signal for a digital circuit.

An simple astable circuit can be constructed using two resistors, a capacitor and the NE555 chip. Using the above logical diagram as a starting point we would connect the additional components as follows:

Astable Logical Layout

The reset pin should be connected to V_cc and the control pin should be connected to ground through a 100nF or 10nF capacitor.

The operation of the astable circuit will be consider by progressing through time from the point that power is applied to the circuit. It is assumed that V_cc is equal to 5V. The makes the nominal values for ¹/₃ * V_cc = 1.67V and ²/₃ * V_cc = 3.3V.

Power On

Capacitor starts to charge

At the point where the chip starts the resistor network inside the NE555 will split V_cc into two as noted above. These will appear on the two comparators negative (for comparator 1) and positive (for comparator 2) inputs.

At the same time, the capacitor C will be charged through resistors R₁ and R₂. At the point shortly after power up there will be very little charge on the capacitor, for argument, let us say that this is 0V. This will place 0V on both the trigger and threshold pins of the NE555.

Comparator 1 will compare the voltage on the trigger pin (negative input) to 1.67V (positive input). As 0V is less than 1.67V this will result in a high output from comparator 1. This high output is applied to the set pin of the S-R latch. Following this through, this will turn the Q output on and the inverted Q output off.

Q output drives both base of the transistor connected to the discharge pin, turning the transistor off and the output pin through the invertor, turning the output on.

Comparator 2 is comparing positive input connected to the charge on the capacitor (currently 0V) to 3.3V. Following this through as we did with comparator 1, 0V is not grester than 3.3V and so comparator 2 outputs a low signal. The low signal on the reset input in the S-R latch has no effect on the output from the S-R latch.

So shortly after power on, comparator 1 has turned the output of the NE555 on and capacitor C is charging. The various parts of the circuit have the inputs and outputs set to the values in the diagram above marked in red.

Capacitor Charge Reaches 1.67V

As time progresses, the charge on the capacitor will reach and then exceed 1.67V. The circuit will look like the following:

Capacitor continues to charge

At this point a change will occur to comparator 1. The negative input voltage (from the trigger pin) will reach 1.67V. The voltage on the negative input to the comparator will no longer be greater than 1.67V and so the output of the comparator will change from high (on) to low (off). The low signal applied to the set input of the S-R latch will have no effect on the S-R latch (both set and reset inputs to the S-R latch are now low and so the previous state is remembered).

At this point there is no change to the output of the circuit, the output is still latched on and charge continues to build up on the capacitor.

Capacitor Charge Reaches 3.33V

Eventually the charge on the capacitor will reach and exceed 3.33V. This will change the circuit to the following state:

Capacitor starts to discharge

There will be no change to the output of comparator 1 as the voltage applied to the negative input of the comparator remains greater than 1.67V just as it was in the above stage.

The main change is triggered by comparator 2. The charge on the capacitor is applied to the positive input to the comparator which is now greater than or equal to the 3.33V (from the resistor ladder) applied to the negative input. This causes the comparator to set the output high.

A high output on comparator 2 is applied to the reset input of the S-R latch. This turns the set output (Q) of the latch off and the inverted output (Q) on.

Two things happen when Q is turned on:

1. The output of the NE555 is turned off
2. The transistor connected to the discharge pin is turned on

Turning the transistor on changes the flow of current through the circuit. So far current has been flowing through the two resistors, R₁ and R₂ to charge the capacitor, C. Now the current starts to flow from V_cc to ground through R₁.

Current will now also start to flow from the capacitor, through R₂ and the transistor to ground. At some point the charge on the capacitor will drop below 3.33V. This will be reflected on the threshold pin connected to comparator 2 and the output of this comparator will be turned off:

Middle of Capacitor Discharging

The output of the S-R latch will continue to hold the last state until and hence the output remains off until a signal is applied to the set pin of the S-R latch and so current continues to flow through the transistor.

Capacitor Charge Drops Below 1.67V

At some point the charge on the capacitor will drop below 1.67V and comparator 1 turns on and so Q is turned off once more. The circuit starts to behave as though the system has just been powered on with one slight difference, the charge on the capacitor C starts at 1.67V instead of 0V. The whole cycle of charging and discharging repeats continuously.

Circuit Output

Building the circuit on breadboard and then connecting up an oscilloscope to the discharge and output pin shows the following trace:

Oscilloscope Trace

The output is shown in yellow and the discharge is shown in blue.

It is clear to see the charging and discharging of the capacitor coincides with the change in the output state of the NE555.

Timing Calculations

The timing calculations given in the data sheet for the NE555 are as follows.

Note that in the following calculations, resistance is expressed on Ohms, capacitance in Farads and time in seconds.

Charge Time

The charge time depends upon the capacitor and the two resistors R₁ and R₂ as current flows through the two resistors to charge the capacitor. The time taken to charge is given as:

t_charge = 0.693 * (R₁ + R₂) * C

Discharge Time

The discharge time is only dependent upon the capacitor and R₂ as current does not flow through R₁ when the circuit is discharging. the time take to discharge is given as:

t_discharge = 0.693 * R₂ * C

Period

The period is the sum of the two timings t_charge and t_discharge. This can be expressed as:

Period = = 0.693 * (R₁ + (2 * R₂)) * C

The duty cycle and frequency are easily derived from the above.

And Finally…

The NE555 is a versatile chip that can act as more than a simple oscillator. The principles of the above circuit can be used in clock generation, switch debouncing, reset circuits and a whole range of other applications, several of which will be covered in following articles.

Dave Jones (EEVBlog) has put together the Three Fives Timer Kit and has videoed the build process and also provided a run down of the theory of operation referring to the kit schematic. Key times in the video are:

• 0 – 36 Minutes: Building the kit
• 36 – 54 Minutes: Examination of the schematic and run through the theory of operation
• 54 – 62 Minutes: Checking the voltages and output from the kit using an astable circuit

Netduino Foundation Banner

It has been a very busy few months both in and out of work as evidenced by the silence here. The last few months has seen a fair amount to time spent working with the Netduino boards developing documentation and libraries.

I was given a Nedtuino board in 2010 as a present and I have never looked back. The orignal Netduino Plus was upgraded to the Netduino Plus 2, the Netduino WiFi and numerous electronics projects have come about all due to that original present.

The attraction of the Netduino is the fact that you can work in C# with Visual Studio. Another big selling point is Visual Studio and the powerful debugging features available to the developer.

In summary, it’s a great prototyping and test environment. If I ever have a problem and want to test a theory quickly I always fall back to these boards.

Netduino.Foundation

One difficulty with Netduino was it was sometimes difficult to find drivers for sensors, displays etc. Support for devices relied upon community members having written a driver and making the source available. In fairness, many community members did just that.

Wilderness Labs have recently taken ownership of the Netduino brand and technology. A new approach has brought some innovations:

• Support for Visual Studio for Mac
• New community forum
• Developer documentation for the Netduino
• Electronics tutorials
• Netduino.Foundtion collection of drivers and core functionality
• Source code is available on GitHub
• Nuget support

It is still possible to use the Netduino without using Netduino.Foundtion but the library makes a number of tasks easier and quicker.

As well as a number of core peripherals there is support for a library of drivers covering a variety of devices:

All of the drivers are supplied with source code, sample applications and comprehensive documentation.

Conclusion

It is great to see the Netduino with a new supporter. The new documentation and libraries make the platform easier to use.

In the previous post, a high level design for an Arithmetic Logic Unit (ALU) was presented. It is time to consider how this could be implemented.

7400 Series Integrated Circuits

The 7400 series of integrated circuits became a staple in computer design and digital electronics in the 1970s and 1980s. These packages implemented everything from simple logic gates (AND, OR, XOR, NOR etc.) through to complex functions such as Error Detection and Correction (see 742960). See this article for a comprehensive list of chips and their functions.

So popular were these chips that they are still available today in the original DIL (Dual In-line Package) as well as surface mount packages.

A number of variations of these ICs were produced:

The above list is not comprehensive and many more variations are available.

This series of posts will concentrate on using the LS series of chips where possible.

Internals of the ALU

The ALU in the SSEM needs to support addition (for the JRP instruction) and subtraction (for the SUB and LDN instructions). The previous post presented the internal view of the ALU for the SSEM as:

Internal view of an Arithmetic Logic Unit showing the control signals and data paths.

The ALU has five distinct components:

1. Storage for the A and B operands (registers)
2. Zero Unit
3. XOR
4. Adder
5. ALU Output

Let’s look at how each of these could possibly be implemented using 74LS00 series integrated circuits.

Storage for the A and B operands (registers)

Both of the operands are connected to the data bus at the same time:

Operand A and B

The Load control signal determines when the input signals should be stored in the register. Each of the registers holding the operand has an independent load signal. So for this part of the ALU a component is required that will:

1. Take the value on the input pins and store the value
2. Only load the data into the register when the trigger signal has a known value
3. Present the stored value on the output pins

The above requirement fits the description of a Flip-Flop (also known as a Latch).

The 74LS00 series has a number of flip-flops and latches available. The 74LS373 contains an octal transparent latch with three state output. This chip is still commonly available and has the following properties:

1. Input signals can be latched (stored) in the internal registers on request
2. The output from the latch can be turned on or off, again, on request

The above functions are controlled by two signals:

1. Clock
2. Output Enable (~OE)

Clock

When the clock signal is low the inputs are effectively disconnected from the latches. the latches will therefore remain unchanged and hold the previously latched value.

A high clock signal will allow the input pins to the connected to the latches. Any changes on the inputs are presented to the latches. This holds true for as long as the clock signal is in the high state.

The state of the input pins is held in the latches when the clock signal transitions from high to low (on the falling edge of the clock).

Output Enable

The output enable pin is an active low pin (denoted here by the ~ symbol before the name of the pin). This means that the contents of the latches will be output from the chip when the ~OE pin is in the low state.

Putting the ~OE pin in a high state disconnects the latches from the output pins and puts the outputs in a high impedance (also known as a high-Z) state.

Setting ~OE low while the clock pin is high means that the outputs will follow the inputs. This happens because the high clock signal allows the inputs to be connected to the latches and the low output signal puts the value in the latches on to the output pins.

Loading the Latch

From the above description, the Clock pin should be connected to the Load A and Load B signals of the respective operands. This will allow the latch to be loaded with the input signals when the load signal falls from high to low.

The inputs to the chips should be connected to the data bus directly and simultaneously. Data cannot be loaded into the latch until the appropriate load signal transitions from high to low. The load signals will control when the operand changes as follows:

• Load A (or Load B) signals are low then the inputs will have no impact on the operands. The outputs will reflect the previous value stored in the latch.
• When Load A (or Load B) is high then the contents of the data bus will be presented to the respective latch. The output of the respective operand will reflect the current contents of the data bus.
• When the Load A (or Load B) signal falls from high to low, the current contents of the data bus will be stored in the respective operand. The output will reflect this value no matter what happens on the data bus.

Aside: in 2013, the intention was to simulate the SSEM in VHDL. The 74HC373 was simulated in a series of posts around that time.

XOR

The next block available is the 74LS series is the XOR block:

Operand B and XOR

This block performs one part of the negation process allowing the adder to also perform subtraction. The XOR truth table is:

In twos complement, the first part of generating a negative number is to invert the bits in the original number. If you examine the above truth table, when the ~Add/Subtract signal is low, the output reflects the input value. When ~Add/Subtract is high then the output is the inverse of the input value.

So, setting the ~Add/Subtract signal high when the ALU is subtracting operand B from operand A and low when the ALU is adding operand A to operand B will ensure that the correct value is passed through to the adder.

The 74LS86 is a quad 2-input XOR gate (contains four 2-input XOR gates) in a single package. The necessary functionality is achieved by connecting the A inputs (not to be confused with the A operand) of each gate to the ~Add/Subtract signal. All of the A inputs are therefore connected together. The B inputs are connected to the outputs of the B operand latch.

Zero

The zero unit sits between the output of the A operand and the Adder. Its function is to select between two possible input values:

1. Zero
2. A operand

and pass the selection on to the Adder.

Operand A and Zero

A number of possibilities exist:

• Use the ~OE signal on the A output to simply turn the output off when zero is required. This may require the use of pull down resistors to prevent a floating signal.
• Use a buffer chip such as the 74LS245 to connect the Adder to ground when ~OE on the A operand goes high

A little investigation is required.

Adder

The adder unit takes the inputs and simply adds them together:

Adder with inputs.

The 74LS283 is a four bit full adder with carry in and carry out. An 8-bit adder is created by chaining two four bit adders together:

In the case of subtraction, the final part of the negation of a twos complement number is to add 1 to the inverted bit pattern of the original number. Setting the carry in on the first adder effectively adds one to the number. The same ~Add/Subtract signal in the XOR block can be used here as it is low for addition (zero will be added to the sum) and high for subtraction (one will be added to the sum).

ALU Output

The ALU output takes the output of the adder and makes this available to the data bus:

ALU Output

Output to the data bus is controlled by the ALUOutout signal and this function can be performed by a buffer circuit. The 74LS245 is an octal bus transceiver with non-inverting three state outputs. The direction of signal transmission can be controlled using the DIR pin on this chip. In the case of the ALU, the direction is always from the ALU to the data bus and so this pin can be held high (or low) permanently.

Output from 74LS245 is controlled by the ~OE pin. This is an active low pin and the chip is transparent when the signal is low and in high impedance mode when this pin is held high.

Conclusion

All of the integrated circuits for the high level functionality of the ALU have been identified. The next step is to put this together and see if it works as expected.

Something for the next article.

The February post regarding the SSEM presented a software implementation of the core hardware:

• Program counter a.k.a Current Instruction (CI)
• Arithmetic Logic Unit (ALU)
• Instruction register a.k.a Present Instruction (PI)
• Registers (memory)

So, how easy this would be to implement the ALU in 1970s hardware, namely, 74LS series of chips.

Arithmetic Logic Unit

The only explicit arithmetic operation implemented by the ALU is the SUB instruction. There is however, one other operation that requires an arithmetic operation to be performed, the JRP instruction. This instruction adds the contents of a store line to CI and stores the result in CI. The inclusion of an ADD instruction to the ALU instruction set will support the JRP instruction.

Before we progress further it is worth noting that the SSEM uses twos complement representation to store numbers.

The high level view of the ALU and the way in which it interacts with the other components can be viewed as follows:

High level view of an Arithmetic Logic Unit.

Two busses run through this CPU:

1. Data Bus
2. Control Bus

The Data Bus is used to move data from one part of the CPU to another. This is also connected to the external data bus of the computer allowing the CPU to store and retrieve data from system peripherals and memory.

The Control Bus determines which operations are performed by the CPU (in this particular case, by the ALU) at any point in time.

The ALU uses two input operands (A and B) from the Data Bus. Operations are performed on the two operands, the type of operation is determined by the signals on the Control Bus. The results of the operation are then placed in the ALU Output register. The final step is to make this result available to the Data Bus.

The fact that the SSEM implements only these two arithmetic instructions operating on twos complement numbers leads to a very simple ALU design with very few control signals.

Data Bus

As noted, the data bus moves data around the system. The ALU requires two operands for the ADD or SUB operations. These can be implemented in a single operation or in several stages.

Single Operation

Supplying the data in a single operation would require the data bus to be twice as wide as the word size. In the case of the SSEM this would require a data bus that is 64-bits wide. Operand A would be supplied by one half of the signals on the data bus. Operand B would be supplied by the signals on the other half of the bus.

Multiple Steps

Supplying each operand independently would require a two step process, the first step puts operand A on the data bus and loads into the operand A register. The second step puts operand B on the data bus and loads the data into the operand B register. This is slower, taking two steps, but simplifies the hardware design as a 32-bit data bus is used.

Control Bus

The operation of the CPU is orchestrated by the signals present on the control bus. In the case of the instructions being implemented (ADD and SUB) using two registers the following signals are required:

1. Load operand A (place the contents on the data bus into operand A)
2. Load operand B (place the contents on the data bus into operand B)
3. Output result (place the ALU result onto the data bus)
4. Add or subtract (Select either addition or subtraction)

There is another instruction that would benefit from having access to the ALU, namely, Load Negative (LDN). This instruction loads a negative number into the accumulator. A negated number can be obtained by subtracting the original number (from a store line) from 0.

If we design the system so that the subtrahend (the number to be subtracted) is always placed in the B operand and operand A can be zero then we can support the LDN instruction. This leads to the final signal, Operand A or Zero.

The full list becomes:

1. Load operand A (place the contents on the data bus into operand A)
2. Load operand B (place the contents on the data bus into operand B)
3. Output result (place the ALU result onto the data bus)
4. Add or subtract (Select either addition or subtraction)
5. Operand A or Zero

Inside the ALU

If we add the data paths and control signals to the above diagram we have the following:

Internal view of an Arithmetic Logic Unit showing the control signals and data paths.

The data paths are shown as broad arrows. The control signals are drawn in red.

Loading the Operand Registers

The data from the data bus is presented to both the A and the B operands at the same time. The data is loaded into the register when the appropriate Load A or Load B signal is set.

Zero Operation

The zero operation is only needed for the A operand. This block will either pass the value in operand A through to the adder (for the SUB, ADD and JRP instruction) or pass 0 through to the adder (for the LDN instruction).

XOR

The XOR block is used to help with the negation of the number in the B operand. In twos complement, a negative number is obtained by inverting the bits in the original number and the adding 1. The XOR helps with the inversion process. Consider the truth table for the XOR operator:

Note that when the Control Signal is 0 then the output from the XOR gate reflects the value on the Input Value. When the Control Signal is 1 then the output is the inverse of the Input Value.

This provides a method for solving the first part of the problem of generating the twos complement negative number, namely, inverting all of the bits in the positive number.

Adder

The adder does exactly what it’s name suggests, it adds two numbers together. Normally, these units have a carry in and a carry out signal to allow multiple units to be chained together:

Two chained four bit adders.

When the ~Add/Subtract control signal is set to 0 then the XOR block passes through operand B unchanged. The carry in signal to the first of the adders (Adder-0) is set to 0. The result is that operand A and operand B are added together. This supports the JRP instruction which requires an addition.

When the ~Add/Subtract control signal is set to 1 then the XOR block inverts the bits in operand B. The additional 1 needed for the twos complement process is provided by passing the ~Add/Subtract control signal to the carry in input to the first adder unit (Adder-0 in the above diagram).

Result Output

The final part of the problem is to control when the result from the calculation is output on to the data bus.

Conclusion

A lot of theory, next step is to consider how this can be put into practice.

Something for the next article.

One of the current projects on the go is a level shifter for the Teensy 3.6 using the TXS0108E chip. The aim is to allow the use of as many of the Teensy’s GPIO pins as possible to allow the development of another project that is working on 5V logic levels.

This project reminded me that when putting together a microcontroller project that the system is made up of both hardware and software. Sometimes a design decision made in one element can have an adverse effect on the other.

Design Decisions

From the start it was decided that the GPIO pins would have a one to one mapping from the microcontroller to the external bus. So pin 1 on the microcontroller would map to pin 1 on the external connectors.

This would make coding easy when using the Arduino API. So connecting to the external bus and outputting a digital high signal on pin 1 would become:

pinMode(1, OUTPUT);
digitalWrite(1, HIGH);

Impact

Putting the circuit together in KiCAD resulted in the following design:

PCB Layout

TXS0108E Schematic

As you can see, the Teensy GPIOS (TIO-1…) mapped directly to the external bus (GPIO-1…)

When translated into the rats nest there were three occurrences of the following:

PCB Layout

Routing this was going to be a nightmare.

Changing the Design

At this point the penny dropped that a small change in the software would make the routing a whole lot easier.

Instead of using the pin numbers directly, a #define could be used for the external bus pin numbers. The above snippet would become:

#define BUS_IO1    30
.
.
.
pinMode(BUS_IO1, OUTPUT);
digitalWrite(BUS_IO1, HIGH);

This small change to the design created a one off task to create a header file for the board but it made the routing a lot easier.

Conclusion

Sometimes a small change may create a new task (creating the header file) but may possibly save more time elsewhere in the project.

Moral of the story, Design the system as a whole, not the individual components.

March has been a funny old month. The launch of the Raspbery Pi Zero W was an interesting event. Most of February was spent evaluating the direction of future developments. The launch of the Pi Zero W in early March influenced those decisions.

It feels like nothing was really completed but the foundations for the next few months have been set. Here’s a few of the things March has bought our way:

• Release of the Raspberry Pi Zero W
• Moving from MicroPython on the ESP32 to Python on the Pi
• TXS0108E level shifting IC
• PlatformIO
• Teensy 3.6

Python

More precisely, MicroPython. The increasing number of platforms supporting MicroPython has made this an interesting development environment. In theory the code developed on one microcontroller supporting MicroPython should be portable to other microcontrollers with relative ease.

The Raspberry Pi Zero W changed all of that.

There were several microcontrollers running MicroPython at the start of February, the ESP8266 was common and cheaply available. A beta version of MicroPython became available for the more capable ESP32 around the same time.

The arrival of the Zero W means that the full Python language is available on a development board running 5-20 times faster than an equivalent microcontroller development board. All this with the added bonus of WiFi and SD card built in.

Another attractive feature of the Zero W is the cost in the UK. The most powerful microcontroller boards available in the UK cost between 1.5-2 times that of the Zero W including shipping.

The net result, I’m starting to look at the Pi Zero W as a possible go to board for future projects.

Level Shifting

One recent project requires the use of 5V logic, a problem when current microcontroller boards are using 3.3V logic levels. Some are 5V tolerant, but not all. Ideally the microcontroller I am after should allow for 40+ GPIO pins. The only microcontroller in the arsenal with this number of pins is the Teensy 3.6. Sadly this in only tolerant to 3.3V signals. Interestingly, I found a reasonably priced bidirectional level shifter, the TXS0108E, so some experimenting required to see if I can use this part. The aim is to use the Teensy to inject test signals.

Time to break out the breadboards and KiCAD.

PlatformIO

I have had PlatformIO installed on the laptop since I first came across it last year. For most of that time it was being used as a simple text editor. What I never appreciated was the ability to program a number of development boards, a large number of development boards.

Time to uninstall the Arduino IDE on the Mac.

A current project requires some memory, only a small amount, something suited to the 2114 4096-bit memory IC. A quick eBay search results in 20 ICs in the post. Only problem now is to make sure I understand how they work and test the batch of chip. Enter the Arduino Uno and PlatformIO.

Teensy 3.6

As noted, one current project requires a large number of IOs, something the Teensy 3.6 can bring. A quick package update installs the Teensy 3.6 board into the PlatformIO environment.

Time to write and deploy a quick test application, enter Blinky… No luck. PlatformIO uses the teensy_loader_cli application to deploy the hex file to the Teensy board. The default package deployed with PlatformIO did not upload the binary file to the Teensy. the solution was to build a new version of the teensy_loader_cli application and overwrite the one supplied with PlatformIO. Success!

For those who are interested, the solution is:

• Download the source code from GitHub
• Edit the Makefile
• Change the OS version to MacOS
• Uncomment the line USE_LIBUSB ?= YES
• Rebuild the application
• Copy the new version of the application to the tools directory, in my case this was ~/.platformio/packages/tool-teensy

Conclusion

It seems that nothing much was completed but the work set the stage for future developments.