A company on eBay is auctioning off pieces of an old supercomputer cluster someone had built from Jetson TK1s and Intel NUCs. The boards are old, but you get a bunch of them pretty cheap so I bought one since SBCs are always handy for projects.

The Jetsons are a nice platform for getting one’s feet wet with CUDA for vision and deep learning on a mobile (e.g. robotic) platform. The TK1 is outdated but a nice board with 2GB RAM and 16GB eMMC flash (11GB free) running Ubuntu 14.04 linux. Most importantly, the GPU is an nVidia Kepler GK20a with 192 CUDA cores providing up to 326 GFLOPs.

If you need more power, NVidia has newer boards such as the Jetson Nano ($99), TX1, TX2 ($400), Xavier ($400), and more. The newer boards are better (more memory, faster GPUs, etc.) and use the standard RPi GPIO connector to make hardware interfacing easier, but the TK1 is fine for learning.

Configure to boot from internal eMMC disk

The boards arrive configured for network booting (PXE) and you need to change that if you want to boot into ubuntu from the internal eMMC disk. To do that, you’ll need to connect to the serial port using a null modem cable or adapter and a USB-Serial cable/adapter. The unit starts out running u-boot; you can interact with it using a serial terminal ([https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html PuTTY], [https://ttssh2.osdn.jp/index.html.en TeraTerm], etc.) configured for 115kbps, 8 data bits, No parity, 1 stop bit. Reset the board and when prompted, press any key to stop the automatic boot within 3 seconds, then you’re at the u-boot prompt. You can change the boot target (default is pxe) using the following commands:

setenv boot_targets mmc0
saveenv
reset

Then when you boot, it will automatically launch ubuntu from the eMMC drive (mmc0) and you can interact with it using an HDMI monitor and USB keyboard/mouse. See here for more useful info on u-boot configuration. The default user name is ubuntu and the password is also ubuntu.

Install JetPack, reflash OS, install CUDA, OpenCV, etc.

Most users will want to use these units to experiment with CUDA-enabled code for vision processing (OpenCV) or machine learning (Tensorflow) on embedded platforms such as robots. nVidia’s tool for flashing Jetsons and loading 3rd party software is called “JetPack” and runs on a host PC running Ubuntu 14.04 linux. Fortunately, you can setup the host PC as a virtual machine (VM) running in any OS (I used Windows 10). The flashing process will require your host PC be connected to the Jetson using a common micro-USB cable and also the Jetson must be connected to the same LAN using an Ethernet cable.

Here’s how:

• Install VirtualBox and Extension Pack
• Create a VirtualBox VM for Ubuntu Linux.
  Allocate at least 2GB of RAM and 30GB (64GB is better) for the max disk size.
• Download the Ubuntu 14.04 desktop .iso
  Jetpack 3.1 requires 14.04, don’t bother trying something newer.
• Configure the VM optical drive (DVD) to use the downloaded .iso
  You’re going to install Ubuntu 14.04 onto the new VM’s drive from the virtual DVD
• Configure the VM for bridged networking
  The Jetpack requires that the VM be on the same local area network as the Jetson.
• Configure the VM for USB 3.0 support (Settings->USB) – requires Extension Pack
  This will make the USB connection used to flash the OS onto your Jetson both more reliable and much faster.
• Boot the VM and install Ubuntu
• Expand your VM desktop size to at least 1024×768 (1280×768 is better)
• Run ifconfig in your VM and make sure eth0 has an address on your local network
  (it needs this so it can talk with the Jetson after it has flashed the OS)
• In the VM, launch Firefox and download nVIdia JetPack 3.1
  (you’ll need a free nVidia developer account)
• Set the downloaded JetPack-L4T-linux-x64.run to have executable permissions
• Launch a command shell and run the downloaded .run file (does not need sudo)
• Follow directions: select TK1 as the target board, accept licenses, etc. Then when asked:
  • Connect your Jetson to Ethernet
  • Connect your Jetson to your PC via a micro USB cable
  • Connect your Jetson to 12V power
  • Configure your Jetson for Forced Recovery mode:
    • Hold down the Force Recovery button (closest to corner of board)
    • Press and release the reset (center) button
    • Wait 2 seconds and then release the Force Recovery button
  • In VirtualBox, under Devices->USB, select NVIDIA Corp APX (the Jetson) to allow the VM to have access to the Jetson via USB.
  • In your VM, run the command lsusb in a command window and make sure it shows a device named NVidia Corp. (if not, one of the above steps failed and you’ll need to try it again before proceeding)
  • If you’re going to use this VM again, you may find it useful to make it automatically capture the nVidia USB connection using VirtualBox USB Device Filters
  • The Post Installation step will take a long time; flashing the OS only takes ~10 minutes, but if you install and build all of the add-on software it will take more than an hour.
    
  • Note: much of the installation time is downloading and building the images for the Jetson. Once that’s been done once, you can launch the installer again and it will skip the unnecessary steps and you can jump ahead to flashing the OS and/or installing the applications.
cd ~/JetPack
./JetPack-L4T-3.1-linux-x64.run
    
  • Note: if you ever want to just reflash the OS:
    cd ~/JetPack/TK1/Linux_for_Tegra_tk1
sudo ./flash.sh jetson-tk1 mmcblk0p1
(This may also provide an easy way to flash the OS onto a larger SD card: mmcblk1p1)
    
    

When all is done, the Jetpack is fully installed on your VM, your Jetson is flashed with a shiny new OS (well actually an old OS: Ubuntu 14.04), and the important tools have been installed on the Jetson: CUDA, OpenCV, cuBLAS, cuDNN, and Visionworks (which has some really nifty demos installed).

To work with graphics, connect a USB keyboard and mouse and an HDMI monitor. The Jetson GPU is capable of some impressive graphics processing at high frame rates. An Rpi couldn’t touch it.

Be sure to run the samples such as oceanFFT in NVIDIA_CUDA-6.5_Samples/bin and run the gameworks sample (~/run_gameworks_sample.sh). The VisionWorks demos are even more impressive. Go to /usr/share/visionworks/sources and run the command: ./install-samples.sh ~ which will copy the samples to your home directory/VisionWorks-1.4-samples. Then go to ~/VisionWorks-1.4-samples, type make to build the sample programs, and when the build finishes, go to the bin folder and run the samples.

You should now also be able to connect to your Jetson from a remote computer using ssh. You can get the Jetson’s IP address from the serial interface console using the command ifconfig or you can connect to it using its default hostname: tegra-ubuntu.

Remote Graphical Desktop (VNC)

For graphical remote access, consider setting up VNC. You can find instructions here.

VNC isn’t a secure protocol, but if your Jetson isn’t exposed to the internet, you can eliminate the need for the ssh tunnel and VNC directly to the machine. Just change the OPTIONS line in /etc/init.d/vncserver to remove -localhost.

Once VNC is installed, you can connect to the Jetson from a remote computer running VNC Viewer and use a graphical desktop. If you changed the OPTIONS line to remove -localhost, then you can login directly by VNC viewer connecting to host tegra-ubuntu:5901

If you left the OPTIONS line configured with -localhost, you’ll need to create an encrypted tunnel from your remote machine to the Jetson in order to access the VNC server:

• ssh -L 5901:localhost:5901 -N -f -l ubuntu tegra-ubuntu
• Then VNC to localhost:5901 and login with password ubuntu

Some other tweaks you can consider to the xfce4 desktop accessed in VNC:

• Fix the default terminal:
  Press Alt-F2 to launch a program
  Run xfce4-settings-manager
  Select Preferred Applications->Utilities->Terminal Emulator->Xfce Terminal
• Fix tab-completion in command windows:
  Press the Applications Menu button (top left)
  Select Settings->Window Manager->Keyboard->Switch window for same application-> <clear>

Java

If you want to do some Java programming, you can install Oracle Java 8.

• Go here and download the Linux ARM 32 Hard Float ABI version (you may need to sign in or create a free account with Oracle)
• Use sftp to transfer the downloaded file (e.g. jdk-8u261-linux-arm32-vfp-hflt.tar.gz) your Jetson
• Make the directory to hold Java and extract it there:
  • sudo mkdir /usr/lib/jvm
  • cd /usr/lib/jvm
  • sudo tar -xzvf ~/jdk-8u261-linux-arm32-vfp-hflt.tar
• Edit the file /etc/environment to add java to the search path and create the required Java environment variables. When you’re done the file should look like this:
  PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/lib/jvm/jdk1.8.0_261/bin:/usr/lib/jvm/jdk1.8.0_261/db/bin:/usr/lib/jvm/jdk1.8.0_261/jre/bin"
J2SDKDIR="/usr/lib/jvm/jdk1.8.0_261"
J2REDIR="/usr/lib/jvm/jdk1.8.0_261/jre"
JAVA_HOME="/usr/lib/jvm/jdk1.8.0_261"
DERBY_HOME="/usr/lib/jvm/jdk1.8.0_261/db"
• Configure the newly installed Java as the default Java:
  • sudo update-alternatives --install "/usr/bin/java" "java" "/usr/lib/jvm/jdk1.8.0_261/bin/java" 0
  • sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/lib/jvm/jdk1.8.0_261/bin/javac" 0
  • sudo update-alternatives --set java /usr/lib/jvm/jdk1.8.0_261/bin/java
  • sudo update-alternatives --set javac /usr/lib/jvm/jdk1.8.0_261/bin/javac
• If you want to install JavaFX, see here.
• Reboot the system

More…

From what I’ve read, the fan is only needed when maxing out the CPU/GPU and in most cases, you can replace the fan with a heatsink.

You can upgrade to 16.04 but I recommend sticking with 14.04; many tools won’t work well with 16.04 and if you’re not careful, the upgrade process can lose the special GPU drivers requiring you to reflash the jetson from scratch. I recommend turning off checking for version upgrades: Applications Menu->Settings->Software & Updates-> Updates Tab->change Notify me of a new Ubuntu version to Never.

NVidia has an active developer forum where you can find answers to almost anything. eLinux is another great reference plus loads of links. For information on the GPIO header see here and also the Jetduino project. Another great site is JetsonHacks. Other useful links:

• Hardware specifications
• Enclosures:
  • 3D printable I used these #4-40 x 7/16″ screws and these switches.
  • laser cut (acrylic)
• eLinux
• Jetpack 3.1 (L4T 21.5 from July 2016)
• L4T 21.6 (last version supporting TK1 from October 2017)
• https://demotomohiro.github.io/hardware/jetson_tk1/index.html
• ZED stereo camera setup (good details on JetPack installation too)
• MOPED project using TK1 for vision processing
• Jetson award winning projects

I’ve been a fan of the STM32 micro-controllers for a long time and EmBitz by Gerard Zagema has been my preferred development environment. I am working on a project that needs a very low-cost microcontroller with fast PWM generation and the new STM32G0 family seems like a perfect fit with packages as small as SO8 and costs under $0.50 with a powerful 32-bit Cortex M0+ core and the same familiar peripheral set as their other uCs.

EmBitz is a light weight, lightning-fast IDE for C and C++ development; previously called Em::Blocks, it is a a fork of Code::Blocks that supports several micro-controller families including STM32 and integrates outstanding debug support. It is free,but I try to support such development and purchased a copy and recommend you do the same. The current version of EmBitz is 1.11; an impending 2.0 release has been announced but is not available yet.

EmBitz 1.11 doesn’t directly support the relatively new STM32G0 family, and many of the STM utilities don’t either (e.g. the latest STLinkUtility 4.5 doesn’t work with it). However, the EmBitz developer has already released an enhanced debugger that supports it and cleanly integrates with EmBitz 1.11. Here’s what I had to do to get STM32G0 development going under EmBitz:

• Download and install EmBitz 1.11 (note that the site may be down if you can’t find a copy, email me for a copy)
• Install EBlink
  • Download the zip file (press the green Code button and select Download Zip)
    (NOTE: do not download the windows installer, it isn’t passing my virus checker)
  • Follow these instructions to install it in EmBitz. The instructions aren’t crystal clear:
    • unzip the EBlink-master.zip folder
    • copy the EBlink win32 folder contents into ${EMBITZ}\1.11\share\EBlink
    • copy the EBlink scripts folder into ${EMBITZ}\1.11\share\EBlink
    • Download the EBlink interface (v2.0) and extract it to
      ${EMBITZ}\share\EmBitz\debuggers\Interfaces\
• Now, EBlink appears as a debug interface option under GDB Servers and you can use it to load software into your target and debug it in the IDE!
• To create an STM32G0 project, I created an STM32L0 project (since it is also Cortex M0+) and replaced the template files with files I gathered (and somewhat modified) from other STMicroelectronics sources:
  • includes: stm32g0xx.h, stm32g031xx.h, system_stm32g0xx.h
  • sources: startup_stm32g031xx.s, system_stm32g0xx.c
  • linker script: stm32g031_flash.ld
• In the project Build Options:
  • Under the Device tab, change the Policy to Use target settings
    • Device: cortex-m0plus
    • Linker script: ./stm32g031_flash.ld
    • Stack: 0x0100 (or whatever stack size you need)
  • Under the Compiler Settings #define tab, define STM32G031xx

Note that there is also a process for importing an STM32CubeMx project into EmBitz; see here.

I have a lot of my personal data (photos, music, etc.) stored on a RAID1 array (two drives that mirror each other so that if one drive dies the other has all of the data). Having my data on a RAID array gave me a lot of confidence that the data was secure…until it died last week. The RAID controller bit the dust, one of the two drives died, and the partition table of the other drive was corrupted. I couldn’t access the data using any windows utilities or fdisk, gdisk, gparted or ddrescue. I realized I hadn’t backed that storage up in more than a year.

It was starting to look grim, when I read about testdisk and gave it a try…and it worked like a champ. testdisk recognized the damaged partition and and gave me access to the NTFS file system. I was able to copy the data onto a good drive so all is good (and I’m going to be a lot better about backups). Thanks testdisk!

In my never ending quest for the perfect portable computing platform, I’ve come a step closer. There are loads of good ultrabooks, but most of them are *expensive*. I don’t want to carry/drop/lose a 1K+ device; my ideal portable is in the $300 range. Thus far, I’ve been using modified chromebooks, but some standard laptop/ultrabooks are finally getting into the right price range.

The Asus Vivobook F510UA-AH51 is replacing chromebooks running windows as my new carry laptop. It has an 8th-gen quad-core i5 processor, 15.6″ full-HD display, comes with 8GB DDR4 (supports up to 32GB), WiFi, USB 2,3,C, fingerprint reader, and HDMI. It weighs only 3.7lbs, is thin, has a very small charger, and looks decent.

The battery life is 6-7 hours which is a little less than I’d like, but the main compromise Asus made with this laptop was an old-fashioned, slow 1TB HDD that cripples its speed. Fortunately, you can add an M.2 SATA SSD and turn it into a speedy little laptop. I installed a Crucial MX500 M.2 SATA drive ($40 on amazon) which pleasantly came with Acronis True Image that allowed me to clone Windows from the 1TB HDD onto the M.2 SSD. The result is windows running on the SSD and the 1TB HDD available for bulk storage.

Installing the SSD requires opening the back of the machine (lots of screws including two hidden under two of the rubber feet); you’ll want a proper pry tool (or a guitar pick) to release the thin plastic clips that retain the back once the screws are removed. YouTube has many videos showing how to open the case; and since it’s a bit of a pain, I installed another 8GB of memory ($32 on amazon) while it was open.

The net result, while costing closer to $400 than my target $300 is a fast, light ultrabook with loads of storage and most modern features. A touchscreen and longer battery life would be nice, but not a big deal and overall, this is a great value and suitable for all student/business/development needs!

eBay isn’t the only place where bad companies and individuals hang out. Regardless of the market, a lot of them are in China. Here’s some information about how to check for Chinese scam companies.

I bought 100 ER34615 lithium batteries with custom pigtail connectors from Shenzhen Enbar on Alibaba. Within a year, all of them were dead whether they had been used or not. This type of battery has a 20+ year shelf life. Taking the generically marked shrink-wrap off the failed batteries, there were numerous spot-weld marks on the battery anode where a different tab had been mounted.

I understand that every company occasionally has a bad batch so I reached out to them to analyze the failures, but they had no interest in that and suggested that I just buy more batteries from them! Their “engineer”: Eric Lee insisted that their batteries must be used within 6 months or they will be destroyed by passivation (the normal process of building up a thin oxidation layer that is precisely what gives the batteries their long storage life). He sent me a datasheet with the specs for their batteries that includes “Long Storage Life”…and complained that I had embarrassed him by bringing up the failures! They are obviously not a legitimate or reputable company.

It turns out that a common scam in China is to take batteries that have been sent for recycling, put new shrink-wrap on them and resell them as new (at a discount of course). Buyer beware.

I won’t be buying from Shenzhen Enbar again.

The XL6009 is a nifty, inexpensive switching voltage regulator from XLSemi. (see datasheet). There is also the XL6019 (see datasheet). They are great parts and operate over a wide input voltage range at high efficiency and their internal switch can deliver substantial current. They can operate in boost and SEPIC/Buck-Boost configurations

HOWEVER you need to be cautious when using the ENable pin (2): the datasheet indicates that EN is a TTL compatible input and considers anything over 1v4 as High (Enable) – that’s good. It also mentions that if left unconnected, the pin floats high (enabled) – that’s also fine.

What wasn’t apparent to me, and certainly isn’t spelled out in the datasheet, is that when the EN pin floats high, it is at Vin and can source enough current to do damage. So if you are using the converter to boost say 12V to 24V, you’d better not connect that EN pin directly to a microprocessor GPIO because the processor pin will be at 12V and will be destroyed! (as I learned the hard way)

The solution of course is simple, just use the processor GPIO to drive a transistor in an open drain/open-collector arrangement to disable the converter. A common 2N2222 or 2N3904 should work just fine over the full input range of the XL6009. Live and learn.

As I’ve gotten older, small screens have increasingly become a problem. I love the real-estate of a full-HD (or bigger) screen, but when they’re smaller than 15.6″, the fonts are getting hard to read for these old eyes.

There aren’t many 15.6″ laptops that met my requirements (1080p, long battery life, 4GB or more, core i5 or better, light weight), especially when you want it to be inexpensive: I prefer not to carry something that costs more than around $200 because laptops get broken/stolen/lost/etc.

So I bought an Acer Chromebook 15 on eBay for $180 and so far, I like it a lot. I replaced the stock 32GB SSD with a KingSpec 256GB SSD (M.2 2242) bought on amazon for $34.15 and installed Windows 10 Pro 64-bit from SCDKey using coolstar.org replacement BIOS. It’s a bit over budget, but still pretty close to the $200 target and it is now a very serviceable Windows laptop with decent battery life, speed (core i5-5200), and a screen I can read. The battery is replaceable and widely available so when that run-time starts to decline, that’s fixable too.

It could be a little lighter and I would have liked more RAM, but it runs all of the software I use and is pretty snappy. Overall, Acer chromebooks continue to impress me!

I usually use Java when developing desktop software, but I recently had need to develop code that provided both a Windows GUI and also supported low-level interface with hardware connected to the PC. Java is great for developing GUIs and I still like the ancient Matisse GUI builder for Netbeans/Java Swing – I can knock out GUIs really fast with it…however, Java apps can be big and slow and interfacing Java with custom hardware is painful..so I looked into developing Windows native GUI apps in C to give really fast and small code that can interface easily to hardware…and have been pleasantly surprised.

Two things helped:

• The free, excellent Pelles C Compiler/IDE
• The (also excellent) WinAPI tutorial at Zetcode

The Pelles tool is slick, fast, and provides wizards for anything you’d want to build for a Windows target. The tutorial provides loads of compact runnable examples showing how to use each widget and feature of the WinAPI. There are other good WinAPI tutorials as well such as The Forger’s tutorial.

Next: find a GUI builder like Matisse for WinAPI. Pelles includes a resource editor but not a full GUI builder.

I buy a lot of gear on eBay and the overwhelming majority of sellers are excellent, but every now and then you meet the crooked ones.  This post is to help others avoid getting scammed by two bad sellers: flyxy2015 and 3c_topstore:

1) Seller flyxy2015 sold me a 10MHz OCXO distribution amplifier.  However, the OCXO I received was far off frequency and not within the correctable range.  The seller offered to ship a replacement for the internal Dapu OCXO; I took him up on this and of course what he really did was wait out the eBay return period without ever sending the replacement part.  Scam artists like fly-xy are part of why people are reluctant to use eBay.

2) Another seller (3c_topstore) sold me a scam graphics card.  The card had been altered to appear to be a more expensive card so it sort of worked, but it crashed whenever the driver tried to use the more advanced features or full memory of the card.  It was tricky to figure out what was wrong so by the time I understood the problem, the eBay return period had expired.  Fortunately, PayPal has a longer return period, but they require shipping the card back which would have cost 3c both the shipping and the original price in order for him to get his useless card back.  I thought I’d be a nice guy and offered instead just to split the loss with him…and sure enough, after I’d declined the PayPal return, he went silent and left me stuck with the card.

So in short, a popular eBay scam appears to be to sell you bad product that is either not obviously bad (so it takes you a while to discover it) or to otherwise stall until the return period expires.  eBay needs to do something about this because it is a growing problem that will ultimately hurt their reputation.  Until they figure it out, if you want to avoid crooks, stay away from eBay sellers flyxy and 3c_topstore.

Caveat emptor.

I’ve been looking for a relatively lightweight cross-platform embedded development environment for some time.  I target mainly STM32, ESP8266, and ESP32 platforms and use both Linux and Windows development machines.  For various reasons I’m not satisfied with the existing solutions:

• Arduino – too primitive
• EmBitz – very nice but no linux and no version control integration
• VisualStudio+VisualMicro – nice but no linux support
• Eclipse/NetBeans – too heavyweight and poor embedded integration

So I tried the Atom editor with the PlatformIO-IDE plugin on Windows workstations and on a low-end linux laptop and it works nicely!  I’ve since switched to the VSCode editor which I prefer over Atom.  The install, initial test build using the Arduino Core, and download/run worked well for an ESP8266 target.  I have since used it for Java projects as well.  VSCode is cross platform (Windows/Linux/Mac), and lightweight/fast.

I consider several features essential for an IDE:

• code completion
• source-level debugger integration with svn
• version control integration
• serial upload/monitor integration (especially for EspressIf platforms)

The community (free) version supports code completion, version control integration, and a rich set of plugins although it clearly prefers git; the subversion plugin doesn’t work very well (see below).  The debugger is not available in the free version and requires the Basic paid version ($10/mo).

The version control integration is spartan and on Windows relies on TortoiseSVN (which is good to install anyway).  Tortoise really needs PuTTY installed too if you use an svn+ssh server.  The right way to do it is to generate a signed certificate and install it on your servers so ssh access is seamless as described here or you can do it in cygwin:

• ssh-keygen -b 4096 -t rsa -N ”
  (creates private & public certs: id_rsa and id_rsa.pub in ~/.ssh)
• ssh-copy-id mylogin@foo.bar
  (install your public certificate on server foo.bar)

Once your certificate is installed (puts public cert into ~/.ssh/authorized_keys on your server), logins no longer require password authentication.  Note that if you use cygwin or linux you’ll need to convert your key to be PuTTY compatible…see here.

The serial monitor isn’t as friendly as I’d liked, but is actually quite effective using hotkeys.  See the bottom of this page.

A good video on installing for ESP8266 is here and another on installing external libraries here. Information on managing the Arduino Core is here.

A video on STM32 support is here.