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: https://github.com/hexagon5un/AVR-Programming

Their website littlehacks.org is offline but still available via archive.org: https://web.archive.org/web/20160307235812/http://littlehacks.org/

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

ISP vs ICSP

User:

ISP vs ICSP

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.

Comparison

  • 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.

Dependency Injection in MediaWiki

Today I read the documentation for how Dependency Injection is done in MediaWiki.

I had a few small nits to pick (such as their statement that services should be stateless) but… fair enough.

For myself I don’t usually use Dependency Injection and a Service Container, instead I prefer the Service Locator pattern which I find is simpler and more economical to use, especially in PHP where there is a single process per request.

Extreme late binding

There’s a famous quote from Alan Kay that you will see bandied about:

OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things.

I think I agree with him, but I often find myself wondering quite what he meant by “extreme late-binding”. I suspect he means that object instances can redefine stuff they inherited from their concrete class. If your OOP platform doesn’t support that, you can emulate it with data and API.