The Atmel AVR is a microcontroller IC (Integrated Chip) that features non-volatile computer memory, or in other words: flash memory. Being developed from EEPROM (Electrically Erasable Programmable Read-Only Memory) its flash memory has the ability to be erased and rewritten. Atmel’s AVR was designed and based off of Modified Harvard Computer Architecture, which features concepts from the combination of the Original Harvard Architecture and the Von Neumann Architecture. The basic computer has a CPU (Central Processing Unit) and memory from which the CPU accesses data. This data could be machine code instructions that tell the computer how to handle information or the data could simply be documents, pictures, music files, etc. Von Neumann Architecture employs a single memory system to store instructions and data. The CPU will need to access instructions or data one at a time, or in turn with one another. Original Harvard Architecture employs entirely separate memory systems to store instructions and data. This allows instructions and data to be loaded and/or saved simultaneously. Since Original Harvard Architecture allows for instruction and data memory to occupy different address spaces they have the advantage of speed but at the disadvantage of needing separate memory spaces, which in actuality costs more to make. Von Neumann Architecture has the advantage of using a single memory space that saves on the cost of manufacturing, but has the disadvantage of access speed. So in essence, when engineers took the best of both worlds Modified Harvard Architecture was born. The most beneficial modification uses a single memory space with a memory hierarchy to separate data and instructions in a technique that allows for fast access. Another feature of the Atmel’s AVR is the use of RISC (Reduced Instruction Set Computing). RISC is a CPU design strategy that uses simplified instruction code to allow for faster instruction execution. It’s like taking a short cut to accomplish a task. Another method of faster memory access from within the CPU is the implementation of processor registers. These are small amounts of storage available for the CPU to use as a space for calculation, manipulation, or other forms of operation. Now, instead of having just one processor register we can implement an array of them to form what’s called a register file. The array is designed with fast static RAMs (Random Access Memory) that dedicate multiple input/output pin ports so that data may be accessed more quickly. To top it all off, the language that is used to write the code for all this memory access and processing is C. C is one of the fundamental languages that acts as medium for the ease of writing code over Machine Code and the compactness of code space. Machine Code though, is more efficient in the amount of code space that it takes up. Yet the hassle of remembering all the memory addresses is solved through C’s libraries.
Through the use of Processing, robotic art can be drawn. One thing to consider though, is the amount of detail the robot can create. This “detail” is referred to as resolution, or the amount of pixels per area. A pixel is the single instance of one of the many instances that make up a picture. Consider this, try drawing a circle with 4 dots.
It looks more like a square doesn’t it? Now use 8 dots to draw the circle. Continue to double the amount of dots you use while pausing in between to acknowledge the circle’s improving shape.
The circle formed better with more dots as opposed to less at the same viewing distance. Try the same exercise again but this time look at the circle from twice the viewing distance as you did before. The circle should appear to look like a circle in half the amount of dots or less as it did before. This is the concept of pixels and resolution. If the robot is to draw a picture on the floor at a constant viewing distance, then the amount of resolution needs to be known in order to make the picture look as it was to be intended. After playing with some code in Processing, here is an example of robotic artwork:
The overall square is composed of 25 spares in a 5X5 matrix. These squares in turn, are made up of 9 smaller squares in a 3X3 matrix. If we continued to divide the smallest square into further smaller squares, then we would essentially be increasing the resolution. The current number of pixels is (9 smaller squares * 25 bigger squares) = 225 squares in overall square.
We can calculate the number of pixels the same way in some java examples. I took an example from one of Dr. Becker’s Robotic Jar files found at his website: http://learningwithrobots.com/
This example should “Pick up three thing objects from consecutive locations immediately in front of the robot. Move to the next location, put all three things down again, and then move one more time.”
Again, we can count the resolution from this example. From the current picture, it looks to be composed of a 10X7 matrix, consisting of 70 pixels of resolution.