0 ratings0% found this document useful (0 votes) 85 views68 pagesElektor USA - October 2014
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content,
claim it here.
Available Formats
Download as PDF or read online on Scribd
[Link] mag azine
October 2014
lektor
Extremely Low Frequency (ELF) Receiver | PWM Control for Flashlight
Temperature Sensor Board | Dot Display Driver | Microcontroller BootCamp (6)
IoT & the Search for a Protocol | Lux Meter | Chip Tip: Magl2C-VDRM
Visual Basic on the Raspberry Pi | DesignSpark Tips & Tricks | Weird Components: Magnetrons
3D Printing Sure Can Be Useful | USB Fix @ Review: Atmel ICE Debuggger/
Programmer @ Retronics: a 1965 Telefunken Carphone(ektor
Projects
Extremely Low Frequency (ELF)
Receiver
‘You can in fact receive some
extremely interesting signals
between 0 Hz and about 20 Hz.
Using the receiver described here,
an ADC module, an Arduino and
some free PC software it is possible
to receive and make recordings of,
these signals.
PWM Control for Flashlight
“The main function of this unit is to
reduce the brightness of an LED at
the user's command.
‘An additional function is also
provided: the LED can be flashed
at full intensity, which can come in
hhandy for example when you are
walking at night.
‘Temperature Sensor Board
‘This board is equipped with an
‘ATtiny microcontroller and an RS
485 driver, and itis possible to
connect several sensors in paralle!
to one board.
In addition we present some
‘example firmware which
‘communicates temperature
readings using the ElektorBus
protocol.
Dot Display driver
‘An indicator for four ranges, based
‘on opamps, with LED readout.
Microcontroller BootCamp (6)
We delve into serial
‘communication—specifically,
using the SPI bus and associated
protocol.
ToT & the Search for a Protocol
Calling engineers and software
designers collaborate on a solid
protocol for IoT devices.
42. Lux Meter
Don’t believe the hype or the
manufacturer—with this instrument
you can reveal the real light
intensity produced by lamps.
56 Chip Tip:
Mag?°C-VDRM
“There's no end in manufacturers
honing the performance af the
voltage regulator. Here's a very
‘advanced one.
68 Visual Basic
on the Raspberry Pi
If Python is not up your street,
try something a little easier—say,
Visual Basic.62. One for Al
A technical look at the latest ICE
Debugger/programmer Atmel says
‘covers all of their AVR, Xmega and
ARM-Cortex devices.
© Industry
72 News & New Products
{A selection of news items received
from the electronics industry, labs
and organizations.
© DesignSpark
48 DesignSpark Tips & Tricks
Day #14: The Autorouter
This month we drop manual PCB
ok
Tension batt = Tension batt basse - Tension hysteresis —'6V-0V = 6.0V
If Adeval < Tension batt Then ‘ADC measurement and switching to low battery mode
Etat_led = 2
end Tf
2: ‘Low battery
+t = Tension_batt_dechargee - Tension_hysteresis '5,5V-8V = 5.5V
If Adeval < Tension_batt Then "ADC neasurenent and go to discharged battery
* mode - cut the load
Etat_led = 2
‘Tension_batt_chargee + Tension_hysteresis
Tension batt Then
case 3: ‘IF low battery/ cutoff LED
Tension_batt = Tension batt_chargee + Tension hysteresis °7,2V + ov = 7.2
If Adeval => Tension batt Then'ADC neasurenent and return
+ "0K mode "if battery is charged
Etat_led = 1
end Tf
End Selectcontinuously the state of charge of the battery.
This state is indicated using D2 as follows:
‘© green = battery charged;
+ orange = battery low:
‘red = battery almost fat.
It snot good for the battery to continue to dis-
‘charge it when its almost flat, and so in this last
‘case the microcontroller turns off all the LEDs in
the flashlight. The LEDs automatically light again
‘when the supply voltage increases sufficiently.
If the battery supply Is at 8 V then 1.5 V will
‘appear on pin 3 of IC1 and D2 will glow green.
If the supply falls to 6 V then the microcontrol-
ler will measure 1.14 V and D2 will glow orange.
‘At 5.4,V, with a measured voltage of just 1.0 V,
the LED glows red and the flashlight turns off
|When designing the cut, care was taken to min-
Imize its power consumption: it would be rather
‘a pity to throw power away needlessly in a LED
‘dimmer! It is for this reason that the battery level
Indicator LED flashes in all three of its states.
Schottky diode 01, type BAS70 or equivalent,
protects input PB4 from possible excess voltage.
‘Capacitor C1 (10 nF) serves to debounce switch
2. Should your switch be ofa particularly inde-
‘sive nature you may find that this isnot suffi-
‘lent and hence that the dimming action is not
‘smooth: before replacing the switch, try increas-
Ing the value of C1, say to 100 nf, and see ifthat
solves the problem.
‘Atype AP1117 voltage regulator provides power
for the circult at 3.3 V. although the LED chain
‘operates at a rather higher voltage (typically
7.2 V) the microcontroller Is isolated from its
supply by the MOSFET that switches its power.
Software
‘The program [1] was written using BASCOM-AVR.
Its easy to modify the code, and only the demon-
stration version of the compiler is needed. Having
‘set up variables with the thresholds for the various
battery states, we initialize Timer®, which han-
des PWM signal generation, and Timer, which is
responsible for the flashing of the battery status.
Indicator LED. The code spends most of Its time
walting for a command from the user. Further
down the code are the routines for indicating the
charge status of the battery and for applying the
thresholds to the A/D converter results to deter-
mine the state of the switch and pushbutton,
In ‘flash’ mode (when S1 Is pressed) the LEDs
are driven using the maximum possible pulse
width. A brief time-out filters out any contact
bounce that might lead to unexpected operation.
‘The comments provided inthe listing should help
guide you if you decide to make any changes
to It. For example, you may wish to increase
the speed at which the brightness increases or
decreases. This can be done by reducing the
value ofthe variable Pas or by changing the PWM.
period from the value provided. The unit can be
‘made to respond more quickly to S1 by reducing
the debounce timeout in variable Tenpo_bp_on_
‘value. Finally, you might want to alter the intial
PWM value (and hence brightness at switch-on)
from the default (Pwn = 100).
Construction
‘The printed circult board design Is shown in Fig-
ure 2. The compact layout Is achieved using
‘surface-mount components, and this allows the
board to be fitted easily into a cylindrical-style
flashlight. However, we did encounter some unex-
pected problems with certain models where the
transparent tube was so firmly glued to the other
parts that it proved Impossible to separate them
‘without damage.
‘Once the flashlight Is disassembled the only elec-
trical modification to be made is to disconnect the
‘common ground connection of the LED chains
(which are often arranged as thirty series pairs
all wired in parallel). The red cross In the circutt
diagram (Figure 1) shows where the connection
Is broken. A wire must be soldered at this point
‘connecting the bottom of the LED chain (or chains,
as the case may be) to the terminal on K3 which
In tum connects to T1. Two further wires connect
tthe flashlights ground connection and the positive
battery terminal to K1. Then all that remains to
bbe done Is to make two holes in the flashlights
body where S1 and S2 can be mounted.
(40019)
Internet Link
[11 www [Link]/140019
Figure 3.
If luck ison your side you
will find a flashlight model
‘ike this one that can easly
‘be disassembled and then
‘reassembled withthe
‘immer circuit inside.Design:
André Goldberg,
Mauk van der Laan
and
Ton Giesberts
Ted: Jens Nickel
Temperature Sensor
Board _ with RS-485 interface
‘Temperature sensors are needed in many automation applications, and the RS-
485 interface allows reliable communication of data even over long distances. Our
compact temperature sensor board is equipped with an ATtiny microcontroller
and an RS-485 driver, and it is possible to connect several sensors in parallel to
one board. In addition we present some example firmware which communicates.
temperature readings using the ElektorBus protocol, and software to display the
‘Our series of articles on the ElektorBus in 2011
‘generated a lot of interest among readers. We
received hundreds of e-mails containing useful
hints and tips or describing homebrew projects
Using the bus. One notable fan of the Elektor-
Bus Is André Goldberg, who bullt an ambient
temperature measurement and control system.
‘An Important aspect of the project Is the use
‘of ElektorBus nodes with temperature sensors,
which transmit readings to his PC.
Part of the appeal of the ElektorBus protocol
Is its simplicity. For example, each message Is
‘exactly 16 bytes long. The payload from a sen-
sor board can carry four Integer readings (In the
range -1023 to +1023) to a central control unt:
these might represent the outputs of four con-
nected temperature sensors. A message going in
tthe opposite direction can, for example, instruct
the sensor unit whether to report temperatures
{In Celsius or Fahrenheit, or specify the interval
between consecutive readings. The ElektorBus
protocol provides commands for al of the above,
see [1].
‘An RS-485 interface Is used for communication. In
hhalf-duplex mode this requires two signal wires,
and a separate ground must also be provided
(see [2]). RS-485 Is in theory highly immune to
Interference, and at the data rate used on the
ElektorBus (9600 baud) communication over dis
tances in excess of 30 m Is possible.
Mini bus nodes
We have previously published circult designs and
printed circutt boards for ElektorBus nodes [3][4].
However, for many applications these boards are
physically too large. André Goldberg gave somethought to the question of how small the a bus
node board could be made: the design that he
delivered to our labs measures just 18 mm by
26 mm. It includes an ATtiny microcontroller in
‘an SMD package, which offers six GPIO pins. The
RS-485 driver Is of course also an SMD device.
Solder pads are provided to connect the bus lines,
‘and likewise the in-system programming pins of
the microcontroller and two GPIOs are also only
brought out to solder pads, all in the interests,
of saving space. The external oscillator was also
dispensed with, and the temperature sensor is a
10S18S20 one-wire device. This consumes only
‘one GPIO pin on the microcontroller as it uses
‘a special asynchronous protocol for communt-
‘cation that removes the need for a clock signal
to accompany the data signal, The data signal
‘even provides power to the sensor: see the data~
sheet [5] for more details. Furthermore, several
‘one-wire sensors can be connected to a single
pin on the microcontroller: each sensor includes
‘a preprogrammed unique 64-bit 1D code, and
the microcontroller can use the 1D to address a
particular sensor and receive a reading from it.
‘The DS18S20 outputs 9-bit readings with a res-
olution of 0.5 °C.
Challenges ahead
‘The proposed hardware design creates several
challenges on the software side.
‘© The ATtiny45 has no hardware UART that
can be used to drive the RS-485 interface
IC. This means that the UART (both transmit
and receive parts) needs to be implemented
In software. An advantage Is that the two
GPIO pins used can be chosen arbitrarily.
‘© A library Is needed to read the one-wire
sensor devices, using one further GPIO pin.
Since we may have several sensors con-
nected to the same pin, the microcontroller
will also have to store the IDs of the individ-
ual devices so that the results can be output
In the correct order.
‘© The ATtiny does not have enough program
memory to contain the whole ElektorBus
protocol library that we have described pre-
viously [6]{7]. The required parts of the pro
‘tocol will need to be reimplemented by hand.
André Goldberg decided to take advantage of
‘two open source libraries, one for the software
UART and one for the one-wire bus. During the
configuration process the addresses of the indi-
vidual sensor devices are read out and stored in
the microcontroller’s EEPROM. The readings from
the four sensors are multiplied by ten so that the
‘temperatures in Celsius with a resolution of 0.1 °C
are represented as integers in accordance with
‘Component List
Resistors (0805)
Ri= 2.20
foaa~ ana.
Ra'= 1200
RS,ae = tka
Capacitors
C1,C2,C4 = 100nF 25V, 10%, X7R, SMD 0805
(C3'= 10uF 25V, 10%, XSR, SMD 0805
C5 = 100uF 16V, 20%, tantalum, SMD Case F
‘Semiconductors
D1 = PMEGZO1OAEH
D2 = LED, yatow, SMO 0805
D3 = LED, green, SMD 0805
ICL = ATiny85-20SU, SMD S0-852
IC2= 14785, SMD S0-8
14 = 78L05
Miscellaneous
‘Ki, Ka =2-pin pinheader, 0.4 inch pitch, right angled
3 = 3-way PCB screw terminal bloc, 0.2 inch pitch
PCB ret 130468-1 V2.0
13 = Sihe quartz oscilator, Se7mm, SMD (LF SPKOO19079)
‘k2'= 6-pin (2x3) pinneader or baxheader, 0.1 inch pitcn
Figure 1
“The single-sided circuit
board measures just 1.14
by 1.5 inch (29 mm by
[Link]). The headers are
‘mounted on the underside.Figure 2.
The crcl centers around
the Any. Oly one
in (PE) i needed by
the sofrare UART as
transmission and reception
‘never occur simultaneously.
the ElektorBus protocol. The remaining bytes in
the ElektorBus protocol packet are ‘manually’
assembled into the code.
The circuit
In the Elektor Labs old hand Ton Glesberts imme-
diately set about thinking how to ‘Elektorize’ the
board. We decided to allow for the possibility of
soldering in header pins or screw terminals for
all the connections if desired, and we added a
crystal oscillator for more reliable communication:
this Is particularly important if the circult Is to
bbe subject to extreme variations in temperature.
Nevertheless Ton managed to keep the board
‘small: the final design measures about 31 mm
by 32 mm (see Figure 1) [8]. The board Is dou-
ble-sided, with the ElektorBus screw terminals,
the two-by-three programming header and the
two two-pin headers for the power supply and
for connecting the one-wire sensors located on
the back of the board. The SMD components can
be soldered by hand.
Our freelance colleague Mauk van der Laan found
a significant improvement that could be made to
the circult. Instead of using two of the six GPIO
pins forthe transmit and receive connections for
the software UART, we use only one pin, switching
‘ts function between input and output as needed.
Because communication on the RS-485 bus Is.
half duplex, a node never needs to speak and lis-
ten simultaneously; collisions between messages
have to be avoided. The advantage of saving a
(GPIO pin is that we can use It to drive an LED to
Indicate the status of the node.
‘The circult diagram Is shown in Figure 2. The
central component is the ATtiny85 [9], which has
‘more flash memory than the ATUny45. All sx port
pins are used, in some cases for more than one
purpose. The one-wire temperature sensors are
connected to PB4 via header K1. PB3 Is driven
by the SMD crystal oscillator module. The SPI
Interface on PBO, PB1 and PB2 and the reset pin
PBS form the ISP interface that allows code to be
loaded into the AVR microcontroller. In normal
operation PEO drives the status LED.
The level on PB1 determines whether the RS-485
transceiver Is In ‘transmit’ mode (PB1 high) or
‘receive’ mode (PB1 low). PB2 Is the pin which,
‘as described above, carries the UART data being
transmitted or received.
‘The RS-485 signals are connected to K3. The
120-9 termination resistor can be fitted or omit-
ted as required.
Configuration
We provide standard firmware to run in the
‘ATtiny85: its of course open source and is avail~
able for free download at [8]. Mauk van der Laan
hhas incorporated in the code a software UART
library, a one-wire Interface library (modified
from an Arduino library) and a small ElektorBus
Interface. The whole thing Is controlled by a kind
of operating system that provides rudimentary
‘multitasking (see the text box for more details).
More advanced users will find studying the com-
mented C++ code very rewarding.
Up to four DS18S20 temperature sensors can be
connected in parallel to Ki. In this configuration
the datasheet instructs us to tie the VDD pin of
each device to ground so that each sensor derives
‘its power from the data line. The software uses
an area of EEPROM ('slot one’ to ‘slot four’) In
the ATtiny to store the IDs of the temperature
sensors. When power is applied to the node the
microcontroller extracts the ID from each sensor
‘ver the one-wire bus. It then compares them
with the stored IDs. If @ stored ID is not found
fn the bus, then that ID Is deleted and the stor-
age slot becomes free. If an ID is seen on the
bus that does not match a stored ID, It s stored
In the first free storage slot.
It Is now clear how we configure the system. First
attach Just one one-wire sensor and apply power
to the board. The ID of this sensor will be storedInthe first storage slot. Its a good idea to label
this first sensor ‘0’ (assuming that programming
In C has taught you to count from zero; if you
are 2 BASIC programmer you may prefer to label
it ‘11. Then disconnect the power supply, add
the second sensor in parallel at K1 and power
tthe board up again. This will store the 1D of the
ssecond sensor In the second slot. Repeat the
process for the third and fourth sensors.
“The progress of the configuration process is neatly
Indicated by the status LED. When the software
starts running the LED blinks rapidly. It then
flashes four times, each flash being etther short or
long. A short flash corresponds to an unused stor-
age slot, a long flash to a recognized ID address.
If its desired to remove a temperature sensor
(even if ts storage slot is not known) the sys-
tem can simply be powered down, the sensor
disconnected, and the system powered up again.
‘The corresponding slot will be freed. The process
described above can then be repeated to add a
new sensor.
o one
of 0 Fo | + RRA] ae
tf [+ [olo)o| 0) 0 |e
0 op fan
A ean sexe
ElektorBus interface
‘The four temperature sensors correspond to four
‘subnodes’. Our standard firmware periodically
sends the four temperature readings packed into
a single ElektorBus message, taking advantage
of the ‘channels’ within the message payload.
Each channel can carry a value from -1023 to
+1023 [1], and each channel occupies two bytes
within the message payload. The four channels
‘occupy bytes 6 to 13 of the payload, counting
from zero. The transmitter address in bytes 4
Figure 3.
Structure of a message to
set the interval between
readings on the temperature
sensor board (only bytes
i to nine shown).
“Interval scale’ is 9, which
is the code for tenths of a
second. The ‘channel bits
‘in principle could allow
diferent intervals to be set
for different temperature
‘sensors, but they are
‘not used in the standardand § Is fixed at ‘S’ in our node. Bytes 2 and 3
contain the receiver address, fixed In our stan-
dard firmware at ‘10’. Bytes 14 and 15 (check-
sum/CRC) are not used.
ber of sensor boards on a single bus. In so-called
‘direct mode’ collisions are avoided very simply
by having a fixed pattern of transmissions. The
sensor node sends the temperature readings at
specified intervals to the ‘master’ (normally the
control software running on a PC). If the master
wants to send a command to the sensor node It
Figure 4.
The sensor board sends its
readings tothe PC over the The standard firmware is designed for one-to-one
S-485 bus. ‘communication rather than for use with a num-
waits until it receives a message containing tem-
perature readings and then sends its message
in the pause immediately thereafter. At the nor-
‘mal bus speed of 9600 baud a message repeat
Interval of under 100 ms is possible; however,
the conversion time of the sensor devices is con-
siderably longer than this (It can be as high as
750 ms) and so a message repeat interval of a
few seconds Is a better choice.
‘Mauk’s firmware sends temperature readings (in
Celsius, multiplied by ten) from all of the sen-
sors it has identified at a default interval of 1 s.
‘The node also listens for commands to change
the interval, the other possibilities being 5 s and
'500 ms (see Figure 3). The units used for the
temperature values can also be changed to Fahr-
enhelt and back to Celsius. When the sensor
‘The standard firmware was written by Mauk van der Laan, @
freelance software and electronics developer. Mauk’s software
is modular and includes a specially-designed operating
system based on state machines to ensure the correct timing
of the execution of tasks: see below.
The file ‘Onewire.h’ contains the one-wire interface library.
“[Link]/-h’ is the state machine that is responsible
for detecting the devices’ IDs and for reading temperature
values from them.
‘The software UART driver ‘[Link]/.h’ which is
used for half-duplex RS-485 communication is derived from
‘an open-source RS-232 library. The ElektorBus interface
“[Link]/.h can, however, also work with @ hardware
UART. The line
Haefine ELEKTORBUS_ORIVER_INCLUDE
“ElektorBusSwlw.h”
in the file ‘config.h’ causes ‘[Link]’ in the
standard firmware to access the software UART library.
“[Link]/.h’ is the state machine that controls the
bus interface.
Seeker
‘The operating system offers so-called ‘cooperative
‘multitasking’. In contrast to preemptive multitasking a task
is never interrupted by another: instead, it yields control
‘voluntarily to the scheduler when itis ready. This means
that no interlock mechanism is needed to prevent a task
being paused at an inappropriate point. Also, unlike more
heavyweight embedded operating systems such as FreeRTOS,
‘the tasks do not have their own stacks. Each task just has a
single state variable, and so memory usage is minimal: the
‘operating system can run on an ATtiny with just 8 Kbyte of
flash memory and 2 Kbyte of RAM.
‘The individual tasks are implemented using state machines.
‘The entire code for each task is expressed in a switch-case
block: depending on the value of the state variable a different
section of the code will be executed. When its actions are
complete, the task calls the method nextState() which
returns control to the main task (also called the ‘runtime’.
‘Alternatively the task can call nextDelay() with an argument
specifying a delay in milliseconds. This constitutes a request
‘ot to call the task again until the specified time has elapsed.
‘The scheduler in the runtime maintains a list of running
tasks, each of which is derived from the “Task’ class. Thenode receives a command message of this type,
the next regular message it transmits will con-
firmation of its current units and scaling (and @
‘message containing temperature readings will be
lost). Subsequent messages will contain read-
Ings as normal. Since the reading in Fahrenheit
can easily exceed 102, the sensor automatically
switches from a scaling value of ~1 (tenths of a
degree) to 0 (whole degrees) when a command
to use Fahrenheit units Is recelved.
PC software
‘An ordinary terminal emulator program Is suff-
cent for an initia test, at least to check that the
board is indeed outputting readings at one-sec-
ond intervals. We have also written some cus-
‘tom demonstration software for the PC. The user
Interface Is as usual written in HTML and JavaS-
Cript. The software download [8] contains the
software [Link] and the folder
UIBus, which should be dragged to your desktop.
‘The sensor board Is connected using Its RS-485,
Interface and the Elektor RS-485-to-USB con-
verter [3], whose USB port Is plugged Into the PC
(Figure 4). On launching the ElektorBusBrowser
‘you must set the number of the COM port that Is
allocated to the RS-485-to-USB converter at the
top of the screen, and then click on the ‘Connect’
Figure S.
‘The user interface on the
PC is as usual based on
HTML, Using the inter
button. Ifthe sensor node is running and cor- fe posse te adja the
rectly configured the readings should now appear measurement interval and
fon the screen. Commands can also be sent to the temperature unts used.
‘scheduler calls the execute() method of each task in turn
(unless it has requested a delay which has not yet expired).
Each task should run for just a short time (perhaps a few
hundred cycles) to maintain the illusion of full multitasking.
The foll
19 example code shows a task that flashes an LED.
class BLinkTask + public UserTask {
‘enum States (Idle, BLinkingon, BLinkingort};
pubtte:
void start()
nextState(BLinkingon) ;
3
void stop() {
nextState(Idte) ;
d
private:
void turnon()
ord turnorr();
virtual void execute();
virtual byte getTaskid() { return BLINKTASK1D; }
votd BLinkTask: :execute() {
switch(state) {
‘case BLinkingon:
500 ms
‘turnon() 5
nextDelay(BLinkingort, 506);
retur
case Blinkingorf:
500 ms
turnort();
nextDelay(BLinkingOn, 500);
returt
derautt:
pante (1
11 turn the LED on and wait
11 turn the LED off and wait
// Anvalid state: give upFigure 6.
‘Simulation using an
‘Arduino Uno and the Elektor
‘extension shield. This node
behaves exactly lke the
‘temperature sensor board
‘onthe EiektorBus.
the node, but itis necessary to tick the ‘Direct
Mode’ check box first.
‘The user interface is straightforward and should
be self-explanatory (Figure 5). The labels “°C’
and ‘°F’ next to the temperature values only
‘change when a message is recelved from the sen-
sor node confirming the receipt of a command to
‘change units. The change In scaling factor is also
taken into account. To take a look at the HTML
and JavaScript code, cick on the ‘Source’ button.
If you also have the Andropod Android bridge
board, you can couple the temperature sensor
board with an Android smartphone or tablet [10].
‘The HTML and JavaScript user interface works
equally well in the ElektorBusBrowserForAndro-
‘pod, which can be downloaded for free from Goo-
le Play.
‘Simulation
‘Since the standard firmware for the board was
‘not available at the time we were writing the
PC control software, we simulated a tempera-
ture sensor node using an Arduino Uno board
fitted with an Elektor extension shield [11] and
‘an RS-485 module [12] (see Figure 6). The sim-
ulated temperature values are generated using
‘a potentiometer and are shown on the display in
tenths of a degree Celsius. The Arduino Uno sends
the simulated value to the PC in channel 0, and
of course this happens at fixed intervals. It also
‘responds to control commands issued by the PC
In exactly the same way as the standard firmware
running on a real sensor node. The source code
for the ATmega328 Is also avallable for down-
load [8]: itis based on the EFL 7] and uses the
ElektorBus library. The ‘Hardware’ directory of
the Atmel Studio project contains the code files
for the Arduino Uno, the Elektor extension shield
and the RS-485 ECC module. These make the
higher layers of the software independent of the
hardware and they are in tum independent of one
‘another. Further software for the new shield will
bbe presented in our next issue.
Of course the standard firmware and the Elek-
torBus protocol are not set in stone: you are free
to write your own software and design your own
protocols. Different sensors, switches and even
‘actuators can be connected to K1: port pin PBS
can easily be used to generate digital signals or
to measure voltages. If you do some up with a
‘new use for the board, please drop us an e-mail
to let us know or tell us at [Link].
(120468)
Web Links
[1] www [Link]
[2] www [Link]/ 110225
[3] wow [Link]/ 110258
[4] www [Link]/ 110727
[5] http:/[Link]/en/ds/[Link]
[6]_wwew [Link]/ 120582
[7] [Link]/120668
[8] [Link]/130468
[8] [Link]/atmel-2586-avr-8-bit-microcon-
troller-attiny 25-attiny4S-attiny85_datasheet. pdf
[10] [Link]/110405,
[11] [Link]/140009
[12] www [Link]/1301558y Clemens Valens
(Giektor Labs)
Dot Display Driver
‘There are situations when it is useful to scale the dynamic range of a signal down
to a few coarse sub ranges. As an example you can think of an indicator that
‘Several solu-
tions to this design chal-
lenge exist, like the ever popular
LM3914 (also avallable as NTE1549, and its
siblings LM3915 and LM3916) with Its convenient
‘moving dot mode, or a microcontroller with an
analog Input. The LM3914 Is easy to use but It
does not offer much control over the way the
Input signal is quantized. A microcontroller gives
you all the flexibility you can wish for, but it
requires programming. The circutt presented here
allows full control of how the input signal is quan-
tized but It does not require any programming
apart from calculating a few resistor values.
‘The craut s straightforward. A multi-output volt-
‘age divider is dimensioned to cover all the ranges
that matter. Each voltage divider output Is com-
pared to the input signal; when the latter exceeds
the former, the corresponding comparator out-
put swings High. This is all standard stuff, but
not good enough, since when the Input exceeds
2 certain level, all the comparators below this.
level will go High instead of just the last one. Our
{goal is to have only one active output for each
level, not several. To paraphrase the LM3914's
datasheet, our circuit must be in ‘dot’ mod, not
“bar graph’ mode.
‘Adding (moving) dot mode can be achieved
by making the higher level comparators con-
trol the comparators below them in some way,
does not show the exact speed of a motor, but only a few values
like Off, Slow, Medium, Fast and Too Fast. Such
signals can easily be obtained by
low-pass filter-
ing) amplitudes, frequencies or
pulsewidths of signals produced
somewhere in the system that
you want to keep an eye on.
for instance by forcing their outputs Low or
by disabling them. In this circuit every com-
parator controls the output of the comparator
directly below it with a PNP transistor. So how
does this work?
When two consecutive comparator outputs are
Low, the base and emitter of the transistor
between them will both see the same voltage.
Consequently the transistor will switch off and 50
wll be the LED driven by t. When the lower com-
parator output goes High while the upper stays
Low, the transistor is switched on because its
emitter voltage will be high enough with respect
to ts base voltage, hence the corresponding LED
vill ight up. If now the upper comparator output
becomes High too, the base and emitter voltages
are again the same, causing the transistor to
block and the LED go out. In short, an LED can
only shine ifthe comparator output straight above
it is Low while the comparator output straight
below itis High. This assures that only one LED
at a time can be on: the circuit is in dot mode.
“There is a subtlety to this circuit that you have
to be aware of. It lurks in the comparator out-
put or, to be more precise, in its impedance. My
‘experiments involved a single-supply rallto-rall
(SS-R2R) opamp type TS924, and everything
worked perfectly fine. However, when I checked
the availabilty ofthis opamp, I discovered that
Ithas become obsolete and that is replacement,the TS924A, Is hard to get in a DIP package. So T
‘switched to another SS-R2R op-amp, an LMC464
that I happened to have handy. To my surprise,
with this chip, my circult no longer lit just one
LED, but It also the LED right below It. Not too
bright, but more than enough to be noticed. The
cause Is its rather high impedance making the
‘output of the new op-amp drop as a quite steep
function of the current it has to deliver. Suddenly
the high level was not so high anymore, allowing
the transistor driven by this output to turn on
slightly because the transistor’s base voltage no
longer equaled its emitter voltage.
Checking the datasheets of both opamps
explained it all. The TS924A, a pretty cool opamp
that I heartily recommend, remains close to R2R
with loads as low as 600 whereas the LMC464
Is specified for loads of 25 k2 or higher.
Okay, so the LMC6464 was a bad idea, but what
about the good old LM324? With this chip the
circuit worked almost fine even though the LEDs
were a bit less bright, the LM324 high output
level being about 1.5 V below its supply voltage.
‘This created a problem for the lowest LED (Off)
because I had tied the emitter of its controlling
transistor to 5 V, too high for the opamp out-
put to make the LED shine continuously. Adding
two diodes In series with the emitter fixed this
problem.
‘The Input stage of the circult Is experimental;
1 just plugged some random component values
Into the schematic because It all depends on
your input signal. I did my experiments with a
3-V 22-kHz PWM signal and got excellent results
with C1 = 220 nF and R15 = 2.2 kA. The PCB
was designed in such a way that capacitors of,
up to 10 pF should fit without problems. High
er-value parts should work too, but hovering over
R1S and R14.
‘Adjust P1 to scale the quantization levels. Note
that the scale in the schematic Is linear thanks
to resistors R5-RB having Identical values, but
this Is by no means obligatory.
Instead of the LEDs you can mount a pinheader
to connect the board to, say, another one with
relays on it. Do not forget to buffer the outputs
If you have to drive heavy loads (to avoid the
problems described above). Think ULN2003, for
Instance.
Web Link
[Link]
Figure 1. Dot Display Driver
(000) schematic.
‘Component List
Resistors
(0.25)
R9,RL0,R4,R42,R13 = 3900
AR2,F3,R4,R,R6,R7,RB = 47K
1,02 = 1na148
Ici = uMa24
{LEDI,LED2,LED3,LED4,LEDS = LED, red, 3mm
Ti-Té = BCSS7C
Miscellaneous
Ki = 3:pin pinheader, 0.1" pitch
Pea iaotti-tFigure 1.
‘Connecting a type 4094 shift
Microcontroller
BootCamp (6)
The SPI interface
Serial communication with each unit of information following the previous one is
actually the normal situation. That’s how we talk to each other in person or by
phone, read and write text—or in the case of Retronics: send telegrams.
In many cases all you need is a single line to transmit data. However, adding a
clock line makes things more reliable. Let’s find out.
‘On the Serlal Peripheral Interface (SPI) bus, the
actual data travels bit by bit over one line—for
‘example from a microcontroller to a display, an
EEPROM or an SD card. In most cases It's also
desirable to be able to read data, so you need a
‘second line to provide a return channel for the
data. There's yet another part to the picture: a
‘lock line. The clock signal always clearly indl-
‘cates when the next bit Is available on the data
line. That eliminates the need for precise agree-
ment on data timing, which both parties have
to supervise with timers. With these three lines,
data transmission Is fairly bombproof.
Port extension with a shift register
‘The first thing we want to try out is actually not
an SPI interface, but instead something entirely
different. Shift registers have been around for
‘a long time (before microcontrollers were eveninvented) and are good for understanding how
serial data transfer works. They can also be put
to good use in combination with a microcontrol-
ler. That’s because port lines are always scarce,
especially on Arduino boards. A port extension
with a shift register can help ease the scarcity.
With a type 4094 8-bit shift register, you need
three lines to talk to It and you end up with
eight new outputs. You can increase this to 16
by connecting a second shift register, or even
80 if you connect ten shift register ICs in series.
If you need a lot of outputs, that’s an especially
low-cost way to meet the requirement.
Figure 1 shows the connections to the Uno board.
The 8-bit shift register has a clock input (CL)
and a data input (D). The data Is applied to the
D input one bit at a time, starting with the most
significant bit, and a rising edge is applied to the
clock input CL for each bit. The data is shifted
through the individual flip-flops of the register
step by step with each clock pulse. There Is also
the strobe input STR. When a pulse Is applied
to the strobe input, all the data present in the
shift register is transferred to the type-D flip-
flops connected to the output pins. You could
also tle the strobe input to the supply voltage
\Vce, but then all the intermediate results of each
shift operation would appear on the outputs. By
contrast, if you apply a strobe pulse after all the
bits have been shifted in, you only see the final
result on the outputs.
The software for all this (Listing 1) is simple. To
‘output a byte D, the code first copies the most
significant bit to the bit variable B (B = D.7)
and puts it on the corresponding port pin. It
then generates a positive clock pulse on CL with
a length of 1 millisecond. A microsecond would
also be sufficient, but the slower output Is easier
to see on an oscilloscope. After the clock pulse,
a shift instruction (shift 0 , Left) causes all
bits of D to be shifted left by one position. This
puts what used to be bit 6 on the output. This
process is repeated until all eight bits have been
shifted out. At the end comes the strobe pulse,
and then all eight bits are present at the outputs
of the 4094.
The code continuously increments the data byte
to be transferred so the outputs of the shift regis-
ter change while the program Is running. The
current value Is shown on the LCD if the Elektor
Extension shield is fitted, and it is output to the
terminal emulator. This makes it easy to com-
pare the output levels of the shift register to the
digital value being output.
If you need more than eight outputs, you can
use the Qs output of the 4094 IC. Each bit that
is clocked into the shift register appears at the
Listing 1. Output using a shift registe
‘UNO_shift.BAS Shift Register 4094
Sregfile = "[Link]”
Serystal = 16000000
$baud = 9600
Dim Dat As Byte
Dim D As Byte
Dim N As Byte
Dim B As Bit
Sr Alias Portb.4 "4994 pin 1
Da Alias Portb.3 '4994 pin 2
CL Alias Portb.2 "4994 pin 3
Config Portb = Output
cs
Led Dat
lca"
Print Dat
D = Dat
For N=1T0 8
B=D.7
Da=8
Wattms 1
asl
Wattns 1
case
Wattns 1
shift D, Left
Next N
sr=1
Wattms 1
sr=0
Waitms 1
yt = Dat + 1
Waitms 500
Loop
EndQs output eight clock pulses later. The D input of
the next shift register can be connected to this
output. In this way you can connect as many
4094 ICs In series as desired, with the clock and
strobe lines connected to all of them in parallel.
Of course, the software will have to be modi-
fied accordingly. First it shifts out all of the bits
necessary to fill the chain of shift registers (e.g.
16 with two ICs or 80 with ten), and then it out-
puts the common strobe pulse.
Manual data transmission
Although you only need one line for the data, you
also need a clock line when you use a clocked
serial interface, as in the above example with a
shift register or with the SPI bus. If you compare
this with Morse telegraphy, for example, you can
see the difference. There both parties have to
agree on the transmission rate, and no breaks are
allowed within an information unit. For example,
if a radio operator wants to send an “x” (dash
dot dot dash) and stops in the middle to scratch
his head, the two characters “N” (dash dot) and
"A" (dot dash) are sent instead. The situation Is
exactly the same with an asynchronous serfal data
Interface, where both parties have to agree on
the baud rate. After the transmission of a byte
has started, all of the bits must be sent within
a precise time frame. By contrast, with SPI the
timing Is not critical and any desired delays are
allowed. The additional clock signal makes the
transfer entirely independent of the speed. No
matter whether the data rate Is just one bit per
minute or a million bits per second, the data will
Listing 2. SPI master and slave (very slow).
'UNO_spi1.BAS Shift in/out
$regtile =
Serystal
Sbaud = 9600
Dim D As Byte
Dim B As Bit
Dim N As Byte
S1 Alias Pinc.0
Portc.@ = 1
$2 Alfas Pinc.1.
Portc.1 = 1
Ledl Alias Portc.2
Darc.2 = 1
Led2 Alias Portb.2
Ddrb.2 = 1
Do
‘D = Rnd(255)
cs
Led D
Print D
Locate 2, 1
For N=@To7
B=D.7
Led B
Print B;
Led2 = B
Waitns 300
Ledl = 1
Wattms 200
Ledl = 0
Waitms 500
Shift D , Left
Next N
Ledi = 0
Led2 = @
waitms 2600
cs
Print
D=0
Do
Loop until Si = 1
For N= To7
shift D , Left
Do
Loop Until $1 = 0
If S2 = 0 Then B= 1 Else B
D=0+8
Led B
Print B;
Wattms 100
Do
Loop Until Si
wattms 160
Next N
Print
Locate 2, 1
Led D
Print D
Wattms 2600
Loop
Endbe transferred properly. On an SPI bus there is
always an SPI master and an SPI slave. Data can
travel in both directions, but the master ways
generates the clock signal.
‘You can try this for yourself manually, where you
(@s the user) assume the role of master. You can
transmit a byte by pushing the two buttons S1
and S2 (Figure 2). This Is not the usual way of
doing things, but it helps you understand exactly
how it works. One of the buttons Is for the data,
and the other Is for the clock. Aside from that
there’s nothing new you have to learn, since you
already know how a byte Is put together. Here's,
how it works: First you send bit 7. If it is a‘1',
‘you press and hold button S2; otherwise you
don't. Then you press button S1 briefly without
changing the state of $2. The receiving end (the
slave, which in this case is the Arduino board)
then knows when it should read the bit from the
data line. Now you repeat the process for bit 6,
bit 5, and so on until bit 0.
‘The program in Listing 2 displays the data in
both directions. At first the microcontroller is
the master and you are the slave. A byte with a
random value is sent, with the clock signal indi-
cated by LED1 and the data indicated by LED2.
If you watch carefully, you can read the trans-
mitted byte. However, that’s not easy, so the
byte Is also shown on the LCD and sent to the
terminal emulator. The individual bts also appear
one after the other on the LCD and the terminal
emulator screen:
83
e1019011,
‘Then the roles change. Now you are the master,
and your job Is to send exactly the same byte
back to the microcontroller. Here you can see that
the ability to send data at any desired speed is a
big advantage, since you can take all the time you
want to decide which bit value to send next. For
example, suppose you want to send the decimal
number 100. Bit 7 corresponds to decimal 128,
which is more than 100, so it is ‘0’. Next comes
bit 6 with a value of 64, so it’s a‘1', and you're
left with 36 still to send. This means that bit 5
(32) Is a1, which leaves 4. The next two bits
(bit 4 = 16 and bit 3 = 8) are ‘0’, bit 3 (4) isa
1’, and the last two bits are ‘0’. Now you have
sent the binary number 01100100, with each bit
‘marked by a clock pulse. It may not have been all
that easy, but the microcontroller had no problem
reading the data. You can regard this as a test
of your concentration, and if the LCD shows the
right result, you pass the test,
If you look closely at Listing 2, you will see that.
the bits are inverted when they are read. That's
because pressing the data button yields a zero
bit value. This Is not especially intuitive, so the
result Is inverted when the bit Is read to make
things easier for you. Another interesting aspect Is
using the instruction D = Rnd (255) to generate
a pseudo-random number. In fact, this always
generates the same sequence of numbers, but
the Bascom Help glves some suggestions for what
you can do about this.
From microcontroller
to microcontroller
In this example, data is sent over the SPI bus
from one microcontroller to another. The data
Is this case consists of 10-bit readings from the
‘A/D converter. This shows another advantage of
SPI, which is that the data width is not fixed. No
matter whether you send 8, 10, 12 or 16 bits,
the procedure is always the same. If the only
objective were to connect two microcontrollers
together, it would actually be less effort to use
an asynchronous serial interface with the TXD
and RXD lines. The SPI bus, by contrast, is better
for controlling and communicating with external
Figure 2.
Manual input and output.isting 3. SPI master.
*UNO_sp12.BAS SPI Master cts
Cursor off
$regftle = "[Link]"
$crystal = 16000000 wattms 200
Sbaud = 9600 Do
Dim B As Bit Dout = Getadc(3) "Pot
Dim Dout As Word Locate 1, 1
Dim N As Byte Led Dout
Dim I As Byte led
cs=0
Sck Altas Portb.5 Wattms 26
Darb.5 = 1
Most Alias Portb.3
Darb.3 = 1
Cs Altas Portb.2
Darb.2 = 1
Cs=2 wattms 1
Most = 6 Shift Dout , Left
Sck = 0 Next N
csel
Config Adc = Single , Prescaler = 32 , Wattms 100
Reference = Avcc Loop
Start Adc End
Listing 4. SPI slave.
Portb.2 = 1
*UNO_sp13.BAS SPI Slave
$regfile = "[Link]” Do
Scrystal = 16000000 Do
‘$baud = 9600 Loop Until Cs = 6
Din=0
Dim Addr As Byte
Dim B As Bit
Dim Dout As Word
Dim Din As Word
Dim N As Byte
Dim I As Byte
S1 Alias Pine.
Portc.@ = 1
2 Alias Pinc.1.
Portc.1 = 1
Sck Alias Pinb.S
Portb.5 = 1
Mosi Alias Pinb.3
Portb.3 = 1
Cs Alias Pinb.2
For N= 1To 10
Shift Din , Lett
Do
Loop Until Sck = 1
Din = Din + Most
Do
Loop Until Sck = 0
Next N
Do
Loop Until Cs = 1
Locate 1, 1
Led Din
tea"
Print Din
Loop
EndMaster
ee
se
hardware. Here the main purpose of the exercise
Is to illustrate the transmission protocol.
As previously with the 4094 shift register, a third
line Is involved here—In this case the chip select
line /CS. The slash (/) means that the signal on
this ine Is active Low. The chip select line allows
you to connect several slave devices to a single
‘master. In that case they share the data and clock
lines, but each one has its own chip select line.
When that line is low, the corresponding slave
knows that it is selected. There's also another
benefit from using a chip select line. If there is
any delay in enabling the slave, there may be
some confusion about which bits have already
been transferred. However, ifthe slave waits until
It sees a falling edge on its CS input (high to low
signal transition), It knows that the transfer is
starting. And If a noise pulse Is read as a clock
signal, the rest of the data for that transfer Is
trash, but on the next access everything Is again
as It should be.
‘The ATmega328 also uses the SPT bus for pro-
gram download from an external programming
device. The following lines are therefore avall-
able on the six-pin programming connector on
the Arduino board and on the Elektor Extension
shield (ICSP in Figure 3): the clock line Serial
‘Clock (SCK) on 85, the write data line Master
‘Out Slave In (MOSI) on B3, and the read data
line Master In Slave Out (MISO) on B4. There
Is no chip select line, but the Reset line has the
same effect because programming takes place
with the Reset line pulled low. Now we want to
Use these lines exactly as intended. This has the
‘advantage that we can use the hardware SPI unit
of the microcontroller, if it has one. With hard-
ware SPI we do not have use program code to
Put each bit individually on the data line as in the
previous examples, and everything Is a lot faster.
However, we still need a chip select line, and in
this case we use the B2 line for this purpose.
‘The master uses the MOST line as the output
‘and generates the clock and chip select signals
(Listing 3). The process Is slowed down a bit by
three 1-millisecond delays so that all the signals
can easily be seen on the oscilloscope. Besides,
we don’t want to make things too difficult for the
slave. If you wish, you can test the boundaries
by reducing the delays until transmission errors
start to occur.
The three lines are inputs for the slave device
(Listing 4). It constantly waits for specific signal
‘edges on the /CS and SCK lines and then reads
In a bit from the MOST line. Since everything Is.
handled by software here, the code must walt for
‘each edge in a Do loop. This takes a bit of time,
‘so data transmission must be slower than with
hardware SPI implementation. The recelved data
Is shown on the display and on the terminal emu-
lator. When you turn the potentiometer on the
master board, the change is visible on the slave.
Figure 2.
‘An SPI connection between
‘wo microcontrollers.SPI EEPROM 25LC512
‘There Is a wide range of ICs available with an
‘SPI interface, including A/D converters, memory
devices and display drivers. Serial EEPROMs from
Microchip and other companies are available at
low cost and are widely used. The 25LC512 (not
tobe confused with the 24C512, which has a I2C
bus interface) has a capacity of 64 KB, and It isa
‘good solution when the 1-kllobyte capacity of the
‘ATmega328's internal EEPROM Is not sufficient.
I7C EEPROMs are more widely used in the hobby
Figures.
Connecting a serial EEPROM.
Listing 5. Reading and writing data over MOSI and MISO.
‘Sub Spioutin
Dino
For N=0To7
‘Shift Din , Left
Din = Din + M1s0
‘If Dout.7 = 1 Then Wost
Wattus 3
sek = 1
Wattus 2
Sck = 0
wattus 2
Shift Dout , Left
Next
End Sub
1 Else Most
realm, but SPI types are generally preferred in
the professional realm because they offer espe-
ally high operational reliability.
Figure 4 shows the connections to the Uno board.
‘The pins of the original SPI interface (2x3 pin
header) are again used here. That makes it easy
to bulld a convenient plug-in memory module
by fiting the IC in a socket soldered to a small
6-pin socket header. You only have to connect
‘one additional line. Ths isthe chip select line,
which is again assigned to 82 because the Reset
line present on the connector cannot be used for
this purpose.
Here there are two data lines. MOSI (Master Out
‘lave In) is the data output line and Is connected
to the Serial Input (SI) pin of the EEPROM, while
MISO (Master In Slave Out) Is used to read data
from the Serial Output (SO) pin. The microcon-
troller is always the master, and it generates the
dock on the SCK line. To go with this exercise, we
have written a subroutine (subroutines are called
“Sub” In Bascom; see the inset) that transfers.
data in both directions in a single go (Listing 5).
Before the subroutine is called, the data to be
‘sent must be placed in the global variable bout,
and after the call the received data Is located In
the variable Din. Of course there are situations
in which data Is only written, but In that case
zero bits are usually sent in the other direction.
‘The relatively complex data sheet for the 25LC512
tells you what has to be sent to the device, as well
‘as when and how. After the chip select line has
been pulled low, the memory chip first receives a
simple byte command that specifies what action
is to be performed. To read data from the mem-
‘ory, you have to send a3" command followed
by two address bytes forming the high-byte and
low-byte portions of the address. after that as
many data bytes as desired can be read out with
‘automatic address incrementing (see Listing 6).
‘The program displays the sequential addresses
and the data bytes that are read out. A brand-new
or fully erased EEPROM always delivers only the
value 255. Now let’s try to program some data.
For that we use the byte command ‘2’. However,
2 bit of preparation Is necessary fist. Writing
must be enabled by sending the command ‘6”
(Listing 7). To check whether writing Is enabled
you can read the EEPROM status register, which
requires sending the command ‘5’. Each action
Is only effective if you pull /CS low at the start
and then return it to the high level at the end.Listing 6. EEPROM readout (excerpt).
cs=0
Dout = 3
Spioutin
Dour = @
Sptoutin
Dout = 0
sptoutin
1-0
Do
Locate 1, 1
Lea I
Print I;
Print "
Tete.
Sptoutin
Locate 2, 1
Lea Din
Print Din
Wattas 200
Loop
tread
"a8. ..ALS
*A0...AT7
If the value in the status register Is 2, the IC Is
enabled for write operations. Complicated? Yes,
but that makes it especially foolproof.
Now we are allowed to write data to the mem-
ory, but even then there's something we have
to consider. The memory space is divided into
pages, which In the case of the 25LC512 have
a size of 128 bytes. Each transfer Is limited to
a maximum of 128 bytes of data, or as many
bytes as it takes to reach the next page bound-
ary. After this you switch /CS high and then give
the EEPROM enough time to actually store the
data, According to the data sheet, 5 ms Is enough
Listing 7. Enabling write access
(excerpt).
cs=0
Dout = 6
Sptoutin
essa
Wattns 20
cs=0
Dout = 5
Spioutin
Sptoutin
essa
Locate 1, 1
Led Dtn
Print Din
‘write enable
*read status
‘status
‘Subroutines are called “Sub” in Bascom, and they are used to allow
1a block of code to be called repeatedly from different locations in a
program. To make this possible, each subroutine must be declared at
the start of the program. This way the name of the subroutine is known
to the compiler, so the it can be called using this name in the same way
‘as Bascom functions.
Declare Sub Sptoutin()
Dout = 6
Sptoutin
Sub Sptoutin
oin= 0
Shift Dout , Left
End Sub
‘You always have to be very careful with the variables used by
‘subroutine. In the case of the Sptoutin subroutine, all of the variables
it uses are “global” variables, which are dimensioned at the start of the
‘main routine and are therefore valid in the entire program. However,
you could do things differently and transfer the data to the subroutine
when it is called:
Declare Sub Sptoutin (Byteout as Byte)
In that case the variable Byteout would not be valid globally, but only
“within the subroutine. The subroutine call would then take the form:
Sptoutin 6
‘This saves one line compared to the previously shown call.
‘You can also transfer a group of several variables to a subroutine in a
‘subroutine call, as can be seen from the example of the Bascom Sptout
‘subroutine:
Spiout Dout , 1
For novice programmers, it's generally safer to use only global
variables in your own subroutines. For advanced programmers, on
‘the other hand, selecting the optimal form of data transfer is a major
‘consideration.Listing 8. Using the software SPI (excerpt).
Contig Spi = Soft , Din = Pind,
Ss = None , Clock = Portb.S , Node = @
sprint
€s Alias Portb.2
barb.2 = 1
cse2
cs=0
Dout = 4
‘Sptout Dout , 1
sea
Wattns 1
cs=0
Dout = 3
‘Sptout Dout , 1
Dout
Spiout Dout , 1
‘write disable
‘read
"a8.
als
» Dout = Portb.3 ,
Dout = @
Spiout Dout , 1
I
Do
Locate 1,
lear
lca"
sptin Din, 2
Locate 2, 1
Led Din
lea"
Print 1
Print"
Print o1n
Wattas 200
T=tel
If T >= 65535 Then Exit Do
Loop
time for storing the data. If you exceed the page
boundary (I tried it), the result Is chaos. Then
the data you find in memory is totally different
from what you wanted to write to memory. For
this reason, the example program carefully obeys
the rules and writes 128 bytes to the first page
from address 0 to address 127, with the data val-
es In ascending order from 0 to 127. When the
data Is read back, that's exactly what you see.
‘As usual, the entire program code (UNO_spiEE1.
bas) can be downloaded from the Elektor website
[1]. It performs the following actions in sequence:
© Command 6, write enable
‘© Command 5, read status register; display for
1 second
Listing 9. Data storage in the timer interrupt routine (excerpt).
Ting_isr: Dout = 3
14000 4s Addr = High(seconds)
Tiner® = 6 Dout = Adar 18, .AIS
Tacks = Ticks +1 ‘Sptout Dout , 1
If Ticks = 25 Then ‘Addr = Low(seconds)
Ticks Dout = Addr *0...A7
U = Getadc(4) Sptout Dout , 1
veusa End If
‘Addr = Seconds bout = u
Addr = Addr and 127 Spiout Dout , 1
If Addr = @ Then ‘start of page ‘Adar = Seconds
cs=0 ‘Addr = Addr And 127
Dout = 6 twrite enable If Addr = 127 Then "End of page
Sptout Dout , 1 cs=2
cs=a End If
Wattus 100 Print Seconds
cs=0 Seconds = Seconds + 1
Dout = 2 narite If Seconds = @ Then Seconds = 65535
Sptout Dout , 1 End IF
Wattus 100 Return
cs20IoT & the Search
for a Protocol
By Jens Nickel
‘The ‘Intemet of Things’ (I0T) is set to change our ives. In order
{or the dverse equipment to understand each other a consistent,
application orientated protocol is needed. For example it's neces-
‘sary to define a general purpose representation of measurement
‘values from sensors and positional information for actuators.
Ideally the protocol will not present too much of an overhead for
‘a small, low cost microcontroller. At the same time it needs to
be versatile enough to cater for the maforty of applications that
‘you might find, for example in a Smart Home environment [1].
This won't be a cakewalk, that's why in our March 2014 edition
‘we appealed to the Community to help us out and send their
Ideas to our competition web page at [Link],
In the mean time we have already recelved many Interesting
‘suggestions that got us thinking, as well as pointers to suitable
existing protocols (2][3]. Now we would like to provoke some
discussion by outlining a framework for a new protocol that is
stll‘work In prog-
ress’. This Is your
chance to make a
difference—if you
think the Ideas are
{good then say so, if
‘you can think of a bet-
ter solution we want to
hear it. This Is going to be
a collaborative effort and we
think, with your help we will arrive
at an optimal solution. Get involved and
{90 to [Link]!
(140298)
1] [Link]/index. php
xapautomation
Eifesceee neues
Messoges are passed between devices, for example es HTTP-
POST data (this need further discussion). Each message
consists of a header together with blocks of information. The
type of information block is defined by two key words (these
are described as ‘Case’ or ‘Mode’, see below).
A few examples:
“Set Value’: Sets an actuator to a value
“Current Value’: A measurement value is transferred
“Query Value’: Request a measurement value to be
transferred (Polling)
“Set LimitMin’, ‘Set LimitMax’: Set end limits to an
intelligent sensor
‘Set Interval’: Set up sensor to send measurement at
intervals
‘Option Min’, ‘Option Max’: The sensor indicates its range
‘Option Value’ (followed by physical units and size):
“The sensor indicates what itis measuring and the
‘measurement units.
‘An outline of the message structure (optional information is
bracketed), the // symbol means ‘or’):
Message: Header + Block (+ Block (+ Block ..))
Block: Case + Mode + (Subnode +) (Location +) (Time +)
Case: ‘Set’ // ‘Current’ // ‘Query’ // ‘Option’
Mode: ‘Value! // ‘Min’ // “Max! // ‘Interval’ // ‘LimitMin’ //
“LimitMax’
Subnode: Integer
Location: LocationString: String
Time: TimeString: String
Data: Value (+ Value (+ Value + ..))
Value: Number + (Accuracy +) Unit + Quantity
Number: Float // Integer // Binary
Accuracy: Float // Integer
Unit: Unitkey: String
‘Quantity: Quantitykey: String
In the end all elements of data types Float, Integer, Binary
Und String will be returned. Exactly how the elements (in
ASCII format) are represented must be defined. Amongst
‘other things we also need suggestions for the representation
‘of lacation and time (LocationString, TimeString).
[A versatile protocol will allow the messages to be made
‘simpler or more complex. For example where Presets,
(predefined actuator positions) are not required or where
‘sensor alarm information such as (‘limit exceeded’) must be
‘accommodated in the message.‘© Command 2, write 128 bytes starting at
address 0
‘© Command 3, read memory starting at
address 0; endless loop
Data logger
‘One practical application for the 64-KB memory
sa data logger. The objective here Is to acquire
‘measurement data from the ADC4 analog Input
‘once per second and store the data. The memory
will be full in approximately 18 hours.
You don't always have to program everything
‘yourself, since Bascom has a lot of ready-made
functions for many situations. In this case you
have the option of configuring an SPI interface as
‘a software interface using any desired port pins or
{as a hardware interface using the microcontroller
pins designated for this purpose. The hardware
‘SPI is especially fast and is commonly used for
tasks such as driving graphical displays. However,
this involves a whole lot of parameters that must
‘be configured for each specific application, which
requires a detailed study of the ATmega328 data
sheet. Things are a bit easier with the software
‘SPI function, and it provides a reasonably high
transmission rate. Although writing your own SPI
procedure from the ground up is not a bad idea
because It allows you to implement the timing
diagrams in the data sheets very clearly, the
ready-made software SPI is more convenient and
faster, which is why we use It here.
The interface configuration specifies which lines
are to be used. For Din, Dout and Clock we use
the familiar MISO, MOST and SCK lines, which
are already avallable on the ICSP connector. The
8S line corresponds to the /CS line. In this case
this line should not be operated automatically by
Bascom because itis usually necessary to trans-
fer a lot of data during a single active chip select
phase. Consequently, this line (on port pin 82)
will still be operated “manually”. The Wode = ©
setting Is also important, because there are four
different SPI modes.
‘The program excerpt in Listing 8 shows how the
software SPI Is used to read dats from the serial
EEPROM. The instruction Spiout Dout , 1 sends
‘exactly one byte, which is transferred in the vari-
able bout. In the other direction, the instruction
sptin Din , 1 reads one byte, which is then
avaliable in the variable Din. The entire program
reads all the data from the EEPROM and shows
the contents on the display and on the terminal
‘emulator screen.
As usual, the entire program code (UNO_spiLog~
[Link]) can be downloaded from the Elektor
website [1]. It is too large to be listed fully here.
Pressing SI starts a measurement run. It can be
stopped at any time by pressing S2, after which
the stored data can be read out.
‘A timer interrupt routine (excerpt in Listing 9)
Is used to control the timing during data acqui-
sition. The voltage on ADC4 Is measured and
stored once per second. The 128-byte block size
of the EEPROM Is taken into account. At the start
of each block, a write access Is started and the
current address Is transferred, followed by 128
bytes of data. At the end of the block, the /CS
line is pulled high to allow the EEPROM to store
the entire block. Since the /CS line Is connected
to port pin PB2, LED2 on the shield is lit when the
line Is high. The LED therefore flashes each time
‘a block of data has been transferred to memory.
(1an24s-t)
Web Link
[1] www [Link]/140245
Ree sa nee ued eet
Many readers who are using the original Arduino boot loader have encountered the following problem: if a program
performs serial output, the Arduino programmer in Bascom does not work properly the next time and hangs. Some readers
have discovered that this problem can be resolved by using the Arduino IDE before using the programmer again. Simply
transferring the Blink program, for example, is sufficient.
However, there's an easier solution. After you launch the programmer in Bascom, briefly press the Reset button on the Uno
board three times (or more) at roughly 1-second intervals. After this the programming function will work again, even when
‘the previous program included a Print output. This has been discussed intensively in various topics on the Elektor forum
(now at [Link]).
If you use the MCS boot loader on the Uno board, this problem does not occur. Another alternative is to use an external
programmer.By
Karl-Anton Dichtel
(Germany)
Lux Meter
With 1 Ix to 100 kIx measuring ranges
Conventional incandescent lamps have been phased out in many areas in the
world, including the EU and Canada. What's left is halogen lamps, energy-effi-
cient lamps and LED lamps, which in fact have better efficiency thai
ndescent_
lamps. However, if you want to know how much better they are, you basically
have to trust the manufacturer's data. Although trust is good, measuring it your-
self is better. The lux meter described here can help.
Particularly with low-cost LED lamps from low-
wage countries, some of which are alot cheaper
than brand-name products, you can hardly be
blamed for being a bit sceptical. For example,
among the 500,000 Items available on a well-
known auction site there are exactly five 3-watt
spot lamps with an asking price of 1 euro. The
aimed light output ofthese lamps is 210 lumen.
“That sounds realistic, but is it actually true?
‘To avold being forced to rey on such claims, you
need an instrument that can reliably measure
brightness. Such an instrument is useful for more
than just checking whether a lamp works. For
‘example, I's good for checking whether a partic-
tular workstation is adequately litand in many
countries there are regulations governing this.
‘Aux meter also offers other benefits with lamps.
For example, for a variety of reasons halogen
lamps are popular for certain purposes. The
brightness of halogen lamps tends to decrease
over time, in part due to the accumulation of
‘metal vapor deposits on the glass envelope. AS
a result, at some point you are getting more heat
than light from the lamp. Even energy-efficient
lamps get darker with age. Measurements can
help you decide when It’s time to replace a lamp
that is no longer up to snuff.
Measuring light
‘The key element of every instrument is a sensor
that converts the desired physical quantity into
an easily measured voltage, preferably with a
reasonably linear conversion characteristic. Of
course, nowadays a fair amount of electronics is
integrated into many sensors to enable them to
output digital data directly. However, the tradi-
tional sensor for light is a photodiode. Along with
types intended for the transmission of infrared
signals, there are special, more accurate types
for measurement purposes. The BPW21R used
here is an example of the latter type, and it is
suitably housed in a sturdy metal TOS package
with 2 glass window (Figure 1).‘This hermetically sealed photodiode has a rela-
tively large active area of 7.5 mm2, which gives
It high light sensitivity. This sensor is also very
linear, as can be seen from the data sheet [1].
Figure 2 shows the Incredibly linear relation-
ship between the short-circult current and the
illuminance. The log-log scale is necessary here
because the sensor covers an extremely wide
brightness range of more than seven decades.
Even though this is a conventional discrete com-
ponent, Its specs are nothing to be ashamed of,
which makes it the Ideal light sensor for use in
2 DIY lux meter.
A photodiode generates a current that is propor-
tional to the illuminance in lux, rather than the
luminous flux in lumens typically used in lamp
‘specifications. As 1 lux is equal to 1 lumen per
square metre, tis theoretically easy to convert
between the two units, but the area illuminated
by a lamp depends on the distance and on the
beam angle. Thanks to the Internet, you don’t
need a pencil and paper for this and you don’t
have to solve any algebraic equations. Various
websites (e.g. (2]) have ready-made calcula-
‘tors where you can simply enter a value in lux
or lumens and convert it into the opposite unit.
Measurement method
As already mentioned, the output from the pho-
todlode Is Its short-circult current. A highly lin-
ear relationship between illuminance and signal
level can only be obtained by operating the pho-
todiode under virtually short-circuit conditions,
which means that the circult for measuring the
current must have a very low input impedance.
However, the quick and dirty approach of con-
nected a 1-ohm resistor across the sensor and
‘measuring the resulting voltage drop Is not very
effective because the voltage at 1 lux would only
be about 9 nV. Although microcontrollers with
Integrated A/D converters are usually the pre-
ferred choice for measurement tasks, the A/D
converters of commonly used microcontrollers
are not sultable for such low voltages. With the
10-bit resolution of a typical AVR microcontroller
and a reference voltage of 1 V, the resolution Is
around 1 mv, which Is five orders of magnitude
greater than the full-scale value of the lowest
‘measuring range. The idea of using an interme-
diate voltage amplifier to boost the voltage by
a factor of 100 million (to obtain roughly 1 V at
1 Ix) is unrealistic, since the signal would be com-
bad
'* Lux meter with 6 measuring ranges:
be, 10 bx, 100 bx, 1 kx, 10 kbc and 100 kbc
‘* Measurement resolution in 1 Ix range: 0.01 be
'* Autoranging
'* Automatic power down after 1 minute
'* Measurement data output over serial interface
‘© All components readily available
'* Low power consumption
‘* Can be calibrated over the serial interface using a terminal emulator
pletely buried in the noise (among other prob-
lems). We therefore need a different approach,
The circuit in Figure 3 shows how it can be
done. The sensor D1 Is connected across the
Inputs of an opamp (IC3), which has its non-in-
verting input connected to a reference voltage of
approximately 0.65 V at the junction of R3 and
D2. When light shines on D1, it wants to supply
a current, which would cause the voltage on the
Inverting input of IC3 to drop. This Is countered
by negative feedback through Ri or R2. Conse-
quently, the voltage at the output of the opamp
rises to the level necessary to cause the current
flowing through the feedback resistor to offset the
current from the diode, so the voltage between
the inputs of IC remains at zero. As a result, D1.
{s virtually short-circuited and therefore oper-
ates with a very linear characteristic. To obtain
the highest possible measurement accuracy, we
chose a Microchip MCP6061T for 1C3 instead of a
standard opamp. With extremely low input cur-
‘ents inthe picoamp range and an offset voltage
cof only 150 pv, this opamp will not degrade the
‘measurements. The converted sensor signal from
1C3 Is routed to connector K2 for test purposes.
let Cheuk Cara (A)
AOE 10" 10% 10" 108 102 108 108 10°
,-mumnarce
Figure 1
‘Schematic depletion ofthe
[BPW2IR package.
Figure 2.
‘The short-circuit current
(i) versus illuminance
(Ey) characteristic ofthe
PWR.Figure 3.
‘The circuit of the x meter
essentially consists of a
sensor, a signal amplifier,
precision A/D converter,
‘2 microcontroller and a
display module.
Circuit description
‘At 1 lx (with RE1B in the Ri position) the volt-
age at the output of 1C3 Is appreximately 1.8 mv
(9 nA x 200 kQ) That is still not enough for the.
AID converter of a normal microcontroller. Tis
could be solved by adding another gain stage,
but if you want a precise instrument it’s better
to-do the job right. Instead of using the so-so
AADC integrated in the ATmega328, we opted for
an external A/D converter (IC2) with an inte-
grated precision input amplifier and a resolution
of 18 bits, That may sound lke overall, and in
fact we only use 15 bits, but there are good rea-
sons for this approach.
One of the main reasons Is the measuring
range, since the working range of the human
‘eye extends from 1 Ix (full moon) to 100 kix (full
sunlight). This corresponds to five full decades,
and it requires circuity with a very large dynamic
range. This requirement is met a follows: Swftch-
Ing between R1 and R2 changes the signal level
by a factor of 100. This means that the subse-
quent circuitry only has to handle a dynamic
range of 1000:1. Since the internal gain of C2
can also be switched between 1x and 8x, the
resulting dynamic range Is sufficient to obtain
accurate measurements over the complete instru-
‘ment measuring range. For the detals of switch-
ing the gain levels and measuring ranges, see
the firmware code. In any case, the accuracy of
the circult Is approximately 0.5%.
C2 is controlled by the microcontroller (IC1) over
the IC bus. It is used to read data and configure
C2. The relay Is also controlled by two outputs.
of IC1, which allows the current through the coll
to be reversed. This direct drive arrangement
Is possible because the relay (RE1) can man-
‘age with a coll current of about 24 mA. REI Is,
‘hat Is called a bistable relay, which only needsa short current pulse in one direction to switch
over and remains latched in the new position
without any current. It can be switched back
by simply applying a short current pulse in the
opposite direction. This method prolongs battery
life, Relay contacts are preferable to any sort of
MOSFET for this application.
C1 also perform three other tasks. Some of its
pins drive the LCD in nibble mode, and another
pin switches the backlight on via 73 during a
measurement session if necessary. Two other
pins handle serial data transfer with TTL signal
levels. The pin assignments of K3 are compatt-
ble with the Elektor 808 USB to serial converter.
This gives you a serial interface over USB if you
need it.
‘Another function of IC1 Is to maintain the supply
voltage (via pin 24 and transistors T2 and T1)
for one minute after the device is switched on
by pressing button 1. After this the Instrument
switches off automaticaly to prolong battery life.
‘Another remark about power: with a battery-pow-
ered instrument such as this, it’s worthwhile to
take measures to save energy. One of them is
the previously mentioned control of the LCD
backlight via T3, or disabling the backlight with
3P2, Illumination is only activated automatically
and adapted to the ambient light level when the
ambient light level is less than 64 Ix. This smart
measure by itself saves about 20 mA under bright
Conditions, which is fairly significant considering
that the current consumption of the rest of the
Instrument Is 14 mA. To avoid the power dissi-
pation of a standard voltage regulator, a special
low-power, low-dropout regulator (1C4) Is used
to generate the regulated 5 V supply voltage.
‘The regulator can work down to a battery voltage
of approximately 5.5 V. at lower input voltages
its output voltage collapses. The display stops
working below 5 V. Choke Li provides additional
filtering for the analog portion of 1C1.
Construction
When fiting components on the PCB you need a
steady hand, a fine soldering tip, small tweezers,
soldering paste or thin wire solder and a magni-
fying glass. Although the sensor is an old-fash-
loned leaded component, nearly all of the other
components are SMDs— mostly in the especially
popular 0603 package In the case of resistors.
and capacitors. If you are newcomer to solder-
Ing SMDs, we strongly advise that you draw on
the assistance of an experienced colleague or
friend. Figure 4 shows the component side of a
prototype circuit board, which should be enough
to give you an idea of what you're up against.
‘A magnifying glass is helpful when you're look-
Ing for shorts between SMD pins, which can be
eliminated with a bit of desoldering braid and
flux. That works fairly will with the pin spacings.
of the ICs used here.
‘The display Is mounted on the other side of the
board (see Figure 5). If you want to mount the
LCD module so it can be removed, you can imple~
‘ment the connection using socket headers and
long pin headers, However, if you don’t need to
have a dismountable display you can simply use
sultable lengths of wire (16 in total) I's import-
ant to keep the LCD module spaced away from
board enough to avoid short circuits between the
rear of the display module and the PCB.
Firmware
‘The software for IC1 was written In C using the
free AVR Studio IDE (V4.18) and Is available free
Of charge (Including the hex file) from the Elektor
‘web page for this project [4]. A 200 kHz clock
Figure 4.
‘The component side ofthe
‘assembled prototype board.
[Neary all ofthe components
‘are mounted on this side,
‘even the tiny” SMDs in type
603 packages.
Figure.
Circuit board with mounted
‘display module. The
photodiode and the power-
‘on button are atthe top.(5 ms period) for the relay drive pulse is derived
from the 10.24 MHz clock signal, and from it a
2 Hz clock is derived for sequence control. The
code for driving the LCD was taken from an arti-
dle on the [Link] website [5], where
It is extensively commented. The IC routine Is,
recycled from a project for a weather station,
which Is why it contains unused (leftover) code
for a rotary encoder and other things. If you are
interested in the details, see the comments in
the code.
‘The standard ISP connector K1 is used to down-
load the program code to IC1. To power the
microcontroller during the download process,
the battery must be connected and JP1 must be
‘Component List
Resistors
Default ratings: 1%, 0.1W, SMD0603
Ri = 200k2
R2 = 2k2
R3 = 3.9k2.
Rd, RS,RE,RB,RL0,R13 = 10k2
R7 = 822
RO = 33k
Rit = 47k 5%
R12 = 330 5%, 0.2W
R1g,RAS = 2200 5%, 0.2W
PL = 10k 20% trimpot, SMD, Vishay
TSS3Y}103MRi0
Capacitors
Default ratings: 10%, 10V, SMD0603
Ci = 1nF 5% SOV, COG/NPO
C2 = 3.3uF 20V, SMD case A, tantalum,
€3,C5 = 470nF
(C4,C13 = 4.7UF 20V, SMD case A, tantalum
C6,C12 = 10uF, SMD Case A, tantalum’
C7,C14 = 10nF SOV.
(C8,C9 = 22pF SOV, COG/NPO
C10,C11 = t00nF 25V
Inductors
LL = 10pH 20%, 250mA, 1.05, SMD 0603
fitted. Alternatively, you can keep S1 pressed for
the duration. The program starts running for the
first time after the download.
Since all bytes in the EEPROM memory of a new
microcontroller are set to $FF and are restored
to that value when the device is reprogrammed,
the microcontroller can easily see whether the
Instrument Is starting up for the first time. If
the value FFpex Is found in two EEPROM bytes, a
calibration factor of 1 is provisionally stored in
those two bytes. This corresponds to a conver-
sion ratio of 9 nA = 1 lx. More precise calibration
can be performed later via the serial interface.
The next step Is to measure the offset of the
‘opamp and the A/D converter without the pho-
‘Semiconductors
‘BPW2IR, TO-S
D2 = 754148 RY, SMD 0805
D3 = PMEG2010AEH, SMD SOD-123F
Ti = IRLML6402PBF, SMD SOT-23
2 = BCB48B, SMD SOT-23
3 = 2N7002, SMD SOT-23
IC = ATmega328P-AU, programmed, SMD TQFP 328
IC2 = MCP3421A0T-£/CH, SMD SOT-23-6
IC3 = MCPEOGLT-E/OT, SMD SOT-23-5
C4 = LP2951-50D, SMD SO-8
Miscellaneous
K1 = 6-pin (2x3) pinheader, 0.1” pitch
BT1,.P1,P2,K2 = 2-pin pinheader, 0.1” pitch (K2
}
optional)
43P3 = 2-pin pinheader, 0.1” pitch, right angled
k3 = 5-pin pinheader, 0.1" pitch, right angled
31, P2,3P3 = jumper, 0.4" pitch
‘Si = pushbutton, 6x6 mm, vertical, make contact
BTi = 9-V-battery clip with wires, optionally with re-
cceptacles for pinheader pins
REI = relay, bistable, 2 contacts, coll 4.5V / 202.52,
41A/L10VDC contacts (Panasonic AGN2104H)
Xd = 10.24MHz quartz crystal, 18pF; HC-49/4H
LCD1 = LCD module, 2x8 characters, backit, 58x32
‘mm, TCO8028-01YA0 (Elektor Store # 120061-75)
PCB # 130109-1