another Base Station or system, with
the DCC Power Shield turning that
signal into a more powerful DCC signal that can be used to drive trains.
While it might not seem that an
Arduino is needed in this case, it’s
a good idea to have one as we can
program it to monitor the DCC signal
and intervene if there is a problem. So
we’ve written a sketch to allow an Arduino to take on this supervisory role.
There are two main conditions to
check for. First, we want the Booster
to be able to protect the shield if too
much current is being drawn from it.
This could be due to an overload
or even a short circuit, such as a
metal object being dropped across
the tracks.
Thus, our sketch continually monitors the voltage present on its A0 pin
via its internal analogue-to-digital
converter (ADC). If it gets above a
certain threshold, the power to the
track is cut by pulling the ENABLE
pin low.
A timer starts and the sketch attempts to re-apply power after it
expires. If the short circuit is still
present, then the over-current condition re-occurs, power is cut again and
the timer re-starts.
The other condition we need to
consider is if the incoming DCC signal
is lost. This could be for any reason,
such as if the connection to CON3
is broken or the upstream DCC Base
Station has a fault. In any case, when
there is no signal at CON3, the input
to IC1 is held high and IC2’s input is
low. There is then an unchanging DC
voltage across the tracks.
This may not sound like a problem,
but some DCC locomotives can be programmed to undergo ‘DC conversion’.
When a locomotive decoder detects
that there is a steady DC voltage present, the locomotive behaves as if it
was on a conventional ‘single-throttle’
layout and will typically set off in one
direction at full speed (hopefully not
towards the end of the track…).
This feature was initially added to
allow DCC locomotives to be used on
conventional layouts, perhaps as an
aid to owners transitioning to DCC
from DC systems.
Fortunately, the DC conversion feature can be turned off in the decoder
by setting a configuration variable.
You can use a DCC Programmer such
as from our October 2019 article to
do this.
In any case, the sketch detects that
the DCC signal is no longer changing
and pulls the ENABLE line low, disabling the track output and preventing
such runaways.
To enable the use of the optoisolated input, add a jumper across JP3.
Leave the jumper on ‘DIR’ for pin D10
in place; D10 is set as an input in the
software and is used to monitor the
incoming DCC signal.
Screen1: while JMRI’s DecoderPro program has many features,
it also has a set of basic tools for controlling trains. This
throttle window allows speed, direction and light functions to
be controlled. You can even switch track power directly; the
green icon at upper right mimics the status LEDs on the shield.
32
The Booster sketch is called DCC_
Shield_passthrough_supervisor.ino.
This uses a library to perform the
precision timing needed to generate
the DCC waveform, called TimerOne.
This can be installed via the Library
Manager by searching for ‘timerone’
or from the ZIP file we have included
with our software package.
Open the sketch, select the Uno and
the serial port and upload it. Disconnect the USB cable and connect your
power source to CON1. The red LED
should light. Connect a valid DCC
signal to CON3 and the green LED
should light. You should then have
a valid DCC signal at CON2.
A standalone sketch
We’ve also created a simple standalone sketch that produces a DCC
signal, suitable for controlling a
single locomotive.
The decoder identification number
has been set to 3 (which is the default
for new, unprogrammed decoders), although it can be changed in the code.
We suggest you use this option if you
want to try out DCC for the first time.
We can’t offer advice on fitting decoders; there are so many options for
both decoder choices and how they
are connected.
The companies that manufacture
the decoders do offer advice (and
many have custom decoders to suit
specific locomotives). After all, they
want to make it easy for you to buy
their products.
Our standalone sketch also requires
the Timer One library mentioned
above, so make sure that is installed.
Screen2: while very basic, our standalone sketch named
DCC_Single_Loco_Control.ino allows power, speed,
direction and lights to be controlled by commands in the
serial monitor – download from the January 2021 page of
the PE website. The software can be modified to control
multiple locos. Advanced Arduino users could use it as the
basis of an automated layout control system.
Practical Electronics | January | 2021
Set the jumpers on the shield to
the default positions and connect
the Uno to the computer. Open the
DCC_Single_Loco_Control.ino sketch
and select the Uno board and its serial port. Press the Upload button to
compile and upload the sketch, then
open the Serial Monitor at 115,200
baud (see Screen2).
You can now enter commands as
numbers which correspond to the
desired locomotive speed, in 128
steps. Thus, numbers from −127 to
127 are accepted. You should ensure
that 28/128 step speed mode is set on
your locomotive decoder.
Type ‘P’ (upper case) to turn track
power on and ‘p’ (lower case) to turn
it off. The power will automatically
turn off if current over half an amp is
detected. You can also use ‘A’ and ‘a’
to turn on and off the loco’s headlights.
The program is elementary, but it has
several unused functions to send all
manner of DCC packets to the track. If
you are comfortable with the Arduino,
you should have no trouble adapting it
to do something more advanced.
Current limitations
Using the specified components and
the DCC++ software, the shield can
easily deliver up to 10A. This is
mostly limited by the screw terminal
connectors. The DCC++ software also
has a hard-coded current limit which
kicks in at around 10A.
Of course, the software limit is easy
to change, but any hardware changes
should be done with care.
The output driver ICs are capable
of handling around 30A, with the
PCB tracks topping out around 20A.
In any case, everything runs cool
well below the 10A limit, so maintaining this limit is good for component longevity.
DCC has a wide range of operating
voltages, so to increase output power,
it may be easier to increase the
supply voltage.
Most locomotives
use PWM speed control
on their motors, so
a higher supply
voltage simply means
a lower PWM duty cycle
(and thus current
consumption) for the
same speed.
We haven’t done any
tests above 10A, but if
you are set on increasing
the current capacity of the DCC
Power Shield,, then you should
ditch the screw terminal connectors
and solder thick copper wires directly
to the board (ideally, to the power
pins of IC1 and IC2).
Practical Electronics | January | 2021
If the wires can handle 20A, then
your modified DCC Power Shield
should have no trouble doing that.
To go higher than this will probably
mean that IC1 and IC2 need some
heatsinking, as well as even thicker
wires. We suggest that you instead
consider using more, smaller boosters. For example, you could modify
the Booster sketch to monitor and
drive multiple DCC Power Shields
stacked above it.
A larger system
If you are planning a system with
multiple Boosters, either because you
need the power or it otherwise makes
sense to do so, then there are a few
minor caveats.
When running multiple Boosters,
avoid daisy-chaining the DCC signal
from one Boosters to the next. Instead,
fan out the DCC signal from one Base
Station to all the Boosters.
Many commercial Base Stations
have a low-powered DCC signal output
(Digitrax names this Railsync), which
is ideally suited for this purpose.
The first problem with a daisy-chain
configuration is that if one Booster goes
down, then so do all those downstream,
as the DCC signal will be shut off.
Second, each Booster also has a
small but measurable delay in propagating the signal. In our case, this is
around 4µs, due to the switching time
of the BTN8962s.
This delay is not usually a problem, but it may become one at the
boundary where the tracks from two
Boosters meet (where there would
typically be an insulator, to prevent
one Booster feeding another Booster’s
section of track).
Where the tracks meet, a train may
be briefly fed by both the
Boosters. If there is
Using the DCC Booster
Shield as a motor driver
The DCC Booster Shield can be used as a
high-current motor driver shield. In this
case, the signal on the DIR pin determines
the motor direction, and a pulse-width
modulated signal is applied to ENABLE
to control the speed.
The BTN8962 has active freewheeling,
so no external diodes are needed. If used
like this, LED1 and LED2 will both appear
to be on at the same time, with green LED1
becoming brighter and red LED2 dimmer
as the duty cycle increases.
As noted earlier, the 100µF electrolytic
capacitor is adequate for a DCC application. A larger value may be needed for
motor driving.
We suggest leaving ZD1 off, as larger
motors will create hefty spikes at the end
of each drive pulse.
Keeping the two supply rails separate
will prevent this from damaging the
Arduino board.
a delay between the signals from the
two Boosters, then it may appear to be
a short circuit if the two Boosters are
delivering opposite polarity voltages
at that instant.
This is less likely to occur if the
Boosters are well synchronised,
which should be the case if all are
being fed the same signal.
You should also ensure that the
Boosters are fed with similar supply
voltages, so that one Booster does not
try to power another Booster’s track
when the train bridges their join.
You must also ensure that the
Boosters are wired with the correct
polarity where the tracks meet.
Reproduced by arrangement with
SILICON CHIP magazine 2020.
www.siliconchip.com.au
The DCC Power Shield can be combined
with an Arduino Uno and DC power supply to
create a basic DCC system. Using our standalone
sketch or JMRI’s DecoderPro program, this combination
can be used to control DCC-equipped trains, points and
signals on a model railway layout.
33
Using Cheap Asian Electronic Modules by Jim Rowe
Intelligent 8x8
RGB LED matrix
This month, we’re looking at a module with an 8x8 matrix
of 64 ‘intelligent’ RGB LEDs. Each LED can display over 16
million different colours, or primary colours at 256 brightness
levels. The LEDs are controlled serially via a single wire, and
multiple modules can be cascaded to build a much larger
display, enabling all sorts of useful applications.
W
e looked at some 8x8 LED
display modules in an earlier
article in this series, back in
the July 2018 issue. We thought it was
worth writing this one up too, as it is
significantly more flexible and just
generally more useful.
It uses RGB (red/green/blue) LEDs
rather than monochrome (single colour) LEDs. Each LED can display up
to 256 brightness levels for each of
the three colours, to give a total of
16,777,216 (256 × 256 × 256) different colours.
In this module, each RGB LED has
its own built-in serial data register,
latch register and decoder/driver, so
no separate controller is needed.
All 64 LEDs of the module are connected in sequential (daisy-chain) fashion, so that serial data can be fed into
the first LED of the module and passed
through to the other LEDs in turn.
If you want to use multiple modules,
the data output from the 64th LED on
the first module can be fed to the first
LED of the next module to program its
LEDs as well. And so on.
This module is based on an impressive device: the WS2812B intelligent
control LED made by WorldSemi,
based in Dongguan, Guangdong province, China (between Guangzhou and
Shenzhen, and near Hong Kong).
I should note that some of the modules
currently available use a ‘clone’ of the
WS2812B device, the SK6812, made by
another Chinese firm: Shenzhen Sikewei
Electronics. Although the timing specs
for the SK6812 differ a little from those
of the WS2812B, they are quite compatible with most of the available software.
You can find these WS2812B/
SK6812-based 8×8 RGB LED modules
on the internet from various vendors,
many of them available via sites like
eBay or AliExpress (www.aliexpress.
com/item/32671025605.html). The
prices vary quite a bit, but you can find
them from around US$4 shipped!
Now let’s look at the WS2812B IC
to see how it works. (This description
also applies to the SK6812.)
The WS2812B LED chip
This small (5 × 5 × 1.6mm) four-lead
SMD package, shown in Fig.1, houses
a trio of LEDs as well as a serial controller IC. It looks deceptively simple,
but you can see from the block diagram
(Fig.2), there’s quite a lot inside.
It includes a 24-bit shift register, a 24bit latch, three eight-bit DACs (digitalto-analogue converters) coupled to a
driver for each LED and a buffer amplifier to boost and reshape the serial data
output, ready for the next WS2812B.
Fig.3 shows how a string of 64
WS2812B devices are connected to
Fig.1: the SMD package size and
pinout of the WS2812B (and
equivalent) chips. Internally,
it’s made from multiple
semiconductor dies, tied
together with bond wires and
encapsulated with a plastic lens
on top. Note that the package
orientation marking is located
on pin 3, rather than pin 1.
►
Fig.2: as well as the red, green ►
and blue LED dies, the WS2812B
incorporates a controller/driver
IC, which includes a serial latch
plus three linear LED drivers
with 8-bit DACs.
34
Practical Electronics | January | 2021
Fig.3: cascading multiple
WS2812B devices is simple.
The DOUT (data out) pin
of one device is simply
connected to the DIN (data
in) pin of the next device.
The 5V and GND pins are all
connected in parallel, with
a 100nF bypass capacitor
close to each device.
make up the module. This is simplified
by showing just three of the 64 devices.
The data stream from the MCU is fed into
pin 4 (DIN) of the first device, while the
output from pin 2 (DOUT) is connected
to pin 4 of the next device, and so on.
One of the slightly unusual features
of this chip is that unlike other daisychained shift registers, it doesn’t feed
the top-most ‘overflow’ bit of the shift
register to the output, for feeding into
the next device.
Rather, the output is held in a static
state until all 24 bits have been shifted
into the register (presumably, tracked via
a counter register), at which point it no
longer shifts in any new bits. The input
is then connected to the output buffer
via an internal switch.
This means that the first 24 bits of data
shifted into the daisy chain determine
the state of the first device. With the
more typical (and simpler) shift-through
design, the first bits of data end up in the
last device – ie, you have to shift in the
data in reverse order.
So, presumably the reason for this
unusual scheme is to avoid the need to
reverse the order of data being sent to an
array of these devices.
The only other components are the
100nF bypass capacitors on the +5V
supply line, with one next to each device. The 1000µF reservoir capacitor is
external to the module.
The physical layout of the 64-LED
array, which measures 65 × 65mm, is
shown in Fig.4. The input connections
for the module are at lower left, while the
output connections are at upper right.
Each WS2812B device can draw up
to 18mA from the +5V supply during
operation, so a single 64-LED module
can draw as much as 1.152A.
That’s why it’s recommended that
even using a single module, the +5V supply for the module should not come from
your MCU (eg, Arduino or Micromite),
but from a separate DC supply.
It’s even more important to do this
when you’re using several modules in
cascade. This is also why that 1000µF capacitor is needed on the +5V supply line.
Driving the module
The LEDs in these modules are programmed serially via a single wire, as
mentioned earlier. But they use a special
pulse-width modulation (PWM) coding
system for the data, shown in Fig.5.
The timing for a zero bit, a one bit
and the RESET/LATCH pulse for a basic WS2812B device are shown at the
top of Fig.5; this is used in most of the
currently-available 8×8 modules. The
corresponding timings for the latest
WS2812B-V4 version of the device are
shown adjacent.
There are subtle differences in data bit
timing between the two versions. The
main difference is that the WS2812B
needs a RESET/LATCH pulse lasting
more than 50µs, while the WS2812B-V4
needs a longer pulse of more than 280µs.
Timing for the SK6812 device is similar to that for the WS2812B, with a zero
bit composed of a 300ns high followed
by a 900ns low, a one bit composed of
a 600ns high followed by a 600ns low,
and the RESET/LATCH pulse needing
to be 80µs or more.
The centre section of Fig.5 shows the
24-bit data packet used to program a
single WS2812B LED. There are eight
bits for each of the three colours, with
each colour’s data byte sent MSB (mostsignificant-bit) first. So the total time
needed to refresh one LED is either 30µs
or 26.4µs, depending on the version of
the WS2812B chip.
Fig.5 also shows the colour data sent
in GRB (green-red-blue) order, but some
of the WS2812B or equivalent devices
used in these modules require the data to
be sent in RGB order. As a result, much
of the software written for these modules
allow the colour byte order to be changed
to suit the specific devices being used.
The 64-LED data stream used to program all of the WS2812B LEDs in a single 8×8 module is shown at the bottom
of Fig.5. As you can see, the 24 bits of
data for each of the 64 LEDs are sent
in turn, followed by a RESET/LATCH
pulse. This pulse instructs all of the WS2812Bs to transfer the data in their shift
register into the latch register, changing
the colour and brightness of its LEDs to
the new values.
So one complete refresh cycle for an
8×8 module takes very close to 1970µs
Fig.4: this shows the layout
of the 8×8 RGB LED matrix.
As you would expect, the
LEDs are laid out in a
grid. The data input is at
lower left and data output
at upper right (along with
the supply pins), so that
multiple modules can be
daisy-chained. It’s a pity
that the output isn’t at
lower right, as that would
make chaining modules
considerably easier.
Practical Electronics | January | 2021
35
While the underside of this
module uses headers for external
connections, some modules
provide SMD pads rather than
holes. It can be worthwhile to
shop around, but there is a risk
that you may come across clones
which are not fully compatible.
rainbow pattern, sending a ‘3’ produces a display of all LEDs glowing
mid-green, sending a ‘6’ produces a
pattern of white dots ‘chasing’ each
other, and so on.
While this may not sound terribly exciting, it should give you
a good idea of what’s involved
in driving these modules from
an Arduino.
(1.970ms) or 1969.6µs (1.969ms),
depending on which version of the
WS2812B is being used. As a result,
the display can be refreshed up to 500
times each second (or a fraction of this
with multiple modules, eg, 100 times per
second for five modules daisy-chained).
Driving it from an Arduino
Thanks to the single-wire data programming system used by the WS2812B device, it’s physically quite easy to drive
this module from an Arduino.
As shown in Fig.6, all that’s needed
is a wire connecting the module’s GND
pin to one of the Arduino GND pins,
together with a wire with a 390Ω series
resistor connecting the module’s DIN pin
to one of the Arduino’s digital I/O pins.
Wires from the module’s +5V and
GND pins are then used to supply it with
5V power, with a 1000µF capacitor used
as a reservoir to ensure that the 5V power
remains constant.
Writing the required Arduino ‘sketch’
(program) is a little complicated due to
the unusual PWM coding system used.
Luckily, several Arduino software libraries have been written to drive a string of
WS2812B/SK6812 devices.
You’ll find suitable programs in various places on the Web, most of them
fairly simple and straightforward. Many
of them make use of a library of routines
for the Arduino written by the Adafruit
people and called Adafruit_NeoPixel.
To get you started, I’ve written a sketch
called RGBLED_Matrix_sketch.ino,
available for download from the January
2021 page of the PE website. It uses the
Adafruit_NeoPixel library, which can
be downloaded from https://github.com/
adafruit/Adafruit_NeoPixel (or via the
Arduino IDE’s Library Manager).
This sketch allows you to produce one
of nine different patterns on the module,
simply by sending a digit (from 1 to 9) to
the Arduino from your PC’s serial port
(eg, via the IDE’s Serial Monitor). For example, sending a ‘1’ produces a changing
36
Driving it from a Micromite
Driving one of the modules from a
Micromite again isn’t easy, mainly because of the PWM bit encoding scheme.
After trying to make unorthodox use
of MMBasic’s built-in SPI communications protocol (with no luck), I realised that I would need an embedded
C function similar to Geoff Graham’s
SerialTX module.
CFUNCTIONs allow native ‘machine language’ code to be added to
an MMBasic program. This would let
me send the serial data streams to the
LED module with the right encoding
and at the right speed.
This 8×8 RGB LED module uses
WS2812B ICs. The data and power
connections are made via two 3-pin
male headers on the PCB’s underside.
I was rather daunted at the prospect
of writing this CFUNCTION. But Geoff
Graham advised me that a suitable function had already been created by Peter
Mather, one of the Micromite ‘gurus’
on The BackShed Forum (http://bit.ly/
pe-jan21-shed).
I eagerly downloaded Mr Mather’s
CFUNCTION, and tried using it with a
small MMBasic program to drive a module with 64 WS2812B LEDs. The results
were a bit disappointing, with a variety
of unexpected errors. This prompted me
to try using my DSO to check the pulse
timing of the bitstream being sent to the
WS2812B LEDs, to compare it to the required timing shown in Fig.5.
I subsequently found a few differences, which seemed likely to explain
the problems I was having.
Fig.5: the WS2812B uses a custom 1-wire serial protocol, with the duration of the
positive pulse distinguishing between a zero and one bit. Unfortunately, different
versions of the chip require different timings, although it is possible to choose
timings which will suit all versions. Note the much longer latch pulse required
for the V4 chips. Also, while many chips expect colour data in the green, red,
blue order shown here, some use the more standard red, green, blue order.
Practical Electronics | January | 2021
Fig.6: it’s effortless to hook up an Arduino module to one of these LED arrays. You just
need to connect the grounds together, plus connect a 390Ω resistor from any of the
Arduino I/O pins to the DIN pin of the module. As mentioned in the text, due to the LED
current demands, a separate >1A 5V DC supply is needed to power the module(s).
After an exchange of emails with Mr
Mather, I learned that his CFUNCTION
had been written about four years ago
to suit the original WS2812 LEDs.
He suggested a couple of changes to
it to make the pulse timing more compatible with the WS2812B, SK6812
and WS2812B-V4 devices, and also
guided me regarding how to make the
changes easily without having to recompile his code.
I made the suggested changes and
tried it all again. Now the timing of
the pulse stream was much closer to
that needed by the WS2812B/SK6812
devices, and, lo and behold, the modules gave the correct displays from my
test program.
I then proceeded to write an expanded version of my original MMBasic test
program to provide readers with a suitable demo program to run on a Micromite. This program is called RGB LED
matrix test program.bas, and again,
you can download it from: the January
2021 page of the PE website.
This program displays a ‘rainbow’
of coloured stripes on the 64-LED
SW2812B/SK6812 module. It then
clears the module’s display for another
five seconds before repeating the
cycle. While simple, again I hope it
will give you a good idea as to how a
Micromite can be used to drive these
LED modules.
To achieve different kinds of display
(including dynamic displays), all you
need to do is use the MMBasic part of
the program to change the ‘pixel’ data
stored in the colours() array.
You can find some useful information
on this module in the following links:
http://bit.ly/pe-jan21-8x8a
http://bit.ly/pe-jan21-8x8b
http://bit.ly/pe-jan21-8x8c
Reproduced by arrangement with
SILICON CHIP magazine 2020.
www.siliconchip.com.au
Fig.7: driving a ‘neopixel’ LED array from a Micromite is nearly identical to an Arduino: the two grounds connected
together, and a 390Ω resistor (or just a direct connection) from one of the Micromite’s I/O pins to the LED array DIN pin.
The software is a bit more complicated, but if you start with our sample code, it should work straight away.
Practical Electronics | January | 2021
37
KickStart
b y M i k e To o l e y
Part 1: MOSFET switching devices in linear applications – introducing the 2N7000 ‘Swiss Army Knife’
Our occasional KickStart series aims to
show readers how to use readily available
low-cost components and devices to
solve a wide range of common problems
in the shortest possible time. Each of the
examples and projects can be completed
in no more than a couple of hours using
M
OSFET devices are available
in various forms, including
N- t y p e an d P -typ e, an d
enhancement or depletion mode types.
The 2N7000 is an N-type MOSFET
designed for enhancement mode
operation (see Fig.1.1). This simply
means that to turn the device ‘on’ (ie,
to make it conduct) it is necessary to
apply a positive voltage between the
gate and source of the device. For
the 2N7000, the required gate-source
voltage is in the range of 2V to 3V.
The device will conduct very heavily
when the gate-source voltage exceeds
about 3V, in which case the resistance
between drain and source (RDS) will
fall to the very low value required for
switching applications. However, with
gate-source voltages (VGS) of less than
2.5V the device can be used in a wide
variety of linear applications. This is
where this incredibly versatile ‘Swiss
Army Knife’ finds a whole new variety
of applications!
Fig.1.2. 2N7000 pin connections.
Fig.1.1. Construction of an N-channel
MOSFET device.
38
off-the-shelf parts. As well as briefly
explaining the underlying principles and
technology used, the series will provide
you with a variety of representative
solutions and examples, along with just
enough information to be able to adapt
and extend them for their own use.
This first part shows you how to use a lowcost MOSFET switching device in a variety
of linear applications. In keeping with
the KickStart philosophy, we’ve provided
sufficient information for you to be able to
design and build your own circuits using
this handy semiconductor device.
MOSFET basics
The construction of a typical N-channel MOSFET
device is shown in Fig.1.1.
The device consists of a
series of semiconductor
layers onto which an insulating metal-oxide layer
is deposited. Conduction
takes place between
source and drain in a
narrow N-type channel.
The degree of conduction
in this region is dependent
on the positive potential Fig.1.3. N-channel MOSFET test circuit.
present on the gate terminal. As the gate-source
voltage (VGS) is raised
beyond the threshold for
conduction (usually above
about 2V for the 2N7000)
conduction increases and
the drain and source currents (which are identical)
increase as a result. Thus,
the voltage present between the gate and source
controls the current flowing in the drain.
In manufacturers’ data
sheets, device properties
are usually summarised
both in the form of
tabulated data and as a
series of characteristic Fig.1.4. Output (drain) characteristics for a 2N7000
operating under small-signal conditions.
curves. Key data for
the 2N7000 is shown in Table 1.1, and
series of plots showing the variation
the two most important characteristic
of drain current (ID) with drain-source
curves are shown Fig.1.4 and Fig.1.5.
voltage (VDS) for different values of
The test circuit that we used to obtain
gate-source voltage (VGS). There are a
these plots is shown in Fig.1.3. Note
few things to note about these curves.
that the drain current (ID) needs to be
First, we have plotted these curves using
relatively small values of drain current
kept to a safe value in order to limit
that would be used in linear (rather than
the total power dissipation of 350mW
switching) applications. Second, note
quoted in Table 1.1.
the bend that occurs for values of VDS
The output characteristics
(shown in Fig.1.4) consist of a
below about 2V. .
Practical Electronics | January | 2021
