---
title: Audio and Video on an ATMega88 Microcontroller
date: 2009-05-19 20:49:40
tags: microcontroller
---

# Audio and Video on an ATMega88 Microcontroller!

__At least 99% of my blog entries contain original content I created.__  However, I was so impressed by something I stumbled upon tonight that I absolutely cannot resist sharing it.  It's a project which aims to output audio and video simultaneously from a single microcontroller.  The [author's site](http://www.linusakesson.net/scene/craft/index.php) has all the details, but if you watch the video below you'll be amazed.  (Just get through the 30 second narration at the beginning)  Apparently the guy rendered video in horizontal lines from the software and outputted audio signals between horizontal lines!  Amazing!

![](https://www.youtube.com/embed/sNCqrylNY-0)

__On second thought,__ this was no big deal in the 80's, so why am I so impressed by it now?  The 8-bit microcontrollers this guy is programming is likely on par with the PCs of the 80's.  I guess that in the 70's this would have been amazing because it was cutting edge.  In the 80's this would have been boring because it was commonplace.  In the 2000's, this is amazing because no one in my generation is old enough to remember how amazing this was in the 70's and 80's!

__After researching some similar projects__ I realized I'm becoming fascinated with [chiptune](http://en.wikipedia.org/wiki/Chiptune) synthesizing code, hardware, and music.  It's basically a type of code to tell a synthesizer how to synthesize the music, rather than having it play pre-recorded music.  It's like a merge of a programming language and MIDI.  For non-technical people, it's like giving a microchip the sheet music for all the different instruments of an orchestra and having the microchip play everything from the sheet music, rather than giving it a CD to play.  Here's some video of a PC-based front-end to the audio creation process. Notice how each line represents a time, and how certain codes in certain channels represent notes (hence the MIDI aspect).  Numbers on the far right represent the location of the memory, and notice also how it goes back and forth, replaying certain areas when necessary (to safe space, hence the coding aspect).

![](https://www.youtube.com/embed/17FmzHk_v0g)

__I can't describe my emotional state right now. It's like I have an extreme nostalgia for an era I never even lived in.__  This chip level audio synthesis stuff sounds amazingly fun to me.  (I've already bookmarked [nolife-radio.com](http://nolife-radio.com/) and [8bitFM.com](http://www.8bitfm.com/)) I feel drawn toward it... but I'm scared to get sucked in. I wish I were a college student in the 80's studying electrical engineering. Here I am, having just gotten a master's in molecular biology and microbiology, and I feel like I wasted six years of my life in the process. I'm about to start dental school in August. Hopefully when I look back from the future I won't feel like I wasted another four years doing _that_.

__Either way, I have an endless supply__ of possible projects to do this summer (not even going into the small list of projects I'm trying/expected to complete in the cardioneurophysiology lab I work in).  I feel like I'm running out of time.  I start dental school in August, and I dread the date.  Not necessarily because I expect it to be difficult, but because I feel [however illogical, irrational, or ridiculous] that I'm actually doing something _significant_, working with my hands and working with my brain to do things that [almost] no one has done before, and doing things in a way that no one has ever thought of doing them.  I feel like when I start resume classes, it's another four years of people telling me how I should do things so I can be exactly like everyone else.  How can you exercise creativity as a dental student? I'm sure there are ways, but it's certainly leagues away from the projects engineering college students work on. As far as the career goes, if you're an engineer the best case scenario is that you do something no one has ever done before.  If you're a dentist, the best case scenario is to do things exactly as everyone else does them.  Maybe I'll go crazy and change the wallpaper in my office every few months.

---
title: ATTiny2313 Controlling a HD44780 LCD with AVR-GCC
date: 2009-05-17 20:27:44
---

# ATTiny2313 Controlling a HD44780 LCD with AVR-GCC

__After a day of tinkering I finally figured out how to control a HD44780 display from an ATTiny2313 microcontroller.__ There are a _lot_ of websites out there claiming to show you how to do this on similar AVRs. I tried about 10 of them and, intriguingly, only one of them worked! I think the problem is that many of those websites show code for an ATMega8 and I'm using an ATTiny2313. Since it took me so long to get this right I decided to share it on the internet for anyone else having a similar struggle.

<div class="text-center img-border">

[![](attiny_2313_lcd_hd44780_thumb.jpg)](attiny_2313_lcd_hd44780.jpg)
[![](attiny_2313_lcd_hd44780_2_thumb.jpg)](attiny_2313_lcd_hd44780_2.jpg)

</div>

__You might recognize this LCD panel__ from some [PC parallel port / LCD interface projects](http://www.swharden.com/blog/old-stuff-of-interest/#lcd) I worked on about 5 years ago. It's a 20-column, 2-row, 8-bit parallel character LCD. This means that rather than telling each little square to light up to form individual letters, you can just output text to the microcontroller embedded in the display and it can draw the letters, move the cursor, or clear the screen. These are the connections I made were:

*   LCD1 -&gt; GND
*   LCD2 -&gt; +5V
*   LCD3 (contrast) -&gt; GND
*   LCD4 (RS) -&gt; AVR D0 (pin2)
*   LCD5 (R/W) -&gt; AVR D1 (pin3)
*   LCD6 (ES) -&gt; AVR D2 (pin6)
*   LCD 11-14 (data) -&gt; AVR B0-B3 (pins 12-15)

__The code to control this LCD from the ATTiny2313__ was found on Martin Thomas' page (dead link removed in 2019). I included the .h and .c files and successfully ran the following program on my AVR. I used the internal RC clock.

```c
// ATTiny2313 / HD44780 LCD INTERFACE
#include <stdlib.h>;
#include <avr/io.h>;
#include <util/delay.h>;
#include "lcd.h"
#include "lcd.c"

int main(void)
{
    int i=0;
    lcd_init(LCD_DISP_ON);
    lcd_clrscr();
    lcd_puts("ATTiny 2313 LCD Demo");
    lcd_puts("  www.SWHarden.com  ");
    _delay_ms(1000);
    lcd_clrscr();
    for (;;) {
        lcd_putc(i);
        i++;
        _delay_ms(50);
    }
}
```

```c
// modified the top of "lcd.h"
#define LCD_PORT         PORTB        /**&lt; port for the LCD lines   */
#define LCD_DATA0_PORT   LCD_PORT     /**&lt; port for 4bit data bit 0 */
#define LCD_DATA1_PORT   LCD_PORT     /**&lt; port for 4bit data bit 1 */
#define LCD_DATA2_PORT   LCD_PORT     /**&lt; port for 4bit data bit 2 */
#define LCD_DATA3_PORT   LCD_PORT     /**&lt; port for 4bit data bit 3 */
#define LCD_DATA0_PIN    0            /**&lt; pin for 4bit data bit 0  */
#define LCD_DATA1_PIN    1            /**&lt; pin for 4bit data bit 1  */
#define LCD_DATA2_PIN    2            /**&lt; pin for 4bit data bit 2  */
#define LCD_DATA3_PIN    3            /**&lt; pin for 4bit data bit 3  */
#define LCD_RS_PORT      PORTD     /**&lt; port for RS line         */
#define LCD_RS_PIN       0            /**&lt; pin  for RS line         */
#define LCD_RW_PORT      PORTD     /**&lt; port for RW line         */
#define LCD_RW_PIN       1            /**&lt; pin  for RW line         */
#define LCD_E_PORT       PORTD     /**&lt; port for Enable line     */
#define LCD_E_PIN        2            /**&lt; pin  for Enable line     */

// AND A LITTLE LOWER, I CHANGED THIS LINE TO 4-BIT MODE
#define LCD_FUNCTION_8BIT     0      /*   DB4: set 8BIT mode (0-&gt;4BIT mode) */
```

__Here is video of the output.__ Notice how this display can show English (lowercase/uppercase/numbers) as well as the Japanese character set!

![](https://www.youtube.com/embed/mMEwFSkr1Ko)

<blockquote>

**Note from Future Scott (ten years later, August, 2019):**

The link to the downloadable source code from Martin Thomas' page is no longer functional. These links do work:

* https://senzor.robotika.sk/sensorwiki/index.php/AVR_lcd.c 

* https://senzor.robotika.sk/sensorwiki/index.php/AVR_lcd.h 

A more recent project which uses these displays is:

* https://www.swharden.com/wp/2017-04-29-precision-pressure-meter-project/ 

</blockquote>

---
title: Removing Textile Markup From Wordpress Entries
date: 2009-05-15 17:56:32
tags: old
---

# Removing Textile Markup From Wordpress Entries

__I realized that the C code from yesterday wasn't showing-up properly__ because of [textile](http://wordpress.org/tags/textile), a rapid, inline, tag-based formatting system.  While it's fun and convenient to use, it's not always practical.  The problem I was having was that in C code, variable names (such as _delay_) were becoming irrevocably italicized, and nothing I did could prevent textile from ignoring code while styling text.  The kicker is that I couldn't disable it easily, because I've been writing in this style for __over four years!__  I decided that the time was now to put my mad Python skills to the test and write code to handle the conversion from textile-format to raw HTML.
__I accomplished this feat__ in a number of steps.  Yeah, I could have done hours of research to find a "faster way", but it simply wouldn't have been as creative.  In a nutshell, I backed-up the SQL database using [PHPMyAdmin](http://en.wikipedia.org/wiki/PhpMyAdmin) to a single "x.sql" file.  I then wrote a pythons script to parse this [massive] file and output "o.sql", the same data but with all of the textile tags I commonly used replaced by their HTML equivalent.  It's not 100% perfect, but it's 99.999% perfect.  I'll accept that.  The output?  You're viewing it!  Here's the code I used to do it:

```python
## This Python script removes *SOME* textile formatting from Wordpress
## backups in plain text SQL format (dumped from PHP MyAdmin). Specifically,
## it corrects bold and itallic fonts and corrects links. It should be easy
## to expand if you need to do something else with it.

infile = 'x.sql'

replacements=   ["r"," "],["n"," n "],["*:","* :"],["_:","_ :"],
                ["n","<br>n"],[">*","> *"],["*< ","* <"],
                [">_","> _"],["_< ","_ <"],
                [" *"," <b>"],["* "," "],[" _"," <i>"],["_ ","</i> "]
                #These are the easy replacements

def fixLinks(line):
    ## replace ["links":URL] with [<a href="URL">links</a>]. ##
    words = line.split(" ")
    for i in range(len(words)):
        word = words[i]
        if '":' in word:
            upto=1
            while (word.count('"')<2):
                word = words[i-upto]+" "+word
                upto+=1
            word_orig = word
            extra=""
            word = word.split('":')
            word[0]=word[0][1:]
            for char in ".),'":
                if word[1][-1]==char: extra=char
            if len(extra)>0: word[1]=word[1][:-1]
            word_new='<a href="%s">%s</a>'%(word[1],word[0])+extra
            line=line.replace(word_orig,word_new)
    return line

def stripTextile(orig):
    ## Handle the replacements and link fixing for each line. ##
    if not orig.count("', '") == 13: return orig #non-normal post
    line=orig
    temp = line.split
    line = line.split("', '",5)[2]
    if len(line)<10:return orig #non-normal post
    origline = line
    line = " "+line
    for replacement in replacements:
        line = line.replace(replacement[0],replacement[1])
    line=fixLinks(line)
    line = orig.replace(origline,line)
    return line

f=open(infile)
raw=f.readlines()
f.close
posts=0
for raw_i in range(len(raw)):
    if raw[raw_i][:11]=="INSERT INTO":
        if "wp_posts" in raw[raw_i]: #if it's a post, handle it!
            posts+=1
            print "on post",posts
            raw[raw_i]=stripTextile(raw[raw_i])

print "WRITING..."
out = ""
for line in raw:
    out+=line
f=open('o.sql','w')
f.write(out)
f.close()

```

__I certainly held my breath while the thing ran.__  As I previously mentioned, this thing modified SQL tables.  Therefore, when I uploaded the "corrected" versions, I kept breaking the site until  I got all the bugs worked out.  Here's an image from earlier today when my site was totally dead (0 blog posts)

<div class="text-center img-border">

[![](hostingwork_thumb.jpg)](hostingwork.jpg)

</div>

---
title: Simple Case AVR/PC Serial Communication via MAX232
date: 2009-05-14 11:00:19
tags: microcontroller, circuit, old
---

# Simple Case AVR/PC Serial Communication via MAX232

__I recently had the desire__ to be able to see data from an ATMEL AVR microcontroller (the [ATTiny2313](http://www.SWHarden.com/blog/images/attiny-2313.gif)) for development and debugging purposes.  I wanted an easy way to have my microcontroller talk to my PC (and vise versa) with a minimum number of parts.  The easiest way to do this was to utilize the [UART](http://en.wikipedia.org/wiki/UART) capabilities of the [ATTiny2313](http://www.SWHarden.com/blog/images/attiny-2313.gif) to talk to my PC through the serial port. One problem is that the [ATTiny2313](http://www.SWHarden.com/blog/images/attiny-2313.gif)(as with most microcontrollers) puts out 5V for "high" (on) and 0V for "low" (off).  The RS-232 standard (which PC serial ports use) required -15V for high and +15v for low!  Obviously the microcontroller needs some help to achieve this.  The easiest way was to use the [MAX232 serial level converter](http://en.wikipedia.org/wiki/MAX232) which [costs about 3 bucks at DigiKey](http://search.digikey.com/scripts/DkSearch/dksus.dll?Detail&name=MAX232CPE%2B-ND). Note that it requires a few 10uF capacitors to function properly.

<div class="text-center img-border">

[![](serialcircuit_thumb.jpg)](serialcircuit.png)

</div>

__Here's a more general schematic:__


<div class="text-center">

![](max232_serial_microcontroller.gif)

</div>

__I connected my ATTiny2313 to the MAX232__ in a very standard way. (photo)   MAX232 pins 13 and 14 go to the serial port, and the ATTiny2313 pins 2 and 3 go to the MAX232 pins 12 and 11 respectively.  I will note that they used a oscillator value (3.6864MHz) different than mine (9.216MHz).

__Determining the speed of serial communication__ is important.  This is dependent on your oscillator frequency!  I said I used a 9.216Mhz oscillator.  First, a crystal or ceramic oscillator is required over the internal RC oscillator because the internal RC oscillator is not accurate enough for serial communication.  The oscillator you select should be a perfect multiple of 1.8432MHz. Mine is 5x this value.  Many people use 2x this value (3.6864Mhz) and that's okay!  You just have to make sure your microchip knows (1) to use the external oscillator (google around for how to burn the fuses on your chip to do this) and (2) what the frequency of your oscillator is and how fast it should be sending data.  This is done by setting the UBRRL value.  The formula to do this is here:

<div class="text-center">

![](ubrrformula.gif)

</div>

__The datasheet of your microcontroller__ may list a lot of common crystal frequencies, bandwidths, and their appropriate UBRR values.  However my datasheet lacked an entry for a 9.216MHz crystal, so I had to do the math myself.  I Googled around and no "table" is available!  Why not make one? (picture, below).  Anyway, for my case I determined that if I set the UBRR value to 239, I could transmit data at 2800 baud (bits/second).  This is slow enough to ensure accuracy, but fast enough to quickly dump a large amount of text to a PC terminal.

<div class="text-center">

![](ubrr-table.gif)

</div>

## AVR Baud Calculator

This will make your life easier. The page <a href="http://www.wormfood.net/avrbaudcalc.php">wormfood.net/avrbaudcalc.php</a> has a chart of common crystals and the baud rates they work best with! Try to pick a combination that provides the least error possible...

__This is the bare-minimum code__ to test out my setup. Just load the code (written in C, compiled with avr-gcc) onto your chip and it's ready to go.  Be sure you set your fuses to use an external oscillator and that you set your UBRRL value correctly.

```c
#include <avr/io.h>  
#include <avr/interrupt.h>  
#include <util/delay.h>  

int main (void)  
{  
  unsigned char data=0;  
  UBRRL = 239;  
  UCSRB = (1 < < RXEN) | (1 << TXEN);  
  UCSRC = (1 < < UCSZ1) | (1 << UCSZ0);  

  for (;;)  
  {  
    if (data>'Z'||data< 'A')  
    {  
      UDR = 10; UDR = 13; data='A';_delay_ms(100);  
    }  
    
    UDR = data;  
    data += 1;  
    _delay_ms(100);  
  }  
}  
```

__Once you load it, it's ready to roll!__  It continuously dumps letters to the serial port.  To receive them, open HyperTerminal (on windows, under accessories) or minicom (on Linux, look it up!).  Set your baud rate to 2800 (or whatever you selected) and you're in business.  This (picture below) is the output of the microcontroller to HyperTerminal on my PC.  Forgive the image quality, I photographed the LCD screen instead of taking a screenshot.

<div class="text-center img-border">

[![](avr_serial_console_thumb.jpg)](avr_serial_console.jpg)

</div>

__This is the circuit__ which generates the output of the previous image.  I have a few extra components.  I have an LED which I used for debugging purposes, and also a switch (labeled "R").  The switch (when pressed) grounds pin 1 of the ATTiny2313 which resets it.  If I want to program the chip, I hold "R" down and the PC can program it with the inline programmer ["parallel port, straight-through, DAPA style](https://wikis.mit.edu/confluence/download/attachments/20512/dapa.png)).  One cable going into the circuit is for the parallel port programmer, one cable is for the serial port (data transfer), and one is for power (5v which I stole from a USB port).

<div class="text-center img-border">

[![](avr_max232_thumb.jpg)](avr_max232.jpg)

</div>

__I hope you found this__ information useful.  Feel free to [contact me](http://www.swharden.com/blog/send-scott-a-message/) with any questions you may have, but realize that I'm no expert, and I'm merely documenting my successes chronologically on this website.

---
title: PHP-Generated Apache-Style Access Logs
date: 2009-05-14 13:33:22
---

# PHP-Generated Apache-Style Access Logs

__A few months ago__ I wrote about a way [I use PHP to generate apache-style access.log files](2009-01-22-using-php-to-create-apache-style-accesslog/) since my web host blocks access to them.  Since then I've forgotten it was even running!  I now have some pretty cool-looking graphs generated by [Python](http://www.python.org) and [Matplotlib](http://matplotlib.sourceforge.net/).  For details (and the messy script) check the original posting.

[![](graph_time_thumb.jpg)](graph_time.png)

__This image represents__ the number of requests (php pages) made per hour since I implemented the script.  It might be a good idea to perform some [linear data smoothing techniques](http://www.swharden.com/blog/2008-11-17-linear-data-smoothing-in-python/) (which I love writing about), but for now I'll leave it as it is so it most accurately reflects the actual data.

This code has been updated:
[2009-08-04-generate-apache-style-http-access-logs-via-sql-and-php](2009-08-04-generate-apache-style-http-access-logs-via-sql-and-php)