Here’s a wall hanging for the reception area that let’s your customers play retro games while they wait. To give you some sense of scale, the buttons to the right (labeled Start/Jump but we would call them A and B) are arcade buttons larger than traditional arcade buttons. The screen itself is a Samsung widescreen computer monitor — we’d wager that it’s a 16″ model but we’re just guessing. It’s held in the wooden frame by a piece of angle bracket.

This is the product of a hack we looked at in June where an Arduino was used to control digitized retro LCD games. The same hardware is used, monitoring the buttons with the Arduino and using a Python script to translate them to keypresses on a computer. That means this isn’t a standalone, but needs a computer to run the game and feed the LCD monitor. Still, we love the look of it and hold out hope that this will someday migrate to FPGA control (they have not problem driving LCD screens) with selectable games.

We remember when retro-gaming required a lot of equipment and a serious time commitment to put together a gaming interface. [Scooter2084] proves that we’ve come a long way with this gaming controller built to complement Android hardware.

It’s not immediately obvious from the image above, but the controller itself looks just like Andy the Android. His head is tilted upward and acts as the tablet stand, while his torso hosts the controls. We don’t the arms and legs have a functional use but they are necessary to complete the look.

Traditionally arcade controls have used a hacked gamepad, or dedicated hardware like the MAME cabinets that use iPac control boards. But this rendition interfaces the joystick and four buttons using an Arduino. A Bluetooth shield lets you control the Android device wirelessly, and opens up the possibility to use this as a controller for laptop-based emulators and the like. Don’t miss the video after the break.

The Optigan and Orchestron were a pair of electronic organs built by Mattel in the 1970s which used swappable optical discs to store instrument information. The discs can still be found today, but the organs are extremely scarce, much to [Gan’s] dismay. After researching the organs for a bit, he decided he could probably build his own MIDI-compatible interface for the audio discs.

The discs have audio waveform data printed on them, which can be read using an LED on one side of the disc and an optical transistor on another. After successfully prototyping a reader that could interpret one of the disc’s audio tracks, he constructed a device to read all of the tracks simultaneously, just like the original organs.

His makeshift turntable was constructed on top of an old record player using acrylic discs and toy car wheels to keep things steady. Once the disc is placed on the turntable, he sets his reader in place, and via some custom circuitry, he is able to play the discs using his much more modern keyboard. It sounds pretty decent as you can see in the video below, though he does admit he would like to tweak a few things to make it sound even better.

[thanks Bryan]

[Iain] is getting to the point in his life where he finds himself waxing nostalgic about various different technologies from his youth. One item he has always been fond of is first generation 7 segment consumer LED displays, like those found in old calculators.

He was excited to find one of these displays at the bottom of a box full of electronics odds and ends he received from a friend. After identifying the display and tracking down a data sheet online, he decided that he wanted to build some sort of little gadget out of it.

His first inclination was to build a tiny text scrolling gadget from the display, and thus his “Personal Electronic Retro Telegram” (P.E.R.T) was born. With Arduino in hand, he prototyped the circuit on a breadboard, then sent away to have some PCBs built. Once he received the boards, alll of his prototyping components were swapped out with SMD versions, including a TQFP ATMega168 chip in place of the full-sized Arduino board.

The final result is a nice melding old and new technology which he decided to give to his girlfriend as a gift. Continue reading to see a quick video of the P.E.R.T in action.

In parts 1 and 2, I discussed the important parts of what is going on the PC side with lua. While not 110% detailed I hope it gave you an idea on how the data is processed so the Apple II computer could quickly digest it. Now its time to see what happens at the other end of the serial cable. I am using basic, but its not 100% off the rom Applesoft basic, that would be even slower, so I am using a compiler and a fast graphics driver. Both are from “The Beagle Compiler” which was produced by the ever awesome Beagle Bro’s software company, and though still under copyright, the publishers have given permission for use of their software (within reason I don’t think you will get very far selling it).

Beagle Compiler does not crunch down to machine code like others, so it has a bit of overhead, but I choose it because it has some interesting add-ons like fast hplot (quick drawing), input anything (by default basic will only accept alphanumeric input), and memory drivers for 128K or more machines, all I thought I might need. The final version does not need extra input because all data being sent to the computer is alphanumeric, but I did use fast hplot, which doubles the speed that the computer can draw individual pixels, and one of the memory managers.

On the disk there are 2 COM programs, which are compiled basic scripts, one is STARTUP the other is CLIENT.  STARTUP is the first program prodos run when you start a disk and it just does some basic startup tasks.

REM LOAD THE FAST GRAPHICS ROUTINE
11 PRINT CHR$(4)"BLOAD FAST.HPLOT"
REM YAP
12 HOME:VTAB 3
13 PRINT " Please type in IN#n (where n = the ssc"
14 PRINT " slot number, then hold control hit A, "
15 PRINT " and type in 7B (600 baud) at the SSC"
16 PRINT " or ? prompt." :PRINT ""
17 PRINT " (you may or may not need to press"
18 PRINT " return depending on model)":PRINT ""
19 PRINT " Then type the following to run ":PRINT ""
20 PRINT " -CLIENT"

As you can see it loads the FAST.HPLOT program, its a binary program so I BLOAD it (binary load), in order to do that we have to PRINT a (ctrl +D) to tell the interpreter that this is  a dos command, then the command we want.

Line 12 clears the Apples current text screen and puts the prompt at the top of the screen, VTAB 3 just bumps the cursor down 3 lines.

Then we have some instructions, this could / should be able to be done automatically, and I remember doing it as a kid with my apple IIe, but no matter what I tried on my current //c I could not get the darn serial port set up via script. I figured if I did ever get it to work, it would be so funky that no other Apple’s would automatically set the serial port, so you have to do it manually.

Next, and more importantly is the CLIENT program

REM STARTUP 0-6
REM ENTER HIGH RES PAGE ONE AND TURN OFF THE 4 LINE TEXT DISPLAY
REM PAGE 2, NORMALLY FULL SCREEN, IS OCCUPIED AND I DONT FEEL
REM LIKE MESSING WITH MOVING STUFF AROUND IN MEMORY
0 HGR:POKE -16302,0
REM LOAD SPLASH SCREEN BINARY INTO HIGH RES PAGE 1 MEMORY
2 PRINT CHR$(4)"BLOAD SPLASH.HGR,A$2000"
REM DELAY
4 FOR I = 0 TO 30000
6 NEXT

REM MAKE A PALETTE 10-12
10 DIM CL(5): CL(1) = 0:CL(2) = 5
12 CL(3) = 2:CL(4) = 1:CL(5) = 6

REM CLEAR HIGH RES GRAPHICS PAGE 1 100-105
100 HGR:POKE -16302,0:HCOLOR = 7
102 FOR Y = 0 TO 138 STEP 2
104 HPLOT 0,Y TO 140,Y
105 NEXT

REM TEMP AND ALERT TEXT GRAPHICS INPUT DECODING 110-125
110 FOR Y = 0 TO 137
112 TB = 140:INPUT TS$
114 FOR X = 1 TO LEN(TS$)
REM CHARACTER --> ASCII VALUE
116 TC$ = MID$(TS$,X,1):TA = ASC(TC$)
REM IF NEW CODE BLOCK
118 IF TC$ = "b" THEN TB = TB + 35
REM DRAW PIXEL
120 IF (TA < 65) AND (TA >= 49) THEN HPLOT((TA - 48) + TB), Y
122 IF (TA >= 65) AND (TA <= 90) THEN HPLOT((TA - 55) + TB),Y
124 NEXT X:NEXT Y

REM BOTTOM TEXT GRAPHICS INPUT DECODING 130-144
130 FOR Y = 139 TO 191
132 BB = 0:INPUT BS$
134 FOR X = 1 TO LEN(BS$)
REM CHARACTER --> ASCII VALUE
136 BC$ = MID$(BS$,X,1):BA = ASC(BC$)
REM IF NEW CODE BLOCK
138 IF BC$ = "b" THEN BB = BB + 35
REM DRAW PIXEL
140 IF (BA < 65) AND (BA >= 49) THEN HPLOT((BA - 48) + BB), Y
142 IF (BA >= 65) AND (BA <= 90) THEN HPLOT((BA - 55) + BB),Y
144 NEXT X:NEXT Y

REM RADAR GRAPHICS INPUT DECODING 150-166
150 FOR C = 1 TO 5:HCOLOR = CL(C)
152 FOR Y = 0 TO 138 STEP 2
154 RB = 0:INPUT RS$
156 FOR X = 1 TO LEN(RS$)
REM CHARACTER --> ASCII VALUE
158 RC$ = MID$(RS$,X,1):RA = ASC(RC$)
REM IF NEW CODE BLOCK
160 IF RC$ = "b" THEN RB = RB + 35
REM DRAW PIXEL
162 IF (RA < 65) AND (RA >= 49) THEN HPLOT((RA - 48) + RB), Y
164 IF (RA >= 65) AND (RA <= 90) THEN HPLOT((RA - 55) + RB),Y
166 NEXT X:NEXT Y:NEXT C

REM WAIT FOR UPDATE LOOP
200 INPUT UD$
210 IF UD$ = "update" THEN GOTO 100
220 GOTO 200

Which has much more meat to it. Starting at the top I have (HGR:POKE -16302,0).  The HGR command clears and sends the apple into High GRapichs mode 1. Mode 1 goes to memory page 1 (there are 2 total for 80 column text or High res graphics) and sets the display to 280×160 with 4 lines of text at the bottom. As already stated I dont want the four lines of text so I POKE location -16302,0 to turn that off.

Maybe someone out there is saying to themselves right now “why didnt he use HGR2?” HGR2 (mode 2) defaults to the second page and is full screen by default, but I didn’t want to use it because there is no dedicated video memory on the Apple II, and something was already using that memory space, so it seemed simpler to just use screen 1 and poke it to be full screen, rather than moving every darn thing around in memory just to free up HGR2.

Next I load the lovely splash screen with Hack A Day’s and Weather Underground’s logos. This image was made in the gimp, converted by an older junkier image converter script I made and dumped into an emulator running at 10X speed. Once the image is drawn on the emulator I BSAVEd it to disk, now in the client script I am just copying that data back into video memory producing the image. There is no time reference for basic so there is just an empty loop to delay the splash screen for a few seconds.

Oddly enough for a machine that has a grand total of 6 unique colors in high resolution graphics, I need to make a palette. The colors on an Apple II are not lined up with the way I want them, and I am not sending it in exact color order either. DIM is dimensioning an array, and the values that follow are the apple color values we want to use and in the order we want them, nice and neat for a loop.

The rest of the script just repeats itself depending on which image is next, first is the tempature and storm advisory graphic(s), its 2 files on the pc side but since they are the same width and going in the same block of the screen I lumped them together as a single image right before it goes to the serial port. Variables are similar to every other Microsoft based 8 bit basic in only the first two characters of a variable is its name, so while you could name everything in nice descriptive words, your going to run into clashes quick.

I loop though each line of the graphic, waiting for input from the serial port each time. each character in the line gets read with the MID function (its like substring) and I also grab each character’s ASCII value using the ASC function. If the character is a “b” then add 35 to the current block counter (TB, BB, or RB for temp, bottom, or radar block).

If the character’s ASCII value is less than 65 but at least 49 then its a number 1-9 so we can just take it at face value, plot the point and move on. If the character’s ASCII value is between 65 and 90 that means its an upper case letter (and here is a chart btw). I take the ascii value and subtract 55 from it, 65 – 55 = 10, A is the 10th character in my graphics key and ASCII value 65 and so on. Now I can plot the point.

Radar is exactly the same thing but its wrapped up in a 5 count loop to change the color after one color of the image has been drawn. Its Y counter also advances 2 steps, since we only have the even lines if I did not “STEP 2″ the image would be squashed, now it just has the odd lines replaced with black.

Final thoughts: I had a lot of fun writing kludgey bad code, and it does function though very slowly. I wish I knew more about Apple II programming, but all the years I have spent on the thing, its just now coming up as a hobby. Maybe one day soon Ill be laughing at this while coding furiously in C to make an awesome video game or demo, but its kind of low on my list. The Apple II is one of my favorite little computers and it will continue to remain on my desk for quite a while, if you have the means and like retro computers, the Apple II is plentiful and surprising.

Pitfalls and problems:

It took for-freakin-ever for me to settle on a graphics format, even worse I wrote and tested 5 of them. RLE, binary, high ascii, XPM decoding on the apple and finally base 36.

I probably spent 3 evenings trying to get the stupid serial port working via BASIC script, as you can see that never worked out.

Wasted 2 nights poking all sorts of mad stuff into the Apple trying to kick over its color killer circuit, just to find out it was my tv tuner application not switching from NTSC to RS170 when changing from graphics to text (with the color burst signal enabled during text mode you cant read ANYTHING)

My computer died! Yea at the start I disabled my bench pc cause my wifes machine popped its power supply, well my machine also got a little bit of it cause I was just sitting there writing (probably graphics code) and the computer shuts off. Long story short, at like 11pm on a work night I am switching out a motherboard, and my 2.8ghz dual core can go from room temperature to over 100C in less than 10 seconds!

I think the last big fiasco was for the video, other than the durn cat bumping the camera a couple times, I had spend a couple hours getting everything onto my “craptop” and set up in the living room. After doing some test shots, fiddling with lighting  its now like 10PM on a work night and I am ready to go … except I did not have the graphic for the splash screen on the Apple II disk. Lucky for me I could not find my USB drive (both were at work) and that afternoon I had just sold my WIFI card to a co worker as I had an internal one on the way. So yea I burned a 8k file onto a cd rom, hurried to patch the basic script, get it sent over and working correctly, and ended up cleaning the living room at like 2AM.

Oh well it was fun.

Part 2 and part 1 can be found here.

In part one of the Apple II weather display I quickly went over how data is fetched and phrased. Now its time to do something with it in part 2. In the order of functions I do the text parts first, and though its very similar to the process that the radar image goes through, its in monochrome and a bit simpler to explain. Before I go into how it works I should explain how I am dividing the Apple II’s screen.

The high resolution mode on an Apple II gives you 280×160 with 4 lines of text on the bottom, or 280×192 full screen. I will be using 280×192 full screen, because as useful as the text can be, it also would show the endless stream of gibberish while updating, and since the entire color video mode of the Apple II design is a NTSC hack, its not all that pretty on a standard TV while also displaying color graphics. I also divide the screen into “blocks” 35 pixels wide each, this came about due to my encoding system.

Without getting into high ASCII or special characters I decided to use a base 36 type numbering system, we only need 35 unique characters to represent any pixel on a line within a block. The value of 1 means the first pixel in a given block and so on to Z being pixel number 35 in a block, and up to 8 blocks for the entire screen. Block separators and other functions can be sent using lower case characters, making a nice n easy plain text system. For example, if the apple received bbb123Z it means skip to block 4 and place a pixel at 1,2,3, and 35 within that block (and if there is no pixels at all for that given line a n is sent).

Looking at text.lua …

-- Weather Underground to Apple //
-- 2011 Kevin Dady
--
-- Text to Graphics:
-- take text from web.data
-- make text images with image magick
-- phrase *.xpm files to apple //
-- send text images
-- end
text = {}
text.data = {}
text.data.input  = {}
text.data.packed = {{},{},{},{}}
text.data.apl2   = {{},{},{}}

text.createIMG = function()
if web.data[1] == nil then
web.data[1] = "No Advisories"
end
if web.data[3] == nil then
web.data[3] = web.data[7]
end
-- create the bottom text
cmd.imageMGK(" -background black -fill white -font req/VeraMoBd.ttf"..
" -dither none -map req/mono.xpm -size 279x53 -pointsize 11 -gravity West"..
" caption:'".. web.data[2].."\n"..web.data[6].."\n"..web.data[5].."\n"..web.data[3].. "'"..
" temp/textBTM.xpm")
-- create the text for advisories
cmd.imageMGK(" -background black -fill white -font req/VeraMoBd.ttf"..
" -dither none -map req/mono.xpm -size 139x64 -pointsize 11 -gravity Center"..
" caption:'".. web.data[1].."'"..
" temp/textALT.xpm")
-- create the text for temperature
cmd.imageMGK(" -background black -fill white -font req/VeraMoBd.ttf"..
" -dither none -map req/mono.xpm -size 139x74 -pointsize 36 -gravity Center"..
" caption:'".. web.data[4].."'"..
" temp/textTMP.xpm")
end

text.convertIMG = function()
local files  = {"textTMP.xpm","textALT.xpm","textBTM.xpm"}
local footer = {82,72,61}
local width  = {140,140,280}
-- read the files into a table one at a time
for img = 1, 3 do
local file = io.open("temp/".. files[img],"r")
table.insert(text.data.input, img, {})
for line in file:lines() do
table.insert(text.data.input[img], tostring(line))
end
file:close()
-- remove header
for y = 1, 7 do
table.remove(text.data.input[img], 1)
end
-- remove footer
table.remove(text.data.input[img], footer[img] - 7)
-- remove non pixel data
for y = 1, #text.data.input[img] do
text.data.input[img][y] = string.sub(text.data.input[img][y], 2, width[img])
end
end
end

text.sortIMG = function()
local newChar = ""
for img = 1, 3 do
-- need to convert the strings into tables
for y = 1, #text.data.input[img] do
table.insert(text.data.apl2[img], {})
-- for each column in the current row
for x = 1, #text.data.input[img][y] do
-- read the character at that Y,X point
newChar = string.sub(text.data.input[img][y], x,x)
if newChar == "." then
table.insert(text.data.apl2[img][y], x) -- pixel
end
end
end
end
end

text.packageIMG = function()
for img = 1, 2 do
for y = 1, #text.data.input[img] do
local one   = ""
local two   = ""
local three = ""
local four  = ""
for x = 1, #text.data.apl2[img][y] do
if text.data.apl2[img][y][x] <= 35 then
one = one .. string.sub(graphicsKey, text.data.apl2[img][y][x], text.data.apl2[img][y][x])
elseif text.data.apl2[img][y][x] <= 70 then
two = two .. string.sub(graphicsKey, text.data.apl2[img][y][x] - 35, text.data.apl2[img][y][x] - 35)
elseif text.data.apl2[img][y][x] <= 105 then
three = three .. string.sub(graphicsKey, text.data.apl2[img][y][x] - 70, text.data.apl2[img][y][x] - 70)
else
four = four .. string.sub(graphicsKey, text.data.apl2[img][y][x] - 105, text.data.apl2[img][y][x] - 105)
end
end
if one == "" and two == "" and three == "" and four == "" then
table.insert(text.data.packed[img], "n")
else table.insert(text.data.packed[img],one.."b"..two.."b"..three.."b"..four)
end
end
end
for y = 1, #text.data.input[3] do
local one   = ""
local two   = ""
local three = ""
local four  = ""
local five  = ""
local six   = ""
local seven = ""
local eight = ""
for x = 1, #text.data.apl2[3][y] do
if text.data.apl2[3][y][x] <= 35 then
one = one .. string.sub(graphicsKey, text.data.apl2[3][y][x], text.data.apl2[3][y][x])
elseif text.data.apl2[3][y][x] <= 70 then
two = two .. string.sub(graphicsKey, text.data.apl2[3][y][x] - 35, text.data.apl2[3][y][x] - 35)
elseif text.data.apl2[3][y][x] <= 105 then
three = three .. string.sub(graphicsKey, text.data.apl2[3][y][x] - 70, text.data.apl2[3][y][x] - 70)
elseif text.data.apl2[3][y][x] <= 140 then
four = four .. string.sub(graphicsKey, text.data.apl2[3][y][x] - 105, text.data.apl2[3][y][x] - 105)
elseif text.data.apl2[3][y][x] <=175 then
five = five .. string.sub(graphicsKey, text.data.apl2[3][y][x] - 140, text.data.apl2[3][y][x] -140)
elseif text.data.apl2[3][y][x] <= 210 then
six = six .. string.sub(graphicsKey, text.data.apl2[3][y][x] - 175, text.data.apl2[3][y][x] - 175)
elseif text.data.apl2[3][y][x] <= 245 then
seven = seven .. string.sub(graphicsKey, text.data.apl2[3][y][x] - 210, text.data.apl2[3][y][x] - 210)
else
eight = eight .. string.sub(graphicsKey, text.data.apl2[3][y][x] - 245, text.data.apl2[3][y][x] - 245)
end
end
if one == "" and two == "" and three == "" and four == "" and five == "" and six == "" and seven == "" and eight == "" then
table.insert(text.data.packed[3], "n")
else table.insert(text.data.packed[3],one.."b"..two.."b"..three.."b"..four.."b"..five.."b"..six.."b"..seven.."b"..eight)
end
end
end

text.sendIMG = function()
for img = 1, 3 do
for y = 1, #text.data.packed[img] do
cmd.sjinn(text.data.packed[img][y])
end
cmd.sleep(2)
end
end

I start off in text.createIMG() by checking a couple things, One if there is any advisories, and if not place a No Advisories tag, Second looking for “windchill”, there is not always a “windchill” and if not place “dew point” in its place so we don’t have any blank lines. once were good to go we send the script off to imagemagick to make 3 graphics that contain black and white text. one for the long text at the bottom, one for advisories, and one for temperature.

text.convertIMG() reads the XPM files generated by imagemagick and does some cleanup. It starts by chopping the header and footer off of the image file, and removes the line formatting from each line of the image.

text.sortIMG() takes the leftover string data and scans each character in each line, in this case a white pixel is represented by a “.” (period) and a black pixel (which we don’t care about) is represented by a ” ” (space). Each time a period is found its x position is added to the end of a table. By the end of the image we are left with a table that has a subtable for each line, and contains X values for each pixel in each line, for example:

data= {}

data[1] = {1,2,12,80}

data[2] = {140,143,144,150}

There are 3 images to process, and they are different sizes, though how tall they are does not really matter to my script, its the width we are concerned about. text.packageIMG() reads each image and divides them up into blocks, the temperature text and advisory text are both 140 pixels wide and consume 4,  35 pixel blocks, so each value in each line is read out of our tables above and have some basic math done on them. If a value is greater than 35 for example then its block 2, the value has 35 subtracted from it and that is our block value (36 – 35 = block 2 pixel 1) . The bottom text is the widest graphic, taking up the entire width of the screen, but its just the same thing just spread over 8 blocks. Once we have our blocks as encoded strings they are packed into a single string per line of the image with “b” separating each block.

radar.lua does pretty much the same thing, except instead of making graphics it dithers the radar image downloaded earlier.

-- Weather Underground to Apple //
-- 2011 Kevin Dady
--
-- Radar processing:
-- feed jpeg to image magick
-- phrase output.xpm to color tables
-- package for apple //
-- send radar

radar = {}

radar.data = {}
radar.data.input  = {}  -- raw file data table dump
radar.data.packed = {}  -- packed apple data
radar.data.apl2 = {{},{},{},{},{},{}} -- black, green, violet, orange, blue, white

radar.img = {}
radar.img.header = 11 -- xpm file header # of lines
radar.img.w = 141
radar.img.h = 141

radar.convertIMG = function()

cmd.imageMGK(" temp/radar.jpg -level 0%,70%,1 -dither none -map req/apple.xpm temp/output.xpm")
-- read the file into a table
local file = io.open("temp/output.xpm","r")
for line in file:lines() do
table.insert(radar.data.input, tostring(line))
end
file:close()

-- remove header
for i = 1, radar.img.header do -- hardcode
table.remove(radar.data.input, 1)
end

-- remove footer
table.remove(radar.data.input, radar.img.w)

-- remove non color data
for i = 1, #radar.data.input do
radar.data.input[i] = string.sub(radar.data.input[i], 2, radar.img.h)
end
-- only deal with odd rows, due to the even / odd, bit / line, funny way apple 2's display highres colors.
-- if we leave them all in the image there is a gret chance of 2 colors phasing into another,
-- since we are going to loose pixel resolution anyway, we can cut that down some by deleting every other line
-- giving 140x70 also making transfer size smaller.
local keep ={}
for i = 1, #radar.data.input do
if (i % 2) == 1 then table.insert(keep, radar.data.input[i]) end
end
radar.data.input = keep
end

-- " " = 0 Apple color black (1)
-- "X" = 1 Apple color green
-- "o" = 2 Apple color violet
-- "." = 5 Apple color orange
-- "O" = 6 Apple color blue
-- "+" = 7 Apple color white (2)

radar.sortIMG = function()
local newChar = ""
-- need to convert the strings into tables
for y = 1, #radar.data.input do
-- add a new "line" string to each color table
for color = 1, 6 do
table.insert(radar.data.apl2[color], {})
end
-- for each column in the current row
for x = 1, #radar.data.input[y] do
-- read the character at that Y,X point
newChar = string.sub(radar.data.input[y], x,x)
-- assign each character a individual table value
if newChar == " " then table.insert(radar.data.apl2[1][y], x) -- black
elseif newChar == "X" then table.insert(radar.data.apl2[4][y], x) -- GREEN
elseif newChar == "o" then table.insert(radar.data.apl2[3][y], x) -- violet
elseif newChar == "." then table.insert(radar.data.apl2[2][y], x) -- ORANGE
elseif newChar == "O" then table.insert(radar.data.apl2[5][y], x) -- blue
elseif newChar == "+" then table.insert(radar.data.apl2[6][y], x) -- white
end
end
end
end

radar.packageIMG = function()
for color = 1, 5 do    -- ignore white, white takes a long time to draw since it makes up most of the graphic
for y = 1, #radar.data.apl2[color] do
local one   = ""
local two   = ""
local three = ""
local four  = ""
for x = 1, #radar.data.apl2[color][y] do
if radar.data.apl2[color][y][x] <= 35 then
one = one .. string.sub(graphicsKey, radar.data.apl2[color][y][x], radar.data.apl2[color][y][x])
elseif radar.data.apl2[color][y][x] <= 70 then
two = two .. string.sub(graphicsKey, radar.data.apl2[color][y][x] - 35, radar.data.apl2[color][y][x] - 35)
elseif radar.data.apl2[color][y][x] <= 105 then
three = three .. string.sub(graphicsKey, radar.data.apl2[color][y][x] - 70, radar.data.apl2[color][y][x] - 70)
else
four = four .. string.sub(graphicsKey, radar.data.apl2[color][y][x] - 105, radar.data.apl2[color][y][x] - 105)
end
end

if one == "" and two == "" and three == "" and four == "" then
table.insert(radar.data.packed, "n")
else table.insert(radar.data.packed,one.."b"..two.."b"..three.."b"..four)
end
end
end
end

radar.send = function()
for line = 1, 350 do
cmd.sjinn(radar.data.packed[line])
end
end

Imagemagick is used to dither the radar image to 6 of the 8 “available” colors, the Apple II only has 6 unique colors in high resolution mode, and the other 2 are black 2 and white 2. This has to do with how the apple does color, I mentioned earlier that its a hack, which basically uses bit patterns and the phase of the color burst to generate different colors. The end effect is always interesting as you can never place a specific color on each and every location on each and every line.

In order to help cut down on artifacts between lines and to cut the data transfer in half I then only use the even lines of the image, which yea reduces my radar resolution from 140×140 to 140×70 but due to the above mentioned wonkyness of the Apple’s video system I would have lost most of that resolution anyway.

The output XPM file has its header, footer and line formatting removed and each color is split up into individual tables, from there the process is the same, reading each monochrome image, packing it into block defined lines and packed up for the Apple to consume. I ignore white and just draw that on the screen as it makes up most of the image, saving time, and the end data is 5 copies of the image line / block encoded, each acting as a mask for its unique color.

For the most part were done looking at the lua scripts, so join me for part 3 (the end) where we will explore the software the apple II uses.

Part 1 and Part 3 are also available.

Due to computer issues I had to rob some parts from my “electronics” computer, which wasn’t bad, since I was not working on anything at the time and I felt a software project itch. I also wanted to do something with my Apple //c, which resides on my computer desk, so this ghetto brute force “solution” to use the 25 year old computer as a weather display came about.

In a nutshell there is the Apple II, a serial cable, and a PC running linux mint 10 and a handful of command line utilities. My specific Apple is the fist revision of the //c which means its got a buggy rom and the serial port(s) can be troublesome, the best speed I was able to get was 600 baud with just basic, though every other model could probably go a little faster.

On the linux side, wget downloads html and the radar image from Weather Underground’s mobile site, which is not a perfect source, but its easy. A lua script phrases text and graphics into string patterns that the Apple II can handle as keyboard input, and its sent down a serial cable where it is drawn on screen in basic.

Yea its pretty darn slow … it typically takes about eight to twelve minutes to redraw the screen, which is not all that horrid (imo) considering what is going on, but anyone with a more serious take on this could find numerous ways to optimize it, I just wanted to see what it would look like.

Join us after the break for a short video and to read all the details about how this all works!

Stuff you need:

*nix PC with a serial port and something with the following software

GNU Wget

GNU core utilities

(both are  probably already installed )

Lua 5.1 (I used sudo apt-get install lua5.1)

ImageMagick (again sudo apt-get install imagemagick)

Lynx (I am just using it to strip html tags and didnt feel like using anything “proper”)

Sjinn, which is a nifty little command line program that lets you deal with the serial port without having to manually set it up and fuss with redirecting i/o in the terminal.

And my project folder.

On the Apple II side, you need a 128k IIe or newer, disk drive/controller, serial card, blank disk,  and high resolution graphics. For software you will need ADT Pro,  and the disk image I made. ADT Pro is the currently developed Apple Disk Transfer utility that allows you to copy disk images to and from the Apple II, and the disk image is contained in the zip file above.

Transfer the disk image to the Apple and reboot with that disk in the drive, once the screen is at the white box, you are free to run “lua a2weather.lua” on the PC. The lua script fetches data, pipes it to the Apple, and then goes to sleep for 45 min using the gnu sleep() command.

Since lua is doing all the lifting, I guess that’s a good place to start. Also, let’s get this out of the way in case you missed it, I am not a programmer, much like my writing, be prepared to see some massive sins!

First up is the main a2weather.lua script  (and I see wordpress is going to murder my formating)

-- Weather Underground to Apple //
-- 2011 Kevin Dady
--
-- main script:
-- read data off of the http://www.wunderground.com/ mobile site
-- phrase it
-- process text & graphics
-- send
-- sleep
-- loop
--
-- This software is provided 'as-is', without any express or implied
-- warranty.  In no event will the authors be held liable for any damages
-- arising from the use of this software.
--
-- Permission is granted to anyone to use this software for any purpose,
-- including commercial applications, and to alter it and redistribute it
-- freely, subject to the following restrictions:
--
-- 1. The origin of this software must not be misrepresented; you must not
--    claim that you wrote the original software. If you use this software
--    in a product, an acknowledgment in the product documentation would be
--    appreciated but is not required.
-- 2. Altered source versions must be plainly marked as such, and must not be
--    misrepresented as being the original software.
-- 3. This notice may not be removed or altered from any source distribution.
require("req/web")
require("req/text")
require("req/radar")
require("req/os_commands")

graphicsKey = "123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

cmd.serialPort = "/dev/ttyS0"
cmd.webURL = "http://m.wund.com/US/FL/Orlando.html"
--cmd.webURL = "http://m.wund.com/cgi-bin/findweather/getForecast?brand=mobile&query=West+Yellowstone%2C+MT"

while true do
 web.get()
 web.sortTXT()
 web.cleanTXT()

 text.createIMG()
 text.convertIMG()
 text.sortIMG()
 text.packageIMG()
 text.sendIMG()

 radar.convertIMG()
 radar.sortIMG()
 radar.packageIMG()
 radar.send()

 -- clean up data
 radar.data.input  = {}
 radar.data.packed = {}
 radar.data.apl2 = {{},{},{},{},{},{}}
 text.data.input  = {}
 text.data.packed = {{},{},{},{}}
 text.data.apl2   = {{},{},{}}

 cmd.sleep("45m")
 -- after sleep do tell the apple and do it again
 cmd.sjinn("update")
end

… pretty straight forward, some comments, zlib license, Ah, required files! These are just other lua scripts with functions and variables in them, though there is no reason all of those functions could not be in this script, I just find it easier to deal with.

web.lua downloads html and the radar image from weather underground, strips HTML tags via lynx, searches for keywords, and packs those keywords into a table (tables in lua are like arrays, but you can put pretty much anything you want in them, even functions)

text.lua takes the text data gathered in web.lua and passes it to ImageMagick to make simple text images, then phrases those images into data strings and transfers that data to the Apple.

radar.lua dithers the radar image with ImageMagick, phrases the that file, builds data strings, and  transfers that image data to the Apple.

os_commands.lua contains functions to run command line programs like wget, lynx, etc.

The graphics key needs to remain constant, I will go into how that works in a little while, but each character represents a numeric value within a 35 pixel column of the screen, there are 280 horizontal pixels in Apple // high res graphics. Its ripped from base36, missing the zero value and you dont add the numbers up, each is its own.

Theres also a string to define your serial port, and one to put the url for the area you want to see, go to Weather Underground’s mobile site search for wherever (I dont know how well it works outside North America)  and copy/paste the resulting page url.

Next is a infinite while loop and the various functions contained within the above required scripts. Then, a little blurb where I define a bunch of empty tables (thats just me being re-assured tables start fresh and I didn’t goof up).

Next is web.lua

-- Weather Underground to Apple //
-- 2011 Kevin Dady
--
-- Web Processing:
-- get text data
-- get radar image
-- phrase text for apple //

web = {}

web.data = {}
web.keywords =
{
"National Weather Service:",
"Updated","Windchill","Temperature","Humidity",
"Conditions","Dew Point","animated radar image"}

web.get = function()
-- download html from website
cmd.wget(cmd.webURL, "text.html")
-- look for the radar image url
local file = io.open("temp/text.html")
local image = ""
for line in file:lines() do
if string.find(line, "jpg") then
image = line
break
end
end
file:close()
-- remove the html tags from image url
local firstQuote = string.find(image, "\"") + 1
local secondQuote = string.find(image, "\"", firstQuote) - 1
image = string.sub(image, firstQuote, secondQuote)
-- download image
cmd.wget(image, "radar.jpg")
end

web.sortTXT = function()
local fileLines = {}
-- use lynx to strip html tags
cmd.lynx("temp/text.html")
-- dump the lynx output file into a table
local file = io.open("temp/text.txt")
for line in file:lines() do
table.insert(fileLines, line)
end
-- look for keywords and scrape data
for y = 1, #fileLines do
local sub = ""
-- storm advisory
if string.find(fileLines[y], web.keywords[1]) ~= nil and web.data[1] == nil then
sub = string.gsub(fileLines[y + 1], "%d", "!")
sub = string.gsub(sub, " , ", " ")
table.insert(web.data, 1, sub)
-- last updated date and time
elseif string.find(fileLines[y], web.keywords[2]) ~= nil then
table.insert(web.data, 2, fileLines[y])
-- windchill
elseif string.find(fileLines[y], web.keywords[3]) ~= nil then
sub = string.gsub(fileLines[y], web.keywords[3], "")
table.insert(web.data, 3, sub)
-- everything but forecast
else
for keyWord = 4, (#web.keywords - 1) do
if string.find(fileLines[y], web.keywords[keyWord]) ~= nil and web.data[keyWord] == nil then
sub = string.gsub(fileLines[y], web.keywords[keyWord], "")
table.insert(web.data, keyWord, sub)
end
end
end
end
end

web.cleanTXT = function()
for y = 1, #web.data do
if web.data[y] ~= nil then
-- remove extra spaces from start of each string
while (string.sub(web.data[y], 1, 1) == " ") do
web.data[y] = string.sub(web.data[y], 2, -1)
end
-- remove degrees character
web.data[y] = string.gsub(web.data[y], "°", "")
end
end
-- Add keywords back in (skipping nill values, and tempature)
for keyWord = 3, (#web.keywords - 1) do
if web.data[keyWord] ~= nil then
if keyWord ~= 4 then
web.data[keyWord] = web.keywords[keyWord] .. ": " ..web.data[keyWord]
end
end
end
-- remove / from Temperature
web.data[4] = string.gsub(web.data[4], " / ", " ")
end

Yea I know its a mess, WordPress is ignoring tabs and it is only 40 columns if I had to guess. At the top there is a function called web.get(), this function uses wget to download the html page from weather underground, it then opens that file and scans through it for a JPG image, as luck would have it, the only jpg on the entire page is the radar. Once it has the URL for the radar it strips the HTML tags and uses wget again to download just the radar image.

The next function is web.sortTXT(), this sends the downloaded HTML file to lynx where it strips out the tags and spits out a plain text file. The function then reads each line looking for keywords. Some keywords require special action … like if it finds a storm advisory, it then knows to skip to the next line, because that line just says “National Weather Service:” and change the link number inserted by lynx to a” !”.  At the end of the function there is a little loop that looks for the rest of the keywords and then removes the actual keyword, this is needed to remove unwanted spaces between the keyword and data.

The final function is web.cleanTXT(), this goes through all the lines of data we have and removes all the leading spaces. It then adds back keywords to the appropriate line, while it ignores nil values as they were not present (like advisories or windchill). It also ignores the Temperature keyword as I don’t need the word Temperature in the display. Lastly I remove the “/” in my temperature data as it makes the graphics format funny, and its just to separate F and C values in the original string.

So we now have the software installed and running, data and radar downloaded from weather underground, text data scrapped, sorted and cleaned and we are now ready to make some graphics!

Join me in part 2 where I explain how graphics are reduced, encoded and drawn on the Apple II computer.

There have been a fair share of portable video game console conversions over the years, but few tug at our retro-loving heart strings more than this one. Modretro forum member [Mario] constructed a fantastic looking portable Atari 2600 using a Flashback 2 Atari console clone.

He hacked apart the Flashback board to fit inside a small plastic case, then added a 3.5″ LCD screen, as well as some donated controller bits from other portable game systems. A pair of rechargeable batteries were added along with a small amplifier and speaker for sound.

While the Flashback comes with 40 games built in, he really wanted to add a cartridge port, so with the little bit of space he had left in the case, he did just that. When everything was finished, he sprayed on a few coats of retro orange paint and called it a day. Really the only thing that’s missing is some nice fake wood veneer and maybe some shag carpet.

Continue reading to see his portable creation in action.

Just one look at that banner image and you’ve got to be thinking “that’s old”! This 1970′s era home made calculator used a 4-function calculator IC that was quite advanced for its time. The only problem is that the chip couldn’t do anything other than calcuations, which left it up to the maker of this dinosaur to get the display and keypad working. Circuit boards were made by drawing on copper clad with resist marker. These controlled the VFD digits for the IC’s output and also fed it the user inputs.

[Thanks Brian]

This gem was published in Mechanix Illustrated magazine in may of 1954. AT that time, a remote control was the stuff of science fiction. This article shows the modern man how to modify his television to include a fancy button to stop all noise. This button, affectionately labelled the “SHADDAP” was marketed as a way to relieve the pain of long winded commercials. Basically, it cut the connection to the speaker, nothing super fancy. Is that an altoids tin as an enclosure?

[via BoingBoing]

In an act of retro revival, [Lee Hart] has created this “Membership Card“, an altoid tin sized tribute to the 1802 CMOS chip. Made popular in the late 70s in the RCA COSMAC ELF computer, the 1802 stole many a hackers heart. There’s tons of information available if you explore the site, from history to kit building experiences.

[via Retro Thing)

“Everyone needs a hobby,” they tell us. For the blogger mysteriously identified only as “R,” that hobby would be an almost fanatical nostalgia for the Commodore 64 computer.

At first we thought this was a fan community site, but apparently it’s all the work of a single person. [R] has tweaked, extended, repackaged and resurfaced this 1980’s icon in nearly every imaginable way. They tend to gloss over the technical aspects of these mods, but that’s okay – the C64 is such an exhaustively documented system now that the site dwells mainly on the aesthetics and meaning of these reborn devices.

The 64 has made an indelible impression on electronic music, and the machines are still sought after by collectors, composers and circuit-benders. [R] pays homage by housing these vintage systems in styles reminiscent of even vintage-er synthesizers. Any one of these would warrant a post here, yet there’s a whole collection to browse. Check it out!

[via Retro Thing]

After a lengthy process that had previously met with rejection, Manomio’s Commodore 64 emulator for the iPhone and iPod touch has finally been accepted by Apple. This marks the first time a multi-purpose emulation title has been approved by the App Store. The $4.99 C64 app comes bundled with five fully-licensed classic games, and additional titles can be purchased and downloaded directly within the application.

App Store policies prohibit software that could run downloadable code, which barred most emulation attempts in the past. A couple of Sega titles worked around this by nature of being single-purpose emulators. The condition by which the C64 title was finally approved was the removal of the BASIC programming language (though ironically it’s still shown in screen shots, even on the App Store). Since only sanctioned programs can be installed and run from within the application, no user-alterable code is present.

The C64 emulator is neat enough in itself, but the really encouraging news here is that a precedent has been set; the business model may open the floodgates for developers to bring more classic gaming titles to the iPhone platform. So download that SDK and get hacking!

[via TouchArcade]

Update: The iPhone Blog has a simple work-around for accessing BASIC!

Update 2: App pulled, no surprise. If you jumped on the opportunity while it was available, [George’s] comment might be of interest.

Defcon, the world’s largest hacker convention, is this coming weekend in Las Vegas. While the convention generally focuses on breaking new technology, digital archivist [Jason Scott] has an interesting surprise for attendees this year. With some help from VintageTech, he’ll be assembling a massive den of retro computing machinery. They’ll have fully functional systems like the PDP-11/70 for people to play with. It sure to be one of the more unique things to see at the con.