Controlling Arduino Uno with Serial commands

@kline helped me with Phase 1 of my Crustacean Chirpy Chip Challenge project, which I have completed (sort of). I got the programming done but I didn’t do all the reading (yet).

Note to self: My Arduino Uno knockoff identifies itself as a “QinHeng Electronics USB Serial” USB device.

This is my code:

enum state { OFF, ON, FLASH };

enum state state = OFF;

int blink_pin = 13;

void setup() {
  pinMode( blink_pin, OUTPUT );
  Serial.begin( 9600 );

void loop() {
  if ( Serial.available() > 0 ) { read_command(); }
  switch ( state ) {
    case ON :
      digitalWrite( blink_pin, HIGH );
    case OFF :
      digitalWrite( blink_pin, LOW );
    case FLASH :
      int pin = digitalRead( blink_pin );
      digitalWrite( blink_pin, !pin );
      delay( 500 );
      digitalWrite( blink_pin, pin );
      delay( 500 );

void read_command() {
  String command = Serial.readString();
  Serial.print( "Command: " );
  Serial.println( command );
  if ( command == "on" ) {
    state = ON;
  else if ( command == "off" ) {
    state = OFF;
  else if ( command == "flash" ) {
    state = FLASH;
  else {
    Serial.println( "Unknown command." );

This is my setup:

The code which would actually implement the spec, as given:

void read_command() {
  char c =;
  switch ( c ) {
    case 'a' :
      state = ON;
    case 's' :
      state = OFF;

Embedded Systems with ARM Cortex-M Microcontrollers in Assembly Language and C

Today I learned about Embedded Systems with ARM Cortex-M Microcontrollers in Assembly Language and C (Fourth Edition) by Yifeng Zhu while watching Lecture 9: Interrupts on YouTube. The full list of associated lectures are here: Short Lectures.

The SCSI Bus and IDE Interface: Protocols, Applications and Programming (2nd Edition)

I have this wonderful old book The SCSI Bus and IDE Interface: Protocols, Applications and Programming (2nd Edition). It was published in 1997 but is still available for purchase through Amazon.

The book comes with a floppy disk (that’s right: a floppy disk!). I had to buy a USB floppy disk drive to read it. I have made the content from the disk available in a tarball, here: scsi.tgz.

If you just want to read the files, those are here:

New Book Teardown: Learning The Art of Electronics: A Hands-On Lab Course | In The Lab With Jay Jay

This post is part of my video blog: In The Lab With Jay Jay.

Support this channel on Patreon:

Silly Job Title: Master Planner

This video is part of the New Book Teardown feature of my video blog.

In this video I take a look at Learning the Art of Electronics: A Hands-On Lab Course by Thomas C. Hayes and Paul Horowitz published in 2016. The book has 1,140 pages and is a companion to The Art of Electronics 3rd Edition.

Some notes about things of interest we noticed in the book:

Make: AVR Programming

I am reading Make: AVR Programming: Learning to Write Software for Hardware and I found this excellent video: Programming AVR Microcontrollers in C – O’Reilly Webcast available from here: Beyond the Arduino: Programming AVR Microcontrollers in C.

The author’s github page is still operational:

Their website is offline but still available via

Also there’s this really cool collection of projects over here: Cornell University ECE 4760 Designing with Microcontrollers Final Projects.




ChatGPT 4:

When discussing programming and interfacing with microcontrollers, “ISP” and “ICSP” are two terms that often come up. Here’s a breakdown of what each means and how they compare:

ISP (In-System Programming)

  • Definition: ISP refers to the ability to program a microcontroller while it is placed within the actual system or circuit where it will operate. This method doesn’t require the microcontroller to be removed from its application circuit for programming. It’s a very convenient way to update firmware or make changes to the program running on the microcontroller without needing to disassemble the system.
  • Advantages: It enables easy updates and debugging since the microcontroller does not need to be removed. This can significantly speed up development cycles and make maintenance simpler.
  • Usage: Common in many microcontrollers, including AVR, ARM, and others. It typically requires a few specific pins to be accessible for the programming interface.

ICSP (In-Circuit Serial Programming)

  • Definition: ICSP is a form of ISP specifically using a serial interface to program the microcontrollers while they are installed in a circuit. It’s a subset of ISP with a focus on the serial communication aspect. This method is often associated with Microchip microcontrollers but is not exclusive to them.
  • Advantages: The serial nature of ICSP means it usually requires fewer pins and can sometimes support lower voltage programming, making it suitable for a wide range of devices and situations. It’s particularly useful for devices where space and pin count are at a premium.
  • Usage: Predominantly seen with Microchip’s PIC microcontrollers, though the concept applies broadly. Like ISP, it necessitates access to specific programming pins but often fewer than other methods.


  • Scope: ISP is a broader term encompassing any in-system programming technique, including serial, parallel, or any other method. ICSP is specifically about serial programming.
  • Interface and Protocol: ICSP typically involves specific protocols and hardware interfaces tailored for serial communication. In contrast, ISP can use various protocols and interfaces depending on the microcontroller and the system’s requirements.
  • Microcontroller Support: While many microcontroller families support ISP, ICSP is more commonly associated with certain brands or families, like Microchip’s PIC series.

In summary, ICSP is a specific form of ISP. The choice between ISP and ICSP often comes down to the specific requirements of the project, including the microcontroller being used, the available pins for programming, and the preferred programming method. Both aim to provide flexibility and ease of use for developers and engineers when programming microcontrollers within their final application environment.