1. Arduino sketches tend to be
easier to write, since most of the
configuration and initialization work
is already done, and because there is
a rich support base — both within the
included libraries and from a vast
community of secondary developers.
Plus, it's far easier to connect a serial
terminal and send debugging
Also, if you follow certain coding
stipulations, a sketch has a good
chance of running on most (if not all)
Arduino platforms (Uno, Pro Mini,
Due, etc.). Even if it's necessary to
override the default configuration(s)
(for instance, to tweak one of the
timers), customizing isn't all that
difficult — especially because of the
plethora of support sites. A Google
search rarely fails to turn up exactly
what is needed for the job.
2. The Arduino's popularity. I'm
finding more and more that
developing an Arduino shield is a
better solution — especially
considering the demand for a good
shield (sounds like something a
gamer might say).
However, I still opt for the PIC in
cases where doing it as an Arduino
shield doesn't fit. At large quantities, a
PIC tends to be far cheaper than
even an Arduino Pro Mini. So, on a
cost basis, the PIC is often the better
Then, there's the Raspberry Pi,
which I also use. So, bottom line, in
my case, I use what best fits the
• If implementing it as an
Arduino shield fits, I do it that way.
The development path will probably
be shorter, which is fine with me.
• If the Arduino doesn't make
sense and there's no need for an
operating system, database, network
connectivity, website, or GUI, etc.,
then a PIC will probably do the job
(though cases may arise where a PIC
is the solution even if some of those
Raspberry Pi determinants are
specified — especially if I want to
keep the per unit cost down).
• Otherwise, a RaspPi might be
the thing (or a Banana Pi/Orange Pi if
Serial ATA is needed, or greater
processing speed, etc.).
• Then, there is the case where a
mix might be needed. For instance,
using an Arduino to monitor random
events (something that is difficult to
achieve with a RaspPi), and serially
connecting it to a Pi for its ability to
run a database, connect to a
network, provide an easy to develop
user interface, and/or for easier IoT,
I tend to be "solution oriented"
like Arduino users, but like I said, I'm
also old school. I do use the Arduino,
but because I care about the process.
Also, I started using the RaspPi well
before I ever picked up an Arduino.
I shied away from the Arduino
because of its relatively high unit
cost, at least until I designed my first
shield (in which case, unit cost is
ported to the consumer).
Also, I'm a stickler for
documenting my code — learned that
the hard way the first time I had to
pick up an old design and figure out
what I was thinking at the time.
I must admit, I do pride myself
on being able to fathom the nitty-gritty of the MCU world. I started
with vacuum tubes (fer kriss-sake)
and built my own small computer
systems based on the Z80. I cut my
teeth on TTL and programmed my
own EPROMs (and UV erased them,
too). So, yeah, definitely some pride
going on there.
Side note: I once worked for a
robot vision company (View
Engineering in Simi Valley, CA) as an
In one situation, I designed
diagnostic routines in machine code,
that I would "burn" onto an EPROM
and then plug into an 8080 based
system to troubleshoot the hardware
(typically to toggle data and/or
address pins that generated
meaningful [and triggerable] patterns
on a scope/logic analyzer, or to
stimulate individual peripherals that
would otherwise be hard to scope).
I'm not much of a shield
collector, but I do stock up on
various modules and breakouts (a lot
of which are Arduino compatible, but
I tend to stock them for more than
that). For example:
• 5V to 3.3V converters
• LM386 speaker drivers
• Class D speaker drivers
• 5V Buck supplies
• Electret microphone boards
• PIR sensor boards
Plus the plethora of PCB
breakouts I've designed for SMD
parts, and RGB LEDs.