Care Required:  
Ham Radio is
Quack Quack Quack Logo

Shiawassee Amateur Radio Association [SARA]

Established: January, 1958 an ARRL Affiliated Club since 1961

"Whiskey 8 Quack Quack Quack"

Meets at: James P. Capitan Center, Lower Level; 149 E. Corunna Ave.; Corunna, MI 48817 Monthly: 2nd Tuesday @ 7:00 PM

Club station located in the James P. Capitan Center - Lower Level.
IARU: 2 Grid Square EN72wx   Latitude: 42.9819 N   Longitude: -84.1164 W   Alitude: 760 ft.

Contact us at:   SARA / W8QQQ <Email>

You're invited to a club meeting!  7:00 PM the 2nd Tuesday of each month in Corunna, MI.


 Google Search
  Search only "W8QQQ Site"   Search "All the Web"

Quickly Find Something! Select your Search Range ~ either choice opens in a new Window.

Initial Arduino Information

I started having a desire to build something for the ham shack (Dec/2016). It had been a few years since I was busy on that front and I had actually been missing it. So, thoughts of a 40m QRP SSB transceiver started to sound like a good project. Then I decided to apply the KISS principle [keep it simple stupid] and start with a 'preassembled board'. Selection of the BITX-40 from HF Sigs, at a cost is about $59.00 (includes shipping from India), seemed like a really great choice. The BITX-40 is and the cost seemed right for a rig to modify and play around with. It is not meant to be a 'operate' only radio, but a "let's play around" unit. You get in and build, gain understanding, modify, repair, and work "hands-on" with the unit. The BITX 40 now (early 2017) comes with a prepogrammed Arduino "mini" microcontroller and a LCD display as the VFO in the assembly. Many uTube videos showed this as a nice little circuit and the various chat boards talk nicely about the VFO stability, though much chatter around programming and other small issues. The BITX-40 is meant to be a very 'hackable' rig for each individual, allowing for lots of experimentation - so I will hold the BITX information for a later discussion, but you should take a look at it! The BITX-40 is a 'spin-off' of the BITX-20 design that has been around for awhile, thus having quite a 'Web Presence'. Many uTube videos showed this as a nice little circuit and the various chat boards talk nicely about the VFO stability, though much chatter around programming and other small issues.

Well, the BITX-40 project had led me to wanting to investigate the "DDS VFO concept" a little deeper (think 'signal generator' and/or standalone VFO). The internet is full of information and uTube videos of using an Arduino microcontroller to control an AD9850/AD9851 DDS circuit making some very neat VFO boxes. Also, in some units the Si5351 DDS module is used (like in the BITX-40 project). This new knowledge kick started in ma a desire to obtain, learn and play with the Arduino UNO and AD9850, AD9851 and Si5351 DDS generators. This then became the main topic of this post (page). A thought of switching out the Arduino (~$17.00) with a Raspberry Pi Zero (~$5.00) and doing some additional things is floating in my thoughts, but needs a large amount of refinement and learning some other basic information (Project concepts: External signal generator, VFO, antenna analyzer, QRP rigs, etc. are part of the thinking). A $12.00 savings for a small project is always very intriguing to a ham, so I will shoot for about $25 as a valid project target cost. I needed to learn a lot more about the 'Arduino Microcontrollers' which became a main focus. The 'official' Arduino site is the first place to read and dig-in for learning. The ARRL has a book of projects for the Ham shack using the Arduino, but I have held off for awhile. (I did later purchse and read this nice book).

Go back to top ↑


In my past experiences with homebrewing and building various receivers, the three characteristics that lead to the unit's level of performance were always sensitivity, selectivity and stability. These were always the major keys to success (or lack thereof). Sensitivity and selectivity seemed to be way easier to work around for me (amplify and filter blocks). The frequency stability always was the major challenge to get "adequate" performance out of a given project. Could these DDS frequency units be the simple key to this earlier project performance issue? I predict some further work in my very near future in checking this out. {After about three years - the answer is a big YES!}

In my defense, I want to share the blame with Bill Meara, N2CQR/M0HBR, and Pete Juliano, N6QW, of 'soldersmoke' fame. Bill and Pete have been discussing the BITX units for awhile and spiked my interest on warming up the solder iron. Therefore, by dividing the responsibility issue betweem them and me, I decided it is only 33% my fault! What is a ham to do? I feel trapped (again). I decided to get started with a simple Arduino based VFO project and post on that project. I rationalize that "I must hold up my end 33% of the project, I can not let them down".

A quick internet search found a nice VFO to copy from {I am not trying to reinvent, just build a useful unit for the shack and add to my knowledge}. Richard Visokey, AD7C, has a nice design for a 1 Mhz to 40 MHz VFO that uses the AD9850 DDS; an Arduino and a 1602 LCD Display. The unit is controlled by a rotarty encoder with it's internal push button switch (2013-Mar-25 rev 1.0). This page will follow that design and address the Arduino in general. A large THANKS goes to Richard for his efforts and sharing them with the ham community. Using the already available sources, let us get going on this project. I will substitute an 'Arduino UNO' for the nano unit (Richard's choice), but otherwise will follow his design. Now my actual responsibilty for this project, because Richard joins Bill and Pete, is down to only a maximum of 25%. New goal: figure out how to make it all someone elses fault. They get the blame and I get the fame.

Arduino Uno Information

Check out "Components 101" UNO Website for some gereat information and descriptions.

Arduino Uno Board Arduino Uno Pinout Diagram

[Click Image(s) for Larger View]

Close the Tab to Return

Coax that connects things! topic divider

Go back to top ↑



SARA Arduino Beginning/Simulation

You cannot "really learn" the Arduino System without actually getting a system and doing some of your own programming!  You MUST actually get involved and type in the programs, find errors, make the corrections, and then repeat it a few times. You must learn each of the steps in going through this entire process -- it is NOT "a read and do" process (you got to get down and play with the dirt if your going to make really good mud). You can read for basic understanding, but you will not really learn "to do" until you actually go through the process steps yourself several times. Your goal should be to get in there and actually learn the entire process. After actually going through all the steps a few times (found in the various sources and tutorials), you will be quite prepared to do your own thing! Trust in the 'learning process' and you will learn all that you need. You will be able to impress yourself and others with your new knowledge and make 'professional quality' projects. Another thing to keep in mind is that when you "own the project", it never really gets 'complete'. You will want to improve it or change it once it starts working ~ this is 'technical thinkers' downfall and appears to apply universaly. A MAJOR suggestion is to take the time to comment ALL your programming code right from the start. This is a simple thing when you are initially are writing it, but becomes very strong tool when you come back later to make changes and then troubleshoot those changes. This is one of the large downfalls for many people just starting to program (coding), they convince themselves that the code is easy to understand and that good comments are not needed. That is JUST WRONG, they will eventually learn when they wish to modify the code later and end up spending extra hours trying to remember "What were the initial thoughts and the 'simple' process steps trying to accomplish and the desired action(s)?". All GOOD experienced programmers comment everything as they write it the first time. For a thought starter read Adafruit's K. TOWNSEND's Guide to Readable Code. I will consider that a fair warning and get back on topic (I tend to get on a soapbox once in awhile, sorry for that ~ Well, I'm not really too sorry!).

For the cost conscious and heavy thinkers, you can use a great little tool called a 'simulator'. It allows you to use a computer to simulate an Arduino to test and develop your coding (sketches) without having actual hardware. An excellent freeware real-time simulator for the Arduino is UnoArduSim developed by Dr. Stan Simmons of the Queen's University in Ontario, Canada. You can choose various virtual I/O devices, configure and connect them into a virtual Arduino Uno using a Lab Bench Pane {program window}. It allows you to write, develop and debug your code, without the dangers of smoking any of your hardware. You can download the installation software from: UnoArduSim site Currently at V1.7.2 Fix (04 Aug 2017).

This is a high-level-language simulator, only C++ statements are supported (no assembly laguage statements). Remember it is "FREE". As a high level simulator the internal processor register content is not displayed in the simulator (or writeable/readable). I should mention it is for Windows only as it comes. Version 1.1 of UnoArduSim supports the official Arduino programing language V1.0.6. If something is missing, you can probably make a work-around to cover the issue. Try your hand at entering some of the beginners Arduino sketches from various tutorials and insure you get the simulator working properly. A great way to learn the all steps getting your Arduino development skills to a high level. Go Code for the Arduino!

You should download and use the Integrated Development Environment [IDE] developed for the Arduino. It is a free download and allows the programming and downloading of many microcomputer/microcontroller projects. The IDE started with just the 'Arduino', but soon other types were added to the list of units supported. As you use and learn the IDE your skills will radpidly grow. You may want the Guide for installing the Arduino IDE {Windows}. [Note: I use the same IDE for ESP32 development.] After a few cycles you will have learned the necessary steps and be moving quickly through this process.

Coax that connects things! topic divider

Go back to top ↑


"What is an ARDUINO?" or An Introduction of Arduino "UNO" Rev.3

The 'simple' answer is that an Arduino is actually set of small microcontroller circuit boards (about eight of them ~ and growing). Most have a USB communication chip, a small amount of power supply items, some (4) indicator LEDs and various supporting electronic components along with the microcontroller chip. Power connector, USB jack, reset button switch and header blocks are on most of the boards, these become the main physical interconnects for an Arduino project. The Arduino "UNO" (currently the most popular Arduino which is what this page will use) has the ATmega 328 microcontroller and the Atmega16U2 chip (it was an Atmega8U2 up to version R2) and is programmed as a USB-to-serial converter. This allow usage of a USB cable from the Arduino UNO board to your computer. This single connection allows for information transfers with just the Arduino and the one USB cable, attached to your computer. The 'UNO' design is being followed by the 'Leonardo' (newer approach). These are the two most popular Arduinos and there are hundreds of 'shields' for use with Arduino boards. They pulled the site in January,2019 and expected to reset it in mid-2019... TRY YOUR OWN SEARCH FOR RIGHT NOW.

Two terms you need to know and understand when starting are: 'sketch' & 'shield'. A 'sketch' is the C programing code which is compiled (turned into a binary or hex file) for an Arduino project. So a sketch is the "programming Code" or simply 'the program'[software]. A 'shield' is a direct plug-on circuit board [hardware] for use with the Arduino (these boards are called HATS in the Raspberry Pi and Caps in Beagle Board worlds). For Arduino there are literally a hundred or more of these small boards allowing you to connect or interface other hardware units to your Arduino. You will become familiar with these terms as you get learning, but knowing the terms becomes important when you first start out.

The initial "Arduino project" started in 2005 and uses an 'open source' software and 'open source' hardware environment. QST for November, 2015 (page 30) has a nice article on the Arduino, "Introduction to the Arduino Microcontroller" by Glen Popiel, KW5GP. For another set of good tutorial series look at:;; &

Go back to top ↑


Every Arduino 'sketch' [program] contains two basic parts. First is a 'void setup' portion that runs statements only once starting when power is applied. The second is a 'void loop' that starts after setup, and then runs the loop continuously until power is removed. Function calls can be executed from these two areas to allow concise use of resources. Good programming requires internal documentation and the sketch supports two different comment types. A "block comment" starts with a '/*' and ends with '*/'. Everything between these is considered a comment and is ignored by the programming actions. These are used for longer comment sections of code, typically at start of the file and where a lengthy set of comments are required. A "line comment" starts with '//' and tells the system to ignore all items on the rest of the line (terminates with a line-feed). Reading a few good example sketches will have you easily understanding these comment types and how they are used.

It is the reusability concepts of "open software" and "open hardware" that allows easy and free use. Using what others have already designed, you can skip over many, many complex technical details. This greatly simplifies making your own specific projects do very complex tasks and avoid getting bogged down in all the details. Also, the Arduino environment expands using 'library' files (written in C++). Usually just giving credit to the original author is all that is required to use many powerful concepts. It is all for free (a word truly worshipped by ham radio operators everywhere).

The Arduino Atmega328 has a 'bootloader' usually preinstalled (more on this topic later). The system process steps start by writing C code [your sketch] in a computer using an Integrated Development Environment [IDE], compiling (makes a 'Binary/Hexfile' from your C code), and downloading that file into the Arduino via a USB cable is the final programming step. The simple real world connection is to connect an interface [shield] to the header blocks on the Aeduino and by using a prototying breadboard, connect things to convert to the 'outer world'. Remember, a "Shield" is the term used to define a plug-in interfacing electronics board, these are used by many microcontroller development systems and final project users. Some "shield designs" are shared and used on several different controller systems, however, YOU must be careful! See the Adafruit Shield Compatibility Guide as a starting point to study the shield compatibility issues. Another method is to connecting your electronics design directly to the UNO header blocks. Another shield list is at: Shield List which tries to keep track of all the shields available. Another site is SparkFun Shields. These will give you ideas on what is available for your own usage. Conceptually, think of a 'temperature sensor shield' connected between a sensor and the Arduino board, your sketch reads the information from the sensor/shield and sends it somewhere to store and display information. You do not initially design the controller and sensor boards, you just connect an Arduino to a 'shield' as the hardware task, then move on to the software portion. Using a library file allows just a few lines of code on your part and then testing of the complete project. Later you can design hardware and simplify the entire project into a dedicated unit (usually at lower complexity and costs.

The open "Arduino" protyping platform relies on an easy to use environment which gives way to it's very wide usage (both hardware and software). The Arduino project is led (designed) and manufactured by a company headed by Massimo Banzi, CEO of Arduino. Arduino boards are able to read a variety of inputs - light on a sensor, a finger on a button, or a Twitter message - and turn them into an output - activating a motor, turning on an LED, publishing something online, etc. You tell your board what to do by sending a set of instructions (a 'sketch') to the microcontroller using an Arduino board. The best starting approach is the Arduino C programming language and the free Arduino Software IDE [Integrated Development Environment]. Most programming languages today have an IDE available for hardware/software development, some are free and some you need to purchase. An IDE is a single program with a text editor, a compiler, an assembler, and a linker all rolled into a single development environment. An Arduino sketch is based on a subset of ANSI C and uses C++ library concepts. The best approach is to use an open-source compiler (free) avr-gcc and linked against the open-source AVR Libc. The Arduino language was based in Wiring. The IDE now supports an 'online' version, so you do not need to download and install it on your computer, you can use it 'online'. Also, your work can be stored 'in-the-cloud' not on your computer. Doing this makes the project available on any computer anywhere you wish to use it. You will need to become familiar with the IDE for you to continue with Arduino types of projects.

Go back to top ↑


Over recent years, Arduino has been "the brain" supporting thousands of projects, from everyday objects to complex scientific instruments. A worldwide community of makers - students, hobbyists, artists, programmers, and professionals - has gathered around this open-source platform. Their contributions have added up to an incredible amount of 'accessible knowledge'. That knowledge can be a great help to novices and experts alike. The 'open source' nature is that everyone contributes to the community and the community gains from the 'reuse of the total effort'.

A useful book that I have been using is: "Beginning C for Arduino, Second Edition - Learn C Programming for the Arduino" by Jack Purdum,PHD [ISBN-13(pbk): 978-1-4842-0941-7 :: (electronic): 978-1-4842-0940-0]. Cost is about $25.00 to $50.00 ([pricing from used to new, w/shipping), search the internet or visit a physical library. Oh, Jack is also fellow ham, W8TEE, and has BITX40 work ongoing (he gets involved in his projects).

Another book I have used is "Sams Teach Yourself Arduino Programming in 24 Hours" by Richard Blum, [ISBN-13: 978-0-672-33712-3]. Cost is about $29.99. I found both these to be easy to read and have been using them for references. Some of the topics get a little deep for a beginner on a first read, but the explanations are done quite well and makes the topics understandable. Many 'C' and 'C++' books are available and add to your knowledge. Many, many technical books can be found for free reading on the internet, just start searching.

The Arduino Product Lineup (yep, more than one product) uses ATmega processors and many different boards have different capabilities. [Checkout Adafruit's Arduino Selection Guideline]. For this site's [SARA] discussion we will focus on the Arduino "UNO" revision 3 {$24.95 from adafruit product #50} see Adafruit product link. To start lets use "adafruit" as learning source for information. They sell most of the devices we will be discussing/working with and have proven to be a great source for information on their products. The Arduino UNO Tecnical Specification is here. There are many, many other sources than adafruit - just search Arduino on an internet search engine and start reading. I have used (and do use) Adafuit for many of my Raspberry Pi & Arduino prototyping project needs and they ship quickly and are resonable on pricing. Thay also supply lots of good technical information on how to work with and use the hardware.

It is assumed we will be using a working 'Windows' computer with an internet connection Apple and Linuix computers can be used also - you should search for specifics. It is highly suggested that you start with a "genuine" Arduino board to avoid some difficulties. We will be discussing specifically the "Arduino UNU rev 3" unit. Some of the cheaper Arduino clones from eBay, Amazon, etc. may not be quite on par with the inital units and can cause some issues later. The clones can have different processors, USB chip, missing bootloader code, etc. Start with one "known good board". You may go cheap later but start with 'known good' hardware to avoid many issues (usually solvable but take time and knowledge). You will need a USB data cable with 'A' and 'B' ends (like most printer style cables). I have several cables bought at ham swaps for about $3.00 each, 'Best Buy' sells them for about $10.00 and a little chaeper onlie. The USB is used to power and program the Arduino. A small power adapter/wallwart (center positive and 7 to 12 Vdc at about 1 A) may be desired to later power the Arduino as a stand-alone (no computer). There are many types of "shield"(s) available (100's of hardware plug-in boards) and libraries for loading into the IDE. I started with a I2C Controlled LCD + Keypad shield and a 16 x 2 LCD display {bought as a kit for $19.95 from adafruit product #772}. We will use the official 'Arduino' IDE for our development (there are some others you can find by searching). The 772 kit allows the connection from the Arduino to the display using only four wires and makes wring to the display simple with simple functions. Small microcontrollers/computers are ALWAYS looking for flexibility in I/O connections and memory space constraints. You will find I2C connectivity frees up many interconnect issues (you will wish to understand this concept as you start complex projects). The I2C shield has a 28 pin IC that does the hard work to use 16 X 2 or 20 x 4 LCD displays from the I2C communication lines. The kit also has five programable switches and a 'reset' switch for the Arduino. I2C can connect up to 1008 devices using just two control lines, so it can really save on pin counts. Additionally there are converters for asynchronous serial port (RS-232) and/or Serial Peripheral Interface (SPI), an interesting read on the topic is Spark Fun tutorial on I2C.

Go back to top ↑


NEW content April, 2019

An 'Arduino Step by Step - Getting Started' [ASbS] is available 'online' or E-book style for free. Arduino Step-by-Step at looks like a good way to step through all basics. Check them out. You will need to register and provide your email address, but the 67 page booklet is free.

Coax that connects things! topic divider

Go back to top ↑


ATmega328 ~ Used in Arduino UNO

The '328 microcontroller high level information:

  • 28 Pin DIP IC
  • Runs at 16 MHz
  • 32 KB of flash storage
  • 2 KB of RAM
  • Powered by 3 or 5 Volts
  • Requires about 0.1 Watts of power
  • Cost is about $5 per chip (if you want to play later)

A major difference between the microcontroller (having no operating system) versus a microcomputer (which requires an operating system, say Mac OS X or Windows or Linux) is the intial booting up process. The microcontroller is very 'barebones', and has a simple bootloader. When you plug it in and turn it on, it immediately runs the bootloader and then whatever you programmed it to do until the power is removed or a reset occurs. Flash storage is where your binary/hex file is stored. The 'flash storage' inside of the chip lasts for a really long time (20+ years). You could program your Arduino, leave it alone for decades, & come back and power it up and it would work just fine. As the cost is small, most just leave the entire Arduino inside their project. It is important to note that their are two microcontrollers chips on the Arduino UNO. The one you program is the ATmega328, the other is a ATmega16U2 which handles some external interfacing stuff.

Lets get onto the Arduino UNO (sketching and hardware):

We suggest that you start online at adafruit using Ladyada's Learn Arduino - Lesson #0 and continue then with lessons 1 through lesson 3. These four lessons teach very basic things, but they are a good framework to build on. Lesson #0 will step you through making sure your Arduino is actually working with your system (kind of important for you to be able to continue).

Lesson #1 will start you with the Arduino IDE; correct Arduino board selection, Correct Serial Port ID (needed for programming); & load a sketch from the IDE to the Arduino.

Lesson #2 will start having you write/change a sketch [program]. Later lessons keep instructing you to control LEDs, motors, switch and other inputs, etc. A nice slow leading lesson path to lots of functionality.

Lesson #3 covers RGB LEDs and further understanding the sketch logic. I think at this point you can start out on your own playing around.

The lessons continue out through number 15 with new topics in each lesson. Continuing through lesson 15, you will be 'very knowledgeable' and way past the 'beginner' stage. If you use one or both of the books we mentioned and step through them, you are definitely not a beginner anymore.

This learning path will get you started towards being knowledgeable about the Arduino UNO and writing/changing various sketches. The Arduino knowledge will be valid on the complete family of Arduino products. After this stage, you are free to dream up your own application project and proceed.

The Arduino IDE is like many current/modern computer/controller environments. It uses "libraries" to extend the capability of code and makes easy 'code reuse' a reality. Libraries quickly and easily extend your sketches (programs). It eliminates a lot of work when your program needs special input/output handling (the complex stuff). Generally a library can be found already written to cover your requirements. You should spend some time reviewing what is actually inside the 'standard' IDE library and how you can add new libraries to the IDE. Perhaps even writting some of your own (See Writing Your Library). NOTE: Arduino libraries must be written in C++ and contain a header file (.h) and a code file (.cpp). Please make sure your libraries are stored at a different path than the IDE supplied libraries. If (or when) the IDE gets updated, you can/may loose any libraries you have added! See Arduino Library Examples for exploring what is in the various supplied libraries. You can kind of think of libraries as 'drivers' for your projects. To review the Standard Libraries checkout Arduino Standard Libraries.

Go back to top ↑


Documenting what "version of library" you are actually using is important. Put version information inside comments of your sketch, also what version of IDE you are using! You usually do not control what is inside a library or IDE. They can get updated and modified frequently. Sometimes the newer libraryIDE combination will not complie your sketch properly. Your '.ino' file will may then have errors and not work. This can be difficult to repair (and frustrating to debug) if you have not documented what specific library/IDE you used the first time. This is more of an issue with 'add-on' hardware libraries than with 'standard' libraries. You will need to properly document your program code if you want to contain and control these types of issues (they can be huge time sinks).

Adding libraries is an important process you need to explore and fully understand, as many of the ham projects require 'non-standard' libraries. Go slow and understand sample sketches and library structures as these are very important concepts to master. Many issues are discussed in the internet groups on getting a sketch (.ino file) to generate the correct hex file for downloading into the Arduino. Initial libraries (or IDEs) get updated or changed and then the compilied hex file is different (or you get errors in the compiling process and it will not generate hex code), in either case the result is an Arduino that does not work. My personal preference is once I get a 'working' hex file on the Arduino, I save a copy of the raw hex file, so I have a saved working Arduino to fall back on as I make changes. As you do not control the libraries, you cannot control the compiling process (changing from a sketch .ino file to a .hex file). You can find instructions on the internet, but once you get a valid compile (no errors), jump out to windows file explorer and search for the same file name as you '.ino' file with a '.hex' extension. Save the hex file somewhere else in your system. The '.hex' file is generated in a temporary fashion in the IDE, but get deleted when the file gets uploaded to the Arduino. So you need do your own save process. It would appear that perhaps a lot of internet chat could be eliminated by simply passing the hex files directly, however, that brings another level of complexity into the dialog, so may not really be a help. The complexity of controlling direct register access saves a large amount of hex code (very small sizes) and speed, however the probablity of failure increses greatly and the issues can be exceedinly time intensive to repair.

You deserve a "Congratulations!" you are moving very fast if you have to gotten here. We will add more here as we get deeper into the knowledge ourselves. I suggest you now go to uTube and find the tutorials by Jeremy Blum, Tutorial #1 Getting Aquainted with Arduino. Watch the whole series and learn as you go. These each move along quite fast so stop and think often. There are currently 15 units that start knowing nearly nothing and move through very advanced topics. Read the referenced books and study the programming concepts presented. Then search the internet for other '.ino' files and see if you can understand those. You will gain knowledge as you see how others have approached the issues. Please know that there are usually a great number of ways you can complete any programming task. The tradeoffs in memory and speed Vs the various programming methods is what you want to understand and learn to use. NOTE: ALWAYS use lots of comments in your sketchs to explain what and why you make a change to the code! When you comeback later to do further work, these comments are worth more than gold in your time. They add the benefit of clearly understanding what you wanted the first time.

Coax that connects things! topic divider

Go back to top ↑


ATmega168/328 - Arduino Pin Mapping

The following chart shows the ATmega 328 to the Arduino UNO pin mapping as a reference. This may not display on some portable devices, but computer screens seem to do fine (without regard to browser choice). {I will work on it later, I hope.} If your project process leads you into wanting to skip the Arduino and use an Atmega chip directly, this breakdown will be useful.

ATmega 328 Pin Map Image


Reading the comment about the ICSP pins, brings us back to the 'no boot loader' topic. ICSP stands for "In-Circuit-Serial-Programming" which is a set of pins on a board for programming the micro chip while installed on a circuit board. On Arduino these pins have four digital control pins along with power and a ground (six pins total). The warning refers to not interfering with the programmabilty of the Arduino. Try Wikipedia for general understanding and Arduino's ISP Project for further investigation. A side note is that a programmed Arduino can work as a ISP [In-Circuit Serial Programmer] for installing a 'boot loader' onto a second ATmega 328 (perhaps on an Arduino). You can find the ICSP pins on many other circuit boards, say inside a modem like the WRT-54G used for HSMM networks. You get the idea (I hope). Remember those 'clone' Arduino units I mentioned earlier. I recieved one that did not have the bootloader programmed into the unit (it was DOA ~ dead-on-arrival). Using a 'good' Arduino allowed me to install new bootload code and brought it back to a very workable unit. I had saved about $6.00 on this 'clone' Arduino, but it took a few hours of reading and digging to gain the knowledge to bring it back to life. Probably about three hours on this board, so my real saving was very reduced as I do not work for $2.00 per hour. though perhaps the learning has greater value going forward.

Arduino Zero

A 'newer' Arduino Zero model is a simple, powerful 32-bit extension from the UNO design. It features 3.3 volt logic, which matches the Raspberry Pi logic levels - making interconnecting these units an easier task. Arduino Zero Buy Site. Also, the MKR Zero and MKR1000 w/WiFi are 'Zero' models you may wish to investigate. You can start technically with the Arduino Zero Tutorial page and get going with these new units. The power of these along with a RPi Zero 'W' look amazing (or any other RPi).

You can continue searching and reading on the Arduino on you own at this point. We will leave the ATmega 328 for now and go to the AD9850 DDS for some further information.

Arduino Nano

In summer of 2019 I bought some "MORTTY" keyer kits (see QST - 2019 April page 58-59). These are powered by an Arduino Nano, which led me to "" and a quick purchase of a '3 pack of Nanos' {$12.86 to my door}. The supplier was ''. The Nano boards are good for a to marriage with an RPi for a stronger project interface (in my future). So here is some basic Nano information and then a quick review of my initial thoughts of the '3 pack'. My first comment is: "these are great for pairing with 2 and 4 line LED displays with several interfacing options!" Used a two line display and an Si5153 synthezier

The Nano has one more AD pin then the Arduino Uno due to board circuit wiring (just nice to know). See Components 101 site on Nano for a pin definition table along with views of the board and pinouts and useful information. As always, check the Arduino site for information on the Nano and make sure you are up-to-date on your Arduino IDE usage (see Getting Started with the Arduino Nano). The newer Nano (including the 3-pack) requires a different IDE driver for proper communication for programming (since January 2018). Note: It is important to select the proper board type and port in the IDE for it to work.

My 3-pack of Nanos was delivered quickly and in good condition. On first inspection, I found the board edges were a little 'rough' from the 'singulation' process, with light pressure on a file these edges quickly smoothed out. The installing of headers was simple. Note headers can be installed on top or bottom - depending on your requirements. Just make sure you know what you want BEFORE you solder them. Even with a proper desoldering tool I would not reccommend unsoldering them. It takes a lot of time do do properly and at about $4.25 each for boards, my time is better spend doing it correctly the first time or ordering new boards. My needs were easily met with the Elegoo parts! I used the 'ATmega328P' processor in the "Tools/Processor" IDE choices (the 'old boot loader' version would throw errors during the upload process - no sync). I have now built a couple of VFO projects for QRP and 'updating' some older tube recievers (man are these more VFOs stable and more accurate when installed in the older recievers!). They make the reciever 'play nice' in operation {stable and resettable} making for a very nice economy station setup with very good performance. Using one of the VFO setups on the transmitter and one on the reciever make a great HF station for a beginning ham.

I used the Si5153a due to cleaner output and lower distortion compared to AD9850 approach. As always, I followed someone else's design (saves me a lot of time). See VK3HN's Arduino/Si5351 VFO Project. These are great in a QRP rig project! Thanks to Paul for sharing.

Nano Information

Use the Components 101 site for lots of Nano Information.

Arduino Nano Board Arduino Nano Pin Diagram

[Click Image(s) for Larger View]

Close the Tab to Return

Coax that connects things! topic divider

Go back to top ↑



AD9850 CMOS, 125 MHz DDS Synthesizer Chip

Here is some of the basic details for the AD9850 and AD9851 DDS on the NJQRP DDS-60 daughter card. The AD9850 has no internal reference clock multiplier, so it requires a faster reference clock then the AD9851. Not having an internal multiplier means that code written for the AD9851 will not work directly on the AD9850 - the AD9851 code will attempt to set registers that do not exist in the AD9850. I am using 'synthesizer' and 'clock generator' as the same meaning- digitally generate a signal based on a simple input selection process (not just audio).

The daughter board contains the electronics to configure the base IC. A data sheet for the AD9850 can be found at Analog Devices (25 pages) OR at AMTEL (over 400 pages). The AD9851 datasheet is at: Analog Devices AD9851

Here is the pinout for AD9850 and AD9851 chips:(nearly the same pinout ~ Pins 5 & 6; 13 & 14; 17). Codes are not the same, so be careful to note the slight differences.

AD9850 Pin OutAD9851 Pin Out

Converting the chip to the daughter board pinouts:

D0 – D7 = Parallel programming bits
GND = Ground (obvious); Vss
CLK = Serial programming clock
Latch = Serial programming latch [FQ_UD pin on 9850]
DATA = Serial programming DATA (internally tied to D7)
RST = Reset. Generally, kept tied to GND
SQW = Square wave outputs (complementary) [Qout] Duty cycle adjustable with blue pot.
SINA = Raw unfiltered AD9850 sine output
SINB = 70 MHz LPF filtered AD9850 output.

The commonly available AD9850 / AD9851 modules on a small circuit board have two rows of 10 pin connections. These are NOT the same as the chip pinouts (above).

Go back to top ↑


The AD9850/51 take a 32 bit 'frequency tuning word' and an 8 bit "phase control word (yes that is a 40 bit word or 5 x 8bit words). Using the AD9851 (180 Mhz clock) and formulas for calculating the 'frequency tuning word' being a 32 bit integer, when the word is incremented by 1 the sine wave increases by .0419Hz - also the minimum frequency - when the tuning word is set to 1. This becomes the "step size" for the output frequency. From very low frequencies to the maximum output frequency these become the smallest change you can make. The actual accuracy of the frequency is based on the DDS crystal clock oscillator. It is fairly stable, but small calibration corrections need to be considered in software, call it a calibration offset term.

Viewed from top of circuit board with the "trimmer pot" at the top.

  Pin    Signal       Signal    Pin  
1 GND   Zout2 (sq) 20
2 D7   Zout1 (sq) 19
3 D6    Qout2 (sin)  18
4 D5   Qout1 (sin) 17
5 D4   GND 16
6 D3   RESET 15
7 D2   DATA 14
8 D1   FU_UD 13
9 D0   W.CLK 12
10 Vcc   Vcc 11


NOTE: Qout 2 is a 70 MHz low pass filtered output. There is an indication that the "DATA" is internally connected to the "D7" pin.

You will find some interesting application feature in various "application notes". Check them out: DDS Application Note files or Analog Devices App Notes. {I like the AN557: An Experimenter's Project paper on incorporating into an Amateur Radio VFO. It is at AN-557 App Note.} Want to sync up two (or more) AD9850 modules then see AN-587 App Note ~ Synchronizing Multiple AD9850/AD9851 DDS-Based Synthesizers.

These are very nice DDS modules when used properly. The Si5351 modules have only square wave outputs, but have wider frequency coverage and are a smaller (lower power) design. Search the inernet for more information (there is quite a lot available).

Coax that connects things! topic divider

Go back to top ↑




Richard Visokey, AD7C, has a nice design for a 1 Mhz to 40 MHz VFO that uses the AD9850 DDS; an Arduino Nano and a 1602 LCD Display controlled by a rotarty encoder with internal push button switch (2013-Mar-25 rev 1.0). The Arduino UNO can be substituted for the Nano and meets the hardware I have, so seemed like a great place to start. The design uses the rotary encoder to set the frequency with the push button changing the resolution (digit) that is to be changed. There is a 'MF Frequency Shift' push button for making a intermediate frequency change allowing the display to show a 'readout' frequency that compensates for an I.F. shift for a receiver. His information: AD7C VFO site with links to project files. The layout concept is an Arduino, an AD9850 DDS, A LCD Readout and a digital encoder connected and controled by a sketch. This yields a 1 to 40 MHz signal source (VFO) for various projects. Some signal output level control may be required for your specific usage requirement, but a stable frequencey control element is obtained from this circuit.

Front panel will have a 16 x 2 display, a rotary encoder knob (with push switch) and a push button for input. Rear panel will have the VFO signal (output) and a power input jack. I use reverse power polarity protection of a fuse (1A and a reverse polarity diode). I do not like smoke when I apply reverse voltage to my projects. I know - do not connect it backwards, but when it is late and I hurry, things seem to happen. Using protection means reverse voltage will blow the fuse (not my electronics). Some things in life deserve just a little protection.

The initial UNO has the MF Frequency switch (pull low on switch push) on Analog pin A5 and the rotary push button (pull low on switch press) on A0. Power from rear panel goes to the VIN of the Arduino UNO and negative supply to GND. The 5+ of the UNO is connnected to the LCD Display and AD9850 DDS and GND from these are tied together and supplied to the rotary encoder. There is an 'internal' 25 kOhm potentimeter (display intensity) with ends to +5 and ground. The center tap goes to pin 3 on the LCD display. Six pins on the LCD display connect to the UNO. The RS (LCD4 goes to UNO D12 and E (LCD6 goes to UNO D13), these are the reset and enable signals. There are four character control wires: LCD 11, 12 13 & 14 to the UNO Digital pins D7, D6, D5 & D4 (four adjacent with reverse order). The final four connections go from the UNO to the AD9850 DDS. UNO D8 goes to AD9850 WCLK; UNO D9 to AD9850 FQUP; UNO D10 to AD9850 DATA; UNO D11 to AD9850 RST. Check your wiring twice! See the AD7C site for a nice schematic. If you desire higher than 0.3 P-P signal you will need a buffer amplifier. See DDS Buffer Amplifier. Also note that as frequency is increased the amplitude falls. Perhaps an AGC circuit would be required, I may play with his later.

As mentioned above the AD7C site has the link for downloading the project files or use AD7C Project file in a zip file. I used the "IF version" of the project files and uploaded through the Arduino IDE process. Follow the process you have been experimenting with all the tutorials and it goes pretty easy!

That was all that I required to get a very nice VFO working. Stabilty is great and it is easy to reset the frequency. I added the a small buffer amplifier and have fed the output into a 'classic' radio, replacing the local oscillator signal, for use with a 455 kHz IF. It works as advertised and I am sure I will continue to expand concepts around the Arduino family and the AD9850/AD9851 modules. Perhaps powering some my old Novice license transmitters (mine expired in 1970 and that does make them "old".)

I want to thank AD7C and others who have done all the heavy lifting on this project. Sure makes it simple for following and adding these tools to my play box. Now I got to go play!

Coax that connects things! topic divider

Go back to top ↑


N2HTT VFO (QST, July, 2017, page 30)

Mike Alello, N2HTT, has nice article for a 3 band VFO project using the si5351 modile, an amplifier and the Arduino making up a tube drive VFO unit. The article has links to sketches, background and hardware links. It uses a 4 line LCD for viewing and a rotary encoder with switch for band selection. It has a 'keyed' approach so the VFO is off during key-up. Article looks like a nice clean approach. Anyone with additional information on this implementation can send us a line and let us know your thoughts. Adafruit hosts a Si5351 datsheet for your reference: Si5351 A/B/C Specification Sheet at Adafruit. An interesting link is "ZL2PD Ham and Homebrew Electronics" and search through the various VFO pages.

Coax that connects things! topic divider

Go back to top ↑



Side thoughts and References


Electronic Design Automation

Fritzing is a design software package for designers and artists with an interest in physical computing and prototyping. To assist robust prototyping and bringing your ideas to fruition and to document an electronic project, this is a great place to get started. You have a "skecth area" for working on your breadboard project. The 'breadboard' layout is for your use and describing to others what your breadboard circuit looks like. That will flow into a schematic diagram and then into circuit board layout processes. This allows great project tracking from breadboard to printed circuit board.

A quick download and update from Fritzing download gets you started. Read the getting started with Fritzing. You should first build a actual circuit and then document it (Fritzing it!). Then start using the software project for modifications, rebuild and retesting. It makes it easy to show others what you have done by sharing the Fritzing files. Try learning Fritzing for further reading on getting going. New to me, so very little to offer right now. I will try to expand later as I gain knowledge here.


Breadboarding may be a new topic for you. Small plug-in boards can be used with actual components to quickly assemble and test electronic circuits. They can save you time when trying many circuit concpets. This includes Arduino projects. Concpet will start collecting here and grow as time permits.

Breadboarding for Beginners ~ Starting Information on using a Breadboard.

Coax that connects things! topic divider

Go back to top ↑


Arduino References

The following are some useful online references for the Arduino and-or the AD9850/AD9851:

Arduino Libraries Display Information

The following are some additional useful Arduino library links you may wish to investigate:

Another great spot for working with displays is:

    LCD Wiki ~ Loads of LCD Display information and libraries for many displays and Guides for usages.

The is great for RPi usage also.

Coax that connects things! topic divider


Go back to top ↑