Friday, October 7, 2016

Bay Area Blind Arduino Monthly Meetup

The Blind Arduino Project is delighted to announce the kickoff of the Bay Area Blind Arduino Monthly Meetup -- BABAMM!! Beginning on October 8, 2016, Bay Area makers, both blind and sighted, will gather on the second Saturday of every month to construct, code, converse, and collaborate on Arduino and Arduino-ish projects. Bring your own or plan to join with others to teach and learn in a supportive and friendly environment focusing on empowering blind and visually-impaired people to make their own accessible stuff with Arduino.

If you are a blind maker working on a project, or if you are blind or sighted and have an interest in learning more about how blind and visually-impaired makers build stuff with Arduino, we invite you to bring your projects and your passion to BABAMM. We welcome beginners and masters alike, and are eager to learn and share our knowledge about all things Blind Arduino!

Meetups take place in the Innovation Lab at the LightHouse in San Francisco from 1:00 to 5:00 on the second Saturday of every month. Space is not unlimited, so it is really helpful to have an idea of how many people to expect. If you’re interested or think you might want to come, we would really appreciate it if you would sign up for the Bay Area Blind Arduino Monthly Meetup group. This makes it a lot easier for us to remind you when the meetups are happening, and to let you know about any special things that might be planned for future meetups.

Please join us for BABAMM! We look forward to crossing paths with many new and old friends as the Bay Area Blind Arduino Monthly Meetups continue to build momentum, community, and cool devices.

Tuesday, August 23, 2016

Configuring The Arduino IDE with the Java Access Bridge

Elsewhere in this blog I have discussed the relative inaccessibility of the Arduino IDE -- the free integrated development environment downloadable from Various rumors and suggestions have reached me about how it can be configured to work with the Java Access Bridge, but despite hours of effort I have never been able to do it myself.

Now, Ken Perry, blind maker, frequent advisor to the Blind Arduino Blog, and software engineer at the American Printing House for the Blind, has finally documented how to make the Arduino IDE work with a Windows screen reader. It is one of the early posts in what is bound to be an awesome blog on blind electronics.

It's great that Ken has finally told us how to get the Arduino IDE to work with the JAB, but I will probably continue to write code and upload from Notepad++ rather than use JAB with the IDE. This is mostly because I have concerns about the security of the Java Access Bridge, but I also feel like I have spent enough hours of my life fruitlessly wrestling with the JAB and don't feel like doing it any more. Maybe I'll try it some day when I'm feeling energized and long on patience.

For many people working in larger institutions such as schools or libraries, the JAB approach will also not be convenient because it requires extensive modification of environment variables and system-level files. Many system administrators will not like the configuration changes necessary to make the Java Access Bridge work with the Arduino IDE.

But the good news is that you can do it if you want, and Ken Perry is the hero of the day for finally telling us how. Thanks, Ken!

Sunday, July 3, 2016

How to Compile and Upload Arduino Sketches with Notepad++ -- Simple, Convenient, Accessible


Blind people living in the real world are constantly working out hacks and alternatives to “normal” work flows that are inaccessible in whole or in part. Arduino software development is no exception, and many of the posts in this blog have been devoted to working around the sketchy (sic) accessibility of the Arduino IDE itself. For example, in an earlier post I describe (perhaps in more detail than strictly necessary) how to set up and configure the Arduino IDE from the Windows command line. In another post, Chancey Fleet provided excellent step-by-step instructions for installing and using Visual Micro to compile and upload Arduino sketches directly from Visual Studio. The current post offers the most convenient Arduino development tool chain I have yet found –editing, compiling, and uploading sketches directly from Notepad++.

Notepad++ (hereafter Npp) is my text editor of choice for almost any simple editing work including coding Arduino. It is used by many developers who don’t want the overhead of a giant IDE just to edit a bit of code. It’s free, open source, simple to install, and largely accessible with whatever screen reader you happen to prefer. It has features such as code completion, line numbers, support for different character encodings, and many others, yet it remains extremely compact and easy to use. Perhaps my favorite feature is that it doesn’t care what kind of line endings you use, CR/LF or just LF – it just does the right thing. This is really nice when using cross-platform source files such as Arduino sketches. If you don’t know what I’m talking about, just take my word for it: Notepad++ is extremely convenient and easy to use as a code editor.

Compiling and uploading Arduino sketches from the command line is great for those of us who are really old school and feel at home typing incredibly long text-based commands. For others though, those long commands are just opportunities for typos and inexplicable DOS error messages. Similarly, for hardcore hackers who have millions of lines of code under their belts, Visual Studio might be the best Arduino development environment you could want. Speaking for myself, however, Visual Studio makes me feel like the Sorcerer’s Apprentice with too many options, settings, and terms that I don’t quite understand, and an incredibly complex interface as reins to ultimate unwanted and undeserved power. In fact, I recently hit an accidental keystroke in VS and the entire thing stopped working. Of course, if I knew what I was doing in there then I’d be able to fix it, but I don’t have that kind of time and I don’t want that kind of power. I just want to write a little Arduino code!

In contrast, Npp is just my speed. It lets me do what I need to do without giving me a dangerous amount of rope. At the same time it has hidden depths which can be quite handy. You could say that I am definitely down with Npp…

But Npp is just an editor. It is not a compiler or an integrated development environment, so it can’t compile or upload your Arduino sketches. On the other hand, it can be configured to interact with other programs on your computer (such as the Arduino IDE) which can. This article explains how to set things up to let you edit an Arduino sketch with Notepad++, and then compile and upload that sketch with a single command without ever leaving Npp. The resulting Arduino compiler output and error messages are even displayed in a Notepad++ window for easy review.

The following sections offer two scripts that can be executed from inside Notepad++. The first allows you to set the Arduino COM port – convenient since this may change frequently with different boards and USB ports. The other compiles and uploads the Arduino sketch that is currently open in Notepad++.

Setting It Up

Step 1: Download the latest Arduino IDE and install it. If necessary, check out my instructions on installing and configuring the Arduino IDE from the command line.

Step 2: Download the latest version of Notepad++ (Npp) and install it. This process is easy and you should have no accessibility-related problems. Take note of the directory where you are installing it because you’ll need to find it later to install the Npp plugin.

Step 3: Download NppExec (a plugin for NPP) and install it. The installation process consists of unzipping the NppExec archive and copying the appropriate DLL into the plugins directory of the Npp installation directory. You are probably using the Unicode version of Npp, so copy the NppExec.dll file from the DLL_Unicode folder of the archive to the plugins directory of Npp and restart Npp to complete the installation. For example, my Npp plugins directory is "C:\Program Files (x86)\Notepad++\plugins"

Step 4: Set up the following Arduino-related NppExec scripts in Npp. You can either copy and paste them from below or download the NppExec scripts in this convenient archive.

The easiest way to install these scripts is to copy and paste them individually into the Execute dialog in NPP. This dialog can be opened with a keyboard shortcut (F6 inside Npp), or through Npp’s menus (Plugins > NppExec > Execute…).

The Execute dialog has a multi-line edit field for pasting or typing the script itself, a Save button for naming and saving scripts, a combo box for recalling previously saved scripts, and an OK button to execute the selected script. All the controls in this dialog are accessible with NVDA or JAWS.

The Arduino COM Port Script

This script makes it easy to quickly update the Arduino IDE’s COM port. This is the port used to upload the sketch to the board. When you invoke this script from inside Npp, a dialog pops up asking for the Arduino’s COM port. Appropriate responses are like the parameters you would use on the command line when setting the com port (e.g., com3, com4, etc.).

To set up the port selection script, open the Execute dialog by pressing F6 or by selecting Execute from the NppExec sub-menu of the Plugins menu. Paste the following script into the edit field and press the Save button. In the Save dialog, type something like “ Arduino Port,” and press return. The port selection script will then be saved for future use using that name.

Before saving, be sure to edit this script to reflect the actual location of your Arduino installation. I have mine in the root directory for convenience – “c:\arduino”.

//This NppExec script sets the com port of your Arduino IDE
//By Josh Miele -- June 27, 2016
//The Blind Arduino Project
set arduino_path = c:\arduino\arduino_debug //the path to your Arduino IDE.
//put up a dialog box requesting com port name
inputbox "Please enter the COM port of your Arduino (e.g., com5):" //gets com port value
//use result to set port value doesn't verify
cmd /c "$(arduino_path)" --port $(input)
npp_console 0 //hide the console

Note: This script does no checking to make sure that you have entered a valid COM port or string. If you make an error typing or enter an invalid com port, you will get no error message or other feedback to indicate your mistake. Take care!

The Compile and Upload Script

This script saves the currently open Arduino sketch, then calls the Arduino IDE with the command line parameters to compile and upload it. It then passes any output, including errors to a new Npp file so that you can easily see what happened.

To set up the compile/upload script, open the Execute dialog by pressing F6 or by selecting Execute from the NppExec sub-menu of the Plugins menu. Paste the following script into the edit field and press the Save button. In the Save dialog, type something like “ Arduino Upload,” and press return. The compile/upload script will then be saved for future use using that name.

Before saving, be sure to edit this script to reflect the actual location of your Arduino installation. I have mine in the root directory for convenience – “c:\arduino”. Also make sure that the Arduino_output.txt file is being created in a directory where you have write privileges and where it won’t cause any problems. I put mine in “c:\temp”. The first time the script runs it will ask for permission to create the output file. After that it will quietly overwrite the file with each new execution of the script.

//This NppExec script compiles and uploads the current Arduino sketch in Npp
//By Josh Miele -- June 27, 2016
//The Blind Arduino Project
//Set where the output goes. Make sure you have write privileges
set arduino_output = "c:\temp\arduino messages.txt" 
//Set location of Arduino executable. 
set arduino_path = c:\arduino\arduino_debug 
npp_save //save current file before uploading
//Compile and upload sketch in current Npp window and send stdOut and stdErr to arduino_output
cmd /c "$(arduino_path)" --upload $(full_current_path)>$(arduino_output) 2>&1
npp_console 0 //hide the console
//show the results of the compile/upload in Npp window
npp_open $(arduino_output)  

Note: This script does not account for the fact that the Arduino IDE will move your sketch if it is not already inside a folder of the same name as the stem of the script. For example, if you are editing a file called MySketch.ino located in c:\temp, executing the above NppExec compile/upload script will compile and upload the sketch, but the Arduino Ide will create a directory called c:\temp\MySketch and move the file MySketch.ino inside it. Notepad++will be left with an open file that has been moved out from under it. This has the potential to lead to unexpected errors and problems, so I recommend making sure your sketches are contained within folders of the appropriate name as modeled in the Arduino examples directory.

Using the Scripts

To invoke these scripts from inside Npp, press F6 to bring up the Execute dialog, then use your arrow keys to select the desired script from the combo box and press return. Pressing ctrl-F6 will execute the last script without invoking the execute dialog.

Note: There is a way to map individual NppExec scripts to their own keyboard shortcuts using the Shortcut Mapper under the Settings menu. Unfortunately, this dialog is not accessible using NVDA or JAWS. I believe there is a way to modify the shortcut mappings by editing one of Npp’s XML files, but I don’t yet know how to do this. In the interest of getting this info into your hands, I decided to post this anyway and update the post when I find an accessible way to map the shortcuts. If you have info about how to do this, please leave it in the comments.

References and Disclaimers

I’m no expert in any of the several areas necessary for creating elegant and effective NppExec scripts. I encourage feedback in the comments and invite suggestions for improvement and additional helpful scripts.

In developing these scripts I found the following resources extremely informative:

Monday, June 20, 2016

Consider the Continuity Tester

It has been argued that the continuity tester is one of the most essential pieces of equipment for a blind electronics maker. It is a device which provides accessible feedback when current flows in a circuit -- basically an Ohmmeter or resistance meter. A continuity tester with audio or tactile output provides an accessible way of testing and even identifying components, leads, and connections, tracing paths on circuit boards, checking solder joints, and even making other simple measurement tools such as light detectors and thermometers. While the sighted person finds occasional uses for an Ohmmeter, the continuity tester is an indispensable and pervasive tool for the blind maker. I cannot over emphasize the importance of having one.

They come in a variety of flavors, from simple circuits which buzz below a specified resistance threshold to oscillators that vary the pitch of an audible tone depending on the amount of resistance in the circuit. The classic continuity tester described in the following section, as well as many other awesome accessible continuity tester circuits and their uses, are fully documented in the Fall, 1982 issue of the Smith-Kettlewell Technical File. Advanced makers should definitely study these for insight into some old-school accessible test equipment.

The Classic Continuity Tester

The classic Smith-Kettlewell continuity tester is an elegantly simple circuit which makes for an excellent first soldering project (read the Soldering Series in the Smith-Kettlewell Technical File for all the information you need on blind soldering techniques). If you're planning to build electronics, make stuff with Arduino, or otherwise make a habit of messing around with wires and components, I strongly recommend building one. It's reliable, versatile, and extremely nice to have around.

Building the Classic Continuity Tester

The continuity tester's oscillator consists of an audio output transformer and a PNP transistor. An 8 Ohm speaker is connected across the leads of the low-impedance secondary of the transformer. The primary of the transformer has a center tap which connects to the emitter of the transistor. One end of the transformer's primary connects to the Positive terminal of a 9-volt battery. The other primary lead connects through a 0.022 uF capacitor to the base of the transistor. Across the entire primary is another 0.022 uF capacitor. The base of the transistor connects through a 22K resistor to the positive test terminal. The negative test terminal connects to the collector of the transistor and the negative terminal of the battery (ground). That's it!

A Simple Arduino-Based Continuity Tester

While the continuity tester described above is extremely simple and reliable, you may not have these capacitors, transformers, or transistors readily at hand. Possibly you aren't yet confident enough with a soldering iron to build it. Sometimes you may want to slap a continuity tester together using an Arduino and a couple of resistors. The following sketch makes a reasonably handy audible continuity tester, although the classic continuity tester described above is superior in most ways.

Building the Arduino Continuity Tester

Connect a 1 mega Ohm resistor and a 1 kilo Ohm resistor to analog pin 0 of the Arduino board. Connect the other end of the 1 mega Ohm resistor to ground and the other end of the 1 kilo Ohm resistor to +5v. Connect a piezoelectric buzzer to digital pin 9 and ground, (or you can substitute a speaker in series with a 100 Ohm resistor). Connect the positive test lead to analog pin 0 and the negative test lead to ground.

Programming the Arduino Continuity Tester

Copy and paste the following sketch into your development environment, make any desired modifications, and upload it to your Arduino. You can also download the continuity tester sketch here.

Simple Audio Continuity Tester

Wiring Description
Resistors -- 1Meg, 1K, 100 Ohm.
8 Ohm speaker or piezo buzzer
jumper cables and test leads

Connect buzzer to pin 9 and ground.
If using a speaker, connect one side to pin 9. 
The other side of the speaker goes to 100 Ohm res, which goes to ground.

Connect 1K to +5V. The other end connects to a junction which includes the positive test lead, analog pin 0, and  the 1M. 
The other end of the 1M goes to ground. 

The negative test lead also connects to ground.

When there is no connection between the test leads, the speaker is silent. It begins to click when there is some conductivity, and produces a 500 Hz tone when there is no resistance.

Play with resistor values and the mapping of reading to ici to optimize for the range of sensitivity you need.

By Josh Miele
The Blind Arduino Project, June 17, 2016.

int sensorPin = 0; //the pin connected to +test lead
int speakerPin = 9;  //connected to speaker or buzzer
int thresh = 1000;   //above this sensor val no sound is played
int reading = 0;  //analog input value somewhere between 0 and 1023;
int ici = 0;   //inter-click interval in ms. Shorter for lower resistance values.

void setup() {
 pinMode(speakerPin, OUTPUT);    //speaker (or buzzer) pin 
 pinMode(sensorPin, INPUT);   //connected to +test lead
}   //end of setup

void loop() {
 reading = analogRead(sensorPin);  //measure voltage across 1Meg Ohm
 if (reading < thresh) {
  //if reading is less than threshold then speaker clicks
  //play a 500 Hz click 5 mS long
  tone(speakerPin, 500, 5);   
  //scale reading val to delay value in mS
  ici = map(reading, thresh, 0, 200, 0);  
  delay(ici);   //wait before playing next click
 }   //end of if
}   //end of loop

Monday, May 30, 2016

HELP -- My Arduino Headers Don't Have Gaps!

In another post I wrote about orienting yourself to the Arduino pins using tactile landmarks such as the gaps in the left and right header blocks. Unfortunately, the header blocks on some Arduino boards are manufactured without gaps between sections. Instead, both right and left headers are continuous blocks that include both upper and lower sections. Where the gap would be on most boards is simply a double-wide space on the header with no hole at all.

You can orient yourself the hard way using a probe such as a jumper pin, wire, or stylus to feel your way along the top of the header to find the spot where there is a wider gap between holes. This is the break between the upper and lower sections. While this is doable, it’s definitely a pain to do every time you need to find a particular pin.

To make navigation easier on these notchless boards, use a serrated dinner knife or a metal nail file to cut a notch between upper and lower sections that is easily detectable by touch. Guide the knife or file by placing male jumper cables on either side of the gap, that is, in the bottom hole of the top section and the top hole of the bottom section. Placing the knife or file between the two jumpers, gently saw back and forth to cut a small notch in the plastic header. Be sure to hold the Arduino by the header, not the board, to avoid straining the joint between the header and the board. The notch doesn’t need to be deep in order to be easily felt. Five to ten strokes with the knife or file should be enough. Check to be sure you can feel it and continue if necessary.

If you don’t want to permanently mark your header you can use a probe to find the gap and place a temporary landmark such as a flexible plastic toothpick or male-female jumper cable in one of the adjacent holes. The main consideration here is not to use anything which might accidentally break off or create a short.

Wednesday, May 25, 2016

What is the Blind Arduino Blog?

There is nothing new about blind makers -- we have a long history of creativity and innovation in order to get access to the information we need to do the things we want to do. We also have a long history of sharing how-to information among ourselves in order to support our community in achieving our goals and potential. The Blind Arduino Blog follows in this proud tradition.

Bob Gunderson's Braille Technical Press was a great, mid-century example of blind people supporting other blind people in building the tools they need. It largely focused on amateur radio tools and techniques, but it was an early pioneer in the blind DIY electronics genre. Bob worked as an electronics teacher at the New York Institute for the Blind and published the Braille Technical press in the 1950s as a way of documenting the accessible tools he and his students developed so that other blind hams could build and use them.

More recently in the 1980s and 90s, Bill Gerrey at The Smith-Kettlewell Eye Research Institute (where I happen to work) published the Smith-Kettlewell Technical File -- a publication inspired by Gunderson's earlier magazine. In addition to publishing instructions for building all kinds of useful accessible test equipment and refining the technique of circuit description, the Technical File published a series of excellent tutorial articles on techniques for blind solderers.

With the advent of open-source, relatively standardized, microprocessor-based project kits like Arduino, the kinds of devices that can be built by the casual maker at home have become quite sophisticated. In fact, Arduino is an ideal platform for creating a variety of accessibility devices which blind makers and users might find useful. For example Arduino would be perfect for building tools like audio and tactile meters and gauges which could be driven by any manner of sensors and detectors. From accessible scales to timers, range finders, multimeters and beyond, Arduino could make it relatively easy to design and share accessible tools which can be endlessly modified, adapted, and improved to meet a wide range of applications and needs.

A little googling reveals that there are designs for a number of Arduino-based accessibility devices scattered across the net. However, none that we have found are intended to be built by blind people, Nor is the documentation necessarily accessible. Furthermore, the fact that they are from all over the place means that they are inconsistently documented and occasionally hard to find.

The Blind Arduino Blog is another step along the road paved by Gunderson and Gerrey. Its intent is to provide a public clearing house for blind makers who want to build accessible devices with Arduino. The project has two main objectives:

  1. To provide clear instructions and accessible resources for blind people who want to develop for Arduino, and
  2. To Assemble a library of accessible project descriptions for devices that might be of particular use for blind people.

Before we can begin assembling our library of accessible Arduino devices for blind makers, there are a number of hurdles to be overcome. We can build on Bill Gerrey and Bob Gunderson's hardware-assembly description techniques to document how to build the Arduino hardware, but the coding component needs some R&D. First we need to identify and document the accessible tools and resources for learning, writing, and uploading code to the Arduino itself.

There are many different Arduino boards and accessories, and many different software tools available for coding, uploading, and debugging. Thus, the first posts to this blog will document our investigations into which boards, tutorials, and other tools are most accessible, as well as any work-arounds or tricks for getting the most out of them as a blind user. Once we have a nice foundation of accessible tools for Arduino development on which to build, we can move on to our long-range plan of collecting and developing accessible instructions for building a wide variety of accessibility devices based on Arduino. My own personal interest is in duplicating a number of devices from the S-K Technical File recast in Arduino. As our group learns and grows, I have confidence that the depth and diversity of projects will expand well beyond what I currently imagine.

Some Comments on Platforms, Screen Readers, and Browsers

Arduino software development can be done on Linux, Mac, Windows, and other platforms. This blog will focus on identifying tools that are Windows based. For folks who are comfortable in Linux, I suspect that is the easiest and most accessible path for Arduino development. However, most people are a little intimidated by Linux. While Apple has done great work with VoiceOver, the vast majority of blind users are still on Windows. For these reasons, we are committed to charting an accessible Arduino-development path through Windows. This doesn't mean that we won't include some posts on tools for other platforms, it just means that the emphasis here will be on tools for Windows.

In addition, in making our judgements about accessibility of tools and informational resources, we will assume the default screen reader/browser combination of NVDA and Firefox. Certainly there are other screen readers and browsers and preferences will vary, but web site performance will as well. Since we can't test all combinations, we will generally stick to NVDA and Firefox when we test Arduino resource sites for accessibility.

Monday, May 23, 2016

Visual Studio Community: a free, accessible IDE for Arduino

Thanks to Ken Perry for investigating and recommending Visual Studio Community 2015 as an accessible Windows environment for programming Arduino. This method requires some time and effort to set up, but once it’s done it offers screen-readable line numbering, error reporting, serial monitoring and code completion, among other advantages. I found that JAWS 17 and NVDA 2016.1 work equally well with Visual Studio Community. If you’d like to give VSC a try, here’s how:


Arduino IDE
You’ll still need to start out by downloading the Arduino IDE; you won’t be opening or coding in this IDE, but a Visual Studio plug-in needs to use the Arduino compiler behind the scenes. If you already have the IDE, check to make sure it’s the latest version; if it isn’t, download the current version before moving on. (Note: at this writing, the current version is 1.6.9. It’s of course possible that a future version will be incompatible with VSC. A quick Google search of the current IDE version and VSC version should let you know whether they’re working together). It’s a good idea to put the Arduino folder at the root of your hard drive: by default it installs within C:\Program Files, which can cause problems with permissions down the line. If you already have the IDE installed, you can just copy the whole Arduino folder from C:\Program Files to C:\.
Visual Studio Community 2015
Visual Studio Community is available as a free download. While the initial download is relatively small, budget some time (it took me around 45 minutes with a decent wifi connection) for the VSC installer to acquire and configure additional files, and make sure you have 12 gb of free storage space (8 for VSC, 4 for Visual C++) before you begin the setup process. The necessary controls to move through installation are readable with both JAWS and NVDA. To monitor the progress of installation, use the touch cursor (JAWS) or object navigation (NVDA). You may notice some “phantom controls” above the progress information that refer to ending a session, cancelling setup, and choosing an installation location. Don’t worry about those; keep your attention on the reassuring movement of the files being installed and the progress percentage.
Note: Before you start the installation, read ahead to the section of Visual C++. If you choose a custom install for VSC, you can skip an extra step later on: however, I haven’t tested this myself so I’ll be describing the (probably longer) path I took.
When setup is done, activate the “Launch” button. You’ll be prompted to sign in or create an account to connect to developer services, but you can tab and choose “Not Now, Maybe Later” if you’d rather not.
Next, you’ll be prompted to choose your development settings (the default, “General”, is fine) and a color theme. Tab and choose to “Start Visual Studio”, and go make a cup of tea or something; it takes about two minutes for VSC to configure itself.
You are now in a world of buttons leading to tutorials, news, videos and more. You can tab through these if you’d like to explore them.
Visual C++
You’ll need to install Visual C++ before programming your Arduino. If you didn’t do this when you first installed VSC, navigate to the File Menu>New>Project. In the dialog box of extension providers that appears in focus, choose Visual C++. Tab several times to a list of extensions and choose “Install Visual C++”. This installation took me about 15 minutes and all screens were readable, although I encountered “phantom messages” similar to the ones I described when installing VSC.
The Arduino Plug-in
Navigate to Tools>Extensions and Updates to install the Arduino Plug-in, otherwise known as “Visual Micro”.
Within the Extensions and Updates dialog box, shift-tab once and change the combo box from “Installed” to “All” (sorry, this box’s label seemed unreadable by NVDA). Then, tab to the search box and type in “Arduino”. Tab to the table of extensions, where “Arduino IDE for Visual Studio” should be your top hit. Tab once more to Download, and press enter to initiate download and installation. (You may need to say “Yes” to a User Account Control at this point”). One more dialog box will appear; choose Install, and follow the prompt to restart VSC. (If you receive an error message stating that “per user extensions” could not be loaded, close VSC; set its properties to always run as an administrator; and reopen it.
When VSC restarts, you’ll be placed in a dialog box to configure IDE locations. (You’ll also be shown a window containing the Arduino for Visual Studio documentation). Choose your Arduino IDE version and the installation path for your Arduino IDE, then tab and choose OK. At this point, I was presented with a message reading “toolchain reloaded” and the only way to dismiss it was to close and reopen VSC.

Getting ready to program

Select your toolbars
Navigate to View>Toolbars and select all four Micro toolbars (Boards, Project, Programmer, Serial Communications).
Configure VSC to work with your board
Visual Studio Community can work with a wide variety of microcontrollers, including Arduino. You need to specify your board and how it’s connected before you can write programs to your Arduino.
Connect your Arduino and find out what com port it’s using. To do this, open your Device Manager and expand the “Ports, Com and LPT” section.
In VSC, navigate to the “Micro Boards” toolbar (you can do this by pressing Alt for the menu bar and then pressing Control+Tab until you find the toolbar). The first combo box you find, Micro Applications, will specify your IDE version. Tab once to the Board combo box and choose your Arduino model. (Pro tip: the first choice here is “Arduino Yún” which sounds a lot like, but emphatically is not, the same thing as “Arduino Uno”. Do not waste time choosing this option and failing to program your Uno: I’ve already done that for you).
After you choose your board, navigate to the Micro Serial Communications toolbar and choose your board’s com port.

Writing a Program

To create your first project, navigate to File>New>Arduino Project. Give your project a name and press enter. A blank sketch is always populated with lines for “Void Setup” and “Voic Loop”, along with comments (bracketed by /* and */) explaining what those sections mean. If you’re writing code by hand, leave these in place; if you’re pasting in a code example that already has these sections, select and delete the existing text before you paste.

Uploading the Program

To upload your program, press Control+F5. If VSC finds errors, it will list them for you, by line and column number. If not, it will let you know whether the program finished uploading. In either case, to dismiss the message and get back to your code, press Escape.

Closing and re-opening your program

VSC refers to programs, which can include your Arduino sketch and any associated files, as “Solutions”. Navigate to File>Close Solution when you’re done working with a program, and follow the prompt to save or discard changes. To open a program you’ve previously created, navigate to File>Open>Arduino Project.