Here is second version of my RF power meter device. It has improved RF shielding and noise immunity. A little bit more expensive to make but quality pays.
C14 is also added for improving noise immunity from supply line.
C14 added and other SMA connector removed. It’s replaced with T splitter externally.
Casing
Case is bought from Digi-Key. It’s part number is PIP-11766-C. DC jack outer diameter is 5.5mm and inner 2.5mm.
This meter measures the transmitting power of the radio transmitter and the voltage of the battery used as a power source. Power is displayed in watts and dBm. The device has a three-digit LCD display. The functions are controlled by a push button. The unit will automatically turn off after five minutes if the button is not pressed. By pressing once device wakes from sleep mode and show measured power in wats. By pressing again device switches to dBm mode and show power in dBm. Pressing third time device show measured supply voltage.
Comes as a bag of
parts kit and is easily assembled if customer can follow the
silkscreen indicators and have beginning experience with a soldering
iron. Customer will need to read the resistor bands or use a
multimeter to determine the resistor sizes.
Works with single
7…14 volts DC power supply connected with DC barrel plug.
Internally 5.0V voltage is used through regulator 7805. ADC reference
voltage is taken from supply voltage with voltage divider. Its
voltage is 2.5V. One analog input is connected with supply voltage
also with voltage divider. its voltage is adjusted to a max. of 2.5V
at 14V so that accurate voltage measurement is made possible.
The heart of the
device is AtMega328P-PU at 16MHz clock frequency. This makes it to be
Arduino™ compatible system.
For
measuring power, an AD8307 chip is used. It allows the RF power to be
converted to a voltage between 0 and 2.5V. The permissible power is
between 0 and 1kW. The
permissible frequency range is between 10MHz and 1GHz. It
is possible to calibrate the measuring range by ± 3dB with
on-board trimmer resistor.
The output is connected to the analog input of the microcontroller.
Measurement is made
with following equations:
dBm = 40(U-1) W = 10(dBm/10)/1000
The display is a three-digit LCD display. LCD display requires AC voltage. It can be simple square wave signal from DC 5V. Frequency is not critical. It can be between 30-200Hz. Phase difference lights the segment. This device uses regular CMOS series IC’s to control LCD segments. 4056 is used to control digits. Every digit needs own IC. One 4054 is used to control two decimal points and to invert common backplane signal. Frequency is made with Arduino™ PWM output. It is about 30Hz. Below is an self-explanatory illustration.
Current consumption is very low because of CMOS integrated circuits used and AtMega328P power saving mode which is programmatically activated. LCD display consumes very little current compared to regular LED display. Also power measurement circuit ’chip enable’ signal is controlled with AVR.
Physical size of device is with casing 13x13cm. PCB is 10x10cm. Dimensions excludes connectors and push button.
Usage examples
Amateur radio station power meter
Power measurement
Circuit diagram
Development stage
One prototype has been ordered so far with double sided printed circuit board and with through hole components. UNTESTED at this point. Work is in progress. It is designed with KiCad.
Target MSRP
BOM (bill-of-material) cost with casing and SMA connectors is about 50 euros. It does not include any basic components with standard values (I use my own stock).
10 pieces small batch BOM cost is $64.90 + PCB $3.02. PCB will cost $1.33 in order quantity of 1000 pieces. PCB’s are bought from Itead Studio from China. The components are bought from Digi-Key from USA. The same components can also be purchased from Mouser. The price in larger quantities are much less. If order quantity is 1000 pieces then it costs $40.04 + PCB $1.33. Manufacturing costs should also be taken into account. (In this case packing.) So total cost for parts is roughly $43.00.
Typical distribution margin is 5-7% and retail margin is 15-25% with this type of products. So the MSRP would be between $51.93 and $57.51. Realistic actual selling price would be $79.00.
Advantages
Ease of use. The
device has only one button with three functions. ’Plug-and-play’.
Safe operating voltage. Safe to use. Hackable design.
Other similar
devices
Surecom SW-102 Digital Antenna Power & SWR Meter VHF/UHF 125-525MHz.
Soldering
The project requires
no special soldering skills. All components are their through hole
versions.
Programming
All parts are open
source. The program is solely written in C++. The program is very
simple and with its 200 lines of code it uses only 4.6kB of program
memory. AtMega328P-PU chip is used.
The bootloader must
first be programmed using external programmer. I personally like to
use Arduino™ as ISP and Arduino™ IDE. Be sure to choose the
Arduino™ Nano from the Tools→Board menu. After installing the
bootloader, the program can be uploaded using same setup.
Program does not use
any external libraries. Only standard built-in power saving related
libraries are used.
Approvals
Arduino is a registered trademark. It is still ok to build a commercial product based on Arduino. Only the name may not be the same. https://www.arduino.cc/en/Main/FAQ#toc10
This USB device works with one DMX universe. A DMX universe is 512 channels of 256 levels. The device also has a slot for a memory card. Maximum memory card size is 32GB.
The device also works as a streaming recorder. When show is running you can simultaneously save it to memory card and output to DMX512 port. If USB connection is lost during play it rewinds automatically and starts from beginning of saved show.
With 2GB memory card maximum recording time is 4 days! Record is simple series of CSV text files on FAT file system. Starting from first subdirectory with 1.csv and so on. Each subdirectory is separate show.
Changing operating mode and choosing between saved shows can be done with onboard display and button. Display shows simple to understand symbols for recording and playback functions and numbers for choosing between memory slots. By pressing button shortly it blinks current symbol and it is possible to browse through functions. Long press chooses that function and it’s symbol stops blinking.
The device also works as a RDM interface. With compatible software on computer it allows control and monitor RDM fixtures remotely. Currently on Linux there is no any software available.
AVR Program
The device uses AtMega328PB-AUR microcontroller with 16MHz crystal. It includes two hardware serial ports and two hardware SPI port. First serial port is USB interface and second serial port is DMX/RDM interface. Speed on both serial ports must be 250000 baud. First SPI port is used only for programming and second SPI port is used to communicate with memory card. Program is written with C++ language. Microcontroller is programmed using avr-gcc and avrdude. Program is released under GNU General Public License.
This program uses:
Enttec DMX USB Pro protocol to communicate with PC. API specification: https://www.enttec.com/products/controls/usb/2-universe-usb-computer-interface-dmx/ Copyright (c) 2007 Enttec Pty/Ltd
Parts from DMXSerial and DMXSerial2 libraries. Copyright (c) 2011-2013 by Matthias Hertel, http://www.mathertel.de This work is licensed under a BSD style license. See http://www.mathertel.de/License.aspx
Parts from SdFat and Sd2Card libraries. Copyright (c) 2009 by William Greiman GNU General Public License V3.
Parts from Arduino SD-library. Copyright (c) 2010 SparkFun Electronics GNU General Public License V3.
CRC-7 routine and CRC-7 table from https://github.com/signal11/m-stack/blob/master/storage/src/crc.c Copyright (c) 2013 Alan Ott Copyright (c) 2013 Signal 11 Software GNU Lesser General Public License V3.
This simple reader is based on previous post circuit and code. LCD display and custom AVR/Arduino circuit is added. Tag number is displayed on screen when detected. Detecting distance is about 2-3cm. Working voltage is 4.5V. This is maximum voltage of LCD display.
#include <LiquidCrystal.h>
uint8_t cparity;
uint8_t numbers[5];
LiquidCrystal lcd(4,2,5,6,8,9);
void setup() {
//Serial.begin(115200);
pinMode(11, OUTPUT); // PWM output
pinMode(13, OUTPUT); // Status LED
lcd.begin(8,2);
lcd.print("RFID");
lcd.setCursor(0,1);
lcd.print("reader");
TCCR2A = 0;
TCCR2B = 0;
TCNT2 = 0;
TCCR2A = 0b01000001;
TCCR2B = 0b00001001;
OCR2A = 32; // 32=125kHz, 27=143kHz == (16000000/(2*1*143000))/2
}
void wait(uint8_t t){
uint8_t counter = 0,last = 0,next;
do {
next = PINB & (1 << 3);
if (next != last) counter++;
last = next;
} while (counter < t);
}
uint8_t readBit(uint8_t time1, uint8_t time2) {
wait(time1);
uint8_t counter = 0, last = 0, state1 = PIND & (1 << 7), state2;
do {
uint8_t next = PINB & (1 << 3);
if (next != last) counter++;
last = next;
state2 = PIND & (1 << 7);
} while (counter <= time2 && state1 == state2);
if (state1 == state2) return 2;
if (state2 == 0) return 0; else return 1;
}
int8_t read4Bits(uint8_t time1, uint8_t time2) {
uint8_t number = 0, parity = 0;
for (uint8_t i = 4; i > 0; i--) {
uint8_t bit1 = readBit(time1, time2);
if (bit1 == 2) return -1;
number = (number << 1) + bit1;
parity += bit1;
}
uint8_t bit1 = readBit(time1, time2);
if (bit1 == 2 || (parity & 1) != bit1) return -1;
cparity ^= number;
return number;
}
uint8_t readCard() {
loop_until_bit_is_clear(PIND, 7);
loop_until_bit_is_set(PIND, 7);
uint8_t counter = 0, last = 0, next;
do {
next = PINB & (1 << 3);
if (next != last) counter++;
last = next;
} while (bit_is_set(PIND, 7) && counter<0xFF);
if (counter == 0xFF && bit_is_set(PIND, 7)) return 1;
uint8_t halfbit = counter, offset = counter >> 1;
if (readBit(offset, halfbit) != 1) return 1;
for (uint8_t i = 7; i > 0; i--)
if (readBit(halfbit + offset, halfbit) != 1) return 1;
cparity=0;
for (uint8_t i = 0; i < 5; i++) {
int8_t n1 = read4Bits(halfbit + offset, halfbit),
n2 = read4Bits(halfbit + offset, halfbit);
if (n1 < 0 || n2 < 0) return 1;
numbers[i] = (n1 << 4) + n2;
}
uint8_t cp = 0;
for (uint8_t i = 4; i > 0; i--) {
uint8_t bit1 = readBit(halfbit + offset, halfbit);
if (bit1 == 2) return 1;
cp = (cp << 1) + bit1;
}
if (cparity != cp) return 1;
if (readBit(halfbit + offset, halfbit) != 0) return 1;
return 0;
}
void loop() {
uint8_t result;
do {
result = readCard();
PORTB ^= (1<<5); // LED drive
} while (result != 0);
lcd.clear();
lcd.print("Raw data");
lcd.setCursor(0,1);
//Serial.print("Raw data: ");
for (uint8_t i=0;i<5;i++) lcd.print(numbers[i],HEX); //Serial.print(numbers[i],HEX);
//Serial.println();
delay(1000);
lcd.clear();
lcd.print("Number");
lcd.setCursor(0,1);
//Serial.print("Card number: ");
uint8_t numbersr[4];
numbersr[0]=numbers[4];
numbersr[1]=numbers[3];
numbersr[2]=numbers[2];
numbersr[3]=numbers[1];
//Serial.print(*(uint32_t*)(&numbersr),DEC);
//Serial.println();
lcd.print(*(uint32_t*)(&numbersr),DEC);
delay(1000);
}
Part list:
R1, R9, R10 – 1k resistor
R2 – 47k resistor
R3, R6, R7, R8 – 22k resistor
R4, R5 – 2k2 resistor
R11 – 680 resistor
R12 – 10k resistor trimmer
C1 – 4n7 capacitor
C2 – 2nF capacitor
C3, C4, C6, C9 – 100nF capacitor
C5 – 47pF capacitor
C7, C8 – 18pF capacitor
D1, D2, D3 – 1N4148 diode
D4 – Green LED diode
Y1 – 16MHz crystal
Q1 – 2N3904 transistor
Q2 – 2N3906 transistor
U1 – LM324 operational amplifier ic
IC1 – AtMega328P microcontroller ic
L1 is not normal component. Instead it is hand wound coil with inductance of 375µH. It can be physically any size or shape. Only important thing is inductance. Online calculator is good tool for this. Calculator asks permeability for air in this case. It is 1.
This simple circuit does not use any external modules to interfacing RFID reader to Arduino. The code below generates 125kHz frequency to other end of circuit. Then the other end sends the received data to Arduino input.
Inductor must be 375µH, but can be any size physically. Good reference to calculate correct value is here: https://www.allaboutcircuits.com/tools/coil-inductance-calculator/. I personally used 46 turns 58mm diameter coil of 0.5mm normal interconnecting wire. I used an empty can of Red Bull energy drink as former. Coil diameter is measured in the center of coil ‘edges’. Detecting distance is about 2-3cm.
Arduino program sends RFID tag data to serial port. This can then be used to for example open an electric lock. 125kHz output is pin 11 and data input is pin 7.
uint8_t cparity;
uint8_t numbers[5];
void setup() {
Serial.begin(115200);
pinMode(11, OUTPUT); // PWM output
TCCR2A = 0;
TCCR2B = 0;
TCNT2 = 0;
TCCR2A = 0b01000001;
TCCR2B = 0b00001001;
OCR2A = 32; // 32=125kHz, 27=143kHz == (16000000/(2*1*143000))/2
}
void wait(uint8_t t){
uint8_t counter = 0,last = 0,next;
do {
next = PINB & (1 << 3);
if (next != last) counter++;
last = next;
} while (counter < t);
}
uint8_t readBit(uint8_t time1, uint8_t time2) {
wait(time1);
uint8_t counter = 0, last = 0, state1 = PIND & (1 << 7), state2;
do {
uint8_t next = PINB & (1 << 3);
if (next != last) counter++;
last = next;
state2 = PIND & (1 << 7);
} while (counter <= time2 && state1 == state2);
if (state1 == state2) return 2;
if (state2 == 0) return 0; else return 1;
}
int8_t read4Bits(uint8_t time1, uint8_t time2) {
uint8_t number = 0, parity = 0;
for (uint8_t i = 4; i > 0; i--) {
uint8_t bit1 = readBit(time1, time2);
if (bit1 == 2) return -1;
number = (number << 1) + bit1;
parity += bit1;
}
uint8_t bit1 = readBit(time1, time2);
if (bit1 == 2 || (parity & 1) != bit1) return -1;
cparity ^= number;
return number;
}
uint8_t readCard() {
loop_until_bit_is_clear(PIND, 7);
loop_until_bit_is_set(PIND, 7);
uint8_t counter = 0, last = 0, next;
do {
next = PINB & (1 << 3);
if (next != last) counter++;
last = next;
} while (bit_is_set(PIND, 7) && counter<0xFF);
if (counter == 0xFF && bit_is_set(PIND, 7)) return 1;
uint8_t halfbit = counter, offset = counter >> 1;
if (readBit(offset, halfbit) != 1) return 1;
for (uint8_t i = 7; i > 0; i--)
if (readBit(halfbit + offset, halfbit) != 1) return 1;
cparity=0;
for (uint8_t i = 0; i < 5; i++) {
int8_t n1 = read4Bits(halfbit + offset, halfbit),
n2 = read4Bits(halfbit + offset, halfbit);
if (n1 < 0 || n2 < 0) return 1;
numbers[i] = (n1 << 4) + n2;
}
uint8_t cp = 0;
for (uint8_t i = 4; i > 0; i--) {
uint8_t bit1 = readBit(halfbit + offset, halfbit);
if (bit1 == 2) return 1;
cp = (cp << 1) + bit1;
}
if (cparity != cp) return 1;
if (readBit(halfbit + offset, halfbit) != 0) return 1;
return 0;
}
void loop() {
uint8_t result;
do {
result = readCard();
} while (result != 0);
Serial.print("Raw data: ");
for (uint8_t i=0;i<5;i++) Serial.print(numbers[i],HEX);
Serial.println();
Serial.print("Card number: ");
uint8_t numbersr[4];
numbersr[0]=numbers[4];
numbersr[1]=numbers[3];
numbersr[2]=numbers[2];
numbersr[3]=numbers[1];
Serial.print(*(uint32_t*)(&numbersr),DEC);
Serial.println();
delay(1000);
}
UPDATE Oct. 20. Now it’s ready and it’s working. Tested with QLC+ and with three channel DMX receiver. It is however impractical large and heavy to connect directly in to USB port. So next version fixes this. Coming soon.
UPDATE Oct. 12. Almost ready.
Open DMX USB is an open USB to DMX hardware design developed by Enttec. The Open in Open DMX USB refers to the fact that everybody is free to use the design and produce its own USB DMX dongle without paying any licenses.
The Open DMX USB is inexpensive way to get into the world of controlling DMX devices from a PC. It relies on the computer for all calculations and timing of the DMX signal. It is ideal for small live music and theater applications.
Powered by a computer over USB. Standard 3pin DMX port. Compatible with a wide range of 3rd Party software. Control up to 512 channels. Plugged directly on to the USB port.
This DMX USB interface is based on the FTDI 232RL chip, it’s a USB to serial converter. It’s designed accordingly to the USB specification and will enter suspend mode when there is no activity on the bus. It then shutdown the device and draw no more than rated suspend current.
Using a simple application on a PC you can send and receive DMX512. Recommended application is QLC+ because it is a free and cross-platform software to control DMX or analog lighting systems like moving heads, dimmers, scanners etc. QLC+ runs on Windows, MacOS and Linux.
A simple Python GUI program to view APRS data from radio via serial port or Bluetooth. Easy to send messages and update status. Serial port and Bluetooth settings is available in settings panel. Autoscrolling feature is included to program so latest messages are always visible.
Features
Graphical user interface for those who not like text only mode.
Decodes KISS frame
Decodes ax.25 U frame
Decodes MIC-E format
Decodes APRS symbol and displays it on screen
Decodes APRS compressed data formats
Removes old items from the map
Removes traces of moving objects on the map
Supported and tested Hardware
Supports virtually any TNC which supports real or virtual serial port and KISS protocol.
Tested with Mobilinkd TNC2 through Bluetooth (with virtual serial port).
How does it work
Program decodes KISS frame and then ax.25 frame and lastly MIC-E data if available. Result is printed on window with colorful notation.
HELP – What to do if it does not work somehow?
Program should work on Python version 2.7.xx and onward. Run it with command “sudo python APRSterminal.py” without quotes. Contact me. I’m willing to help on any questions and can even add some features to program if necessary.
This project uses this 7-segment display. It is based on Arduino. Display shows current gasoline price in Tampere, Finland. Gasoline price is middle price for 95E10 and it’s downloaded from www.polttoaine.net with Python code.
GUI (graphical user interface) is made with wxPython and wxFormBuilder. Update interval and serial port is user selectable.
Finally, I can say that I can program in the Python language. I learned Python from this tutorial. It is a good combination of the languages that I previously knew (PHP, Javascript and SQL). Structure also reminds me of Delphi and Basic languages.
Here is a program that reads 1-wire temperature sensor DS18B20 and displays it’s value on GUI (graphical user interface). GUI is made with wxPython library and with wxFormBuilder software.
In between sensor and computer there is Arduino Nano which transforms data from 1-wire to UART.
Python code:
#! /usr/bin/python
# -*- coding: utf-8 -*-
import wx
import wx.xrc
import serial
from thread import start_new_thread
class MyApp(wx.App):
def OnInit(self):
self.res = wx.xrc.XmlResource("gui.xrc")
self.frame = self.res.LoadFrame(None, "MyFrame1")
self.text1 = wx.xrc.XRCCTRL(self.frame, "m_textCtrl1")
self.text2 = wx.xrc.XRCCTRL(self.frame, "m_textCtrl2")
self.button1 = wx.xrc.XRCCTRL(self.frame, "m_button1")
self.frame.Bind(wx.EVT_BUTTON, self.on_evt_button, id=wx.xrc.XRCID("m_button1"))
self.SetTopWindow(self.frame)
self.frame.Show()
return True
def on_evt_button(self, evt):
self.button1.SetLabel("Wait...")
self.button1.Enable(False)
start_new_thread(readSerial,(self,))
def readSerial(self):
try:
with serial.Serial(self.text2.GetValue(), 9600, timeout=1) as ser:
line = ""
while len(line) == 0:
ser.write("\n")
line = ser.readline()
self.text1.SetValue(line.splitlines()[0] + u"°C")
except IOError:
print("Port cannot be opened")
self.button1.Enable(True)
self.button1.SetLabel("Read sensor")
app = MyApp(False)
app.MainLoop()
#include <OneWire.h>
#include <DallasTemperature.h>
// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
void setup(void) {
Serial.begin(9600); // start serial port
sensors.begin(); // Start up the library
}
void loop(void) {
while (Serial.available() > 0) { // if there's any serial available, read it
if (Serial.read() == '\n') { // look for the newline
sensors.requestTemperatures(); // Send the command to get temperatures
Serial.println(sensors.getTempCByIndex(0)); // get temperature from first sensor only
}
}
}
