Why Are Memory Addresses Represented in Hexadecimal Format?

Why addressing location is located in hexadecimal.

It is not hexadecimal but binary. We use Hex to represent the address as it is easily convertible to/from binary and is more human readable.

The best way to describe this is if you look at memory First lets have a look at binary and it relation to hex

We normally convert a number to binary to as to operate on this in the form of switches Lets consider an ordinary house hold light switch It is either on or off

We can represent this by saying the switch is logic one for ON or logic 0 for OFF

So the switch has two states these states are ON or OFF
Hence we can deduce that the switch can be represented in base 2 notation as having
2^ 0 states that is 0 giving us OFF or 2^0= 1 giving us 1 ( It therefore has two states On or Off )

Since all electronics is mostly represented by two states we only count up to one that is we count 0 ,1 , 10 ,11 ,101, 110, 111 and so on

In decimal which is human readable format we count as such 1,2,3,4,5,6,7 and so on up to 10 then we count One one , or 11 , one two, or 12 and so on
We term this base 10

Now lets take this another stage further Lets now consider a row of switches 4 in total

Imagine a bank of 4 switches each switch on and off 4 lights each mapped to a single light that is

Switch zero = light Zero State = 0 = OFF
Switch One = light One State = 0 = OFF
Switch Two = light Two State = 0 = OFF
Switch Three = light Three State = 0 = OFF

Now in order to switch “lights Zero on” and “light Two on” leaving the rest off we would have to change the above as follows

Switch zero = light Zero State = 1 = ON
Switch One = light One State = 0 = OFF
Switch Two = light Two State = 1 = ON
Switch Three = light Three State = 0 = OFF


We could therefore also say each switch represents a bit light pattern comprising in the above example 4 bits or In computer jargon we can say this is a nibble

If you understand this then lets introduce another 4 switches attached to lights as above giving us a bank of 8 switches

Switch zero = light Zero State = 0 = OFF
Switch One = light One State = 0 = OFF
Switch Two = light Two State = 0 = OFF
Switch Three = light Three State = 0 = OFF
Switch Four = light Four State = 0 = OFF
Switch Five = light Five State = 0 = OFF
Switch Six = light Six State = 0 = OFF
Switch Seven = light Seven State = 0 = OFF

If you understood this much brilliant lets move on
Now lets switch (Light two On) , ( Light 3 On ) , (Light 5 On) , and Light Seven On and we going to leave the others off

Let’s see what this would look like

Example 1A

Switch zero = light Zero State = 0 = OFF
Switch One = light One State = 1 = ON
Switch Two = light Two State = 0 = OFF
Switch Three = light Three State = 1 = ON
Switch Four = light Four State = 0 = OFF
Switch Five = light Five State = 1 = ON
Switch Six = light Six State = 0 = OFF
Switch Seven = light Seven State = 1 = ON

As you can see our binary implementation of the switches looks like this

1010 1010 And we can also say we now have two nibbles of light information making up an 8 bit word We can also say the above is 8 bits wide

This could be a computer instruction telling the micro chip for example to switch a pattern of lights on or off

But for easier and quicker use in computing we don’t want to express two 8 bit words for example as binary, or in more understandable terms can you imagine what a 64 bit pattern would look like, we’d be writing down zeros and ones for ever

The computer Industry decided to use what we call base 16 so recall base 10 we count 0 to 9 then 10, 11, 12, 13, 14 and so on

Now we arrive at Base 16

We thus count 0 to 9 and then refer to anything above 9 and below 16 as letters

Hence we count like this

0 ,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F
A being 10 , F being 15 I’m sure you can work this out to here

After this we count 10,12,13,14,15,16,17,18,19,1A,1B ,1C,1D,1E,1F


Let’s go back to the 8 bit light pattern or as I said two nibbles or an 8 bit word All are correct

From the above Example 1A we can see this

Light 1 or bit 1 is set to 1
Light 3 or bit 3 is set to 1
Light 5 or bit 5 is set to 1
Light 7 or bit 7 is set to 1


Recall the rest were left off

Which gives us the pattern 1010 1010 from MSB (Most significant bit to Least Significant bit reading the binary pattern from right to left )

Now lets convert the above pattern to Base 15

We first break down the 8 bit word into two nibbles taking the lower nibble first

Example 1C

1010

This is our right hand nibble (The Least significant nibble of our 8 bit word)

Moving from leftt to right we have
2^3 = 8, 2^2= 4, 2^1 = 2, 2^1 =1
1 , 0 , 1 , 0

So
How many 2^ 0 = 1 have we ? Answer= 0
How many 2^1 = 2 have we ? Answer = 1
How many 2^2 = 4 have we ? Answer = 0
How many 2^3 = 8 have we ? Answer = 1

Hence we can say we have (1*8 = 8) + (1*2 = 2) = total = 10 hex for 10 is A

Recall 0,1,2,3,4,5,6,7,8,9,A

Now do the same with the right hand nibble
We land up with A again
Hence our 8 bit word represent in binary was 1010 1010 or Hex 0xAAh
We use the X notation to say that’s the number is represented in hex notation

So what’s this all got to do with addressing you ask

Well I said earlier that we have an 8 bit word consisting of two nibbles I also said we say the word is 8 bits wide

Picture if you will to boxes subdivided into 8 sections
Both directly below each other

We might see this

Word 1 = |1|0|1|0|1|0|1|0|
Word 2 = |0|1|0|1|0|1|0|1|

For the micro to fetch word 1 I need some way of telling the micro which word to get
We therefore use addressing Now recall I also said the 8 bit word can also be referred to as 8 bits wide

Moving from left to right imagine each compartment in these boxes has an address
Just like a block of flats

Bit 7 Word 1 has an address of 0x00h
Bit 6 Word 1 has an address of 0x01h
Bit 5 Word 1 has an address of 0x02h
Bit 4 Word 1 has an address of 0x03h
Bit 3 Word 1 has an address of 0x04h
Bit 2 Word 1 has an address of 0x05h
Bit 1 Word 1 has an address of 0x06h
Bit 0 Word 1 has an address of 0x07h

So what happens when get to Word 2 then How does the processor know how to get this word

If we we add one to 0x07h what do we wind up with ?
0x08h which is the start of word Two

So when the Cpu fetched an instruction which is a word it does so by addressing the memory in hex

It knows that how wide the memory is in other words the cpu knows how many bits are stored in one instruction our above very simple examplethis is 8 bits wide

So its says in layman’s terms

Get the instruction at 0x00h
Execute that Instruction
Turn the lights on as per the word

Its fetches that instruction adds one to the instruction counter once it fetches the last bit in word one and then knows where its position is in memory

It might say next

Get the instruction at 0x08h which is the next word or Word 2
Execute that instruction in otherwords turn those lights on instead switching the others off


This obviously depends on the program that tells the processor which words it should fetch

In a pic micro depending on the IC an instruction is typically 14 bits wide for all 8 bit micros

Hope this explains all of this to you and makes this far easier to understand

For more information please see the following
http://nptel.iitm.ac.in/courses/Webcourse-con...Kharagpur/Embedded%20systems/Pdf/Lesson-5.pdf

Mark

www.harrington.force9.co.uk

Consider the picture of a memory chip below


This shows an 256K * 8 memory chip it holds 256k of 8 bit words 0r more accuratley 256K *1byte

Note ***** !!

( I should mention at this point that that although I refer to this as word in this context that this is solely for understanding at basic level 8 bits represents a byte in more accurate terms I shouldn’t really refer to this as a word since a word is 16 bits in length and not 8 bits which is a char in C language

I’m not being over precise otherwise at this stage this becomes confusing So for the purposes of understanding this better I’m only referring to 8 bits as word since it more easily read and understood )

Also the picture indicates one bit length so please ignore this * 1 and refer to this as 256 *8 then it makes sence ( My mistake applogies slight error )


The output is a single data line which outputs the data on one single line

In the above example is shown you the address lines of which there are 7
These are (A0 to A7)

When we need to read a word from the Memory device The micro puts out a binary word on the address lines to access to word stored in memory this is done by some internal program also having its own address lines where the instruction code is stored

We call this ROM for now "Read Only memory" this is a portion of the CPU that contains our instruction code, also written in hex notation ,so that it knows how to read the external memory

First we select the chip this done via the CS Line or (Chip select line) The Memory chip is left in read mode so we place a logic zero on the Read write line (R/W) and a logic 1 on the Chip select line (CS)

We then program the CPU to output that address onto the address line and out is written our data which is stored at that address location ( Imagine this as a postman only in this case he fetches and reads the letters out loud from each address in the street We give him / her the fisrt address and off he goes and fetches those words Then we issue another address and he does the same

Lets see how this might look in simple English


[code]

// read the first word
Reset the program counter to 0x00 // counter now read Zero decimal
Place a logic 1 on the CS line
Place a Zero on the RW line
Place 0x00h on the address line // binary 0000 0000
Data should be 1010 1010

// read the third word in memory
Add 16 to the program counter // PC now = 0x10 ,16 in decimal

Place 0x10h on the address line to access Third word // binary on address line will be 1000 0000
Data should be 1111 0110

// read the second word
Subtract 8 from the program counter // PC now = 0x08 , or 8 in decimal

Place 0x08h on the address line // binary 0000 1000
Data should now be 01011001

End program
[/code]



In the above manor I have read three words in memory at different locations by using a program counter and placing an address on the address lines

Only instead of referring to address in binary I’ve used hex to retrieve that word

This now should clearly illustrate why we refer to addressing in Hex as opposed to binary

Hopefully you should now see why

This should make this far clearer than ever before

You see

If you had done any databases and were involved in retrieving data from tables This would make this far more easier so that when you got to this step you would have no problem with pointers or understanding hex addressing or the beginnings of Pic Micro , Atmel or any other CPU controller programming / Interfacing hence you would also understand Web architecture, Object models ,html streams , serial streams etc which is all data, fetch ,post etc

Then finally you would have realised that the rasberry pi and pic together with TCP IP becomes an embedded webserver


Decimal to hex to ascii


But there you go they decided this wasnt worth learning for some reason like the maths which they should have kept up every year

I’ve written nice little program for you this afternoon so that you can get instant decimal to binary to octal codes with what character they represent in ASCII The data is diplayed in a JFrame and is bound to JTable giving you a list from 0 to 127 decimal As far as Eeweb are concerned you could also add this to an applet class and laucnh this from the web site

But thats entirely up to you Use it if it helps you (More than welcome to do that ) All Welcome to use this

I think you will find this very useful It will help you immensely if you are writing software for pic micro 12f, 16f ranges , Atmel or other 8 bit embedded architecture



Its written In java so you will need to have Java installed on your machine latest download is available from http://www.oracle.com/technetwork/java/javase/downloads/index.html

This was compiled using the Java SE 7u25 latest release
If you need to recompile see code below

There are two classes One main Class and A JFrame class I’ve done this In java deliberately so that you can use this on Linux , Solaris, Windows It may even run on Mac but you will have to try it and see if not recompile it

To launch the file I only have to double click the jar file but im running windows and new JRE allows this but you might have to run this from the command line in which case you use the following syntax

java -jar "jar-file name in full"

[code lang="java"]
/*
* MD Harrington
* 20-July-2013
*/
package asciitable;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Image;
import java.awt.Toolkit;
import java.nio.charset.Charset;
import java.util.Formatter;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;

/**
*
* @author Mark
*/
public class Ascii extends JFrame {

private String [][] data ; // this holds the data that we bind to our table
private String [] columns =
{"Char","Decimal","Hex","Binary", "Octal"} ; // this holds our column data
private String CHAR ;
private JLabel m_Label ;
private String []Unrecognised =
{"NUL","SOH","STX","ETX","EOT","ENQ","ACK","BEL","BS","HT","LF","VT","FF",
"CR","SO","SI","DLE","DC1","DC2","DC3","DC4","NAK","SYN","ETB","CAN","EM" ,
"SUB","ESC","FS","GS","RS","US","SP"
};




public Ascii(String title)
{
super(title);// calls the super class constructor and sets the title

data = new String[128][5]; // create a string bi dimensional Array
// to hold 127 elements by 3
// fill the data array with information

popDataArray();

//showCharsUnicode(); // simply for debugging to find out how
// this works

initComponents() ;


}

private void popDataArray()
{
for(int i = 0 ; i < 33 ; i++)
{


data[i][0] = this.Unrecognised[i] ;
data[i][1] = String.format("d", i) ; // decimal notation
data[i][2] = "0x"+String.format("x", i) ;
data[i][3] = String.format
("%8s", Integer.toBinaryString(i)).replace(" ", "0") ;
data[i][4] = String.format("o",i) ;


}

// i will now be at 32

for (int i = 33 ; i < 128; i++)
{
if (i == 127)
{
data[i][0]= "DEL" ;
}else
{
data[i][0] = "" + (char)i ; // cast this direct to char
}

data[i][1] = String.format("d", i) ; // decimal notation
data[i][2] = "0x"+String.format("x", i) ;
data[i][3] = String.format
("%8s", Integer.toBinaryString(i)).replace(" ", "0") ;
data[i][4] = String.format("o",i) ;

}


}// end function statement


private void initComponents() {

JTable table = new JTable(data, columns);
JScrollPane scrollPane = new JScrollPane(table);
table.setFillsViewportHeight(true);

m_Label = new JLabel("Ascii Conversion Table");
m_Label.setFont(new Font("Arial",Font.TRUETYPE_FONT,20));

this.getContentPane().setLayout(new BorderLayout());

this.getContentPane().add(m_Label,BorderLayout.PAGE_START);
this.getContentPane().add(scrollPane,BorderLayout.CENTER);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(550, 195);
Image img =
Toolkit.getDefaultToolkit().
getImage(getClass().
getClassLoader().
getResource("image/icon.png")); // loads a new Icon image
this.setIconImage(img);
this.setResizable(false); // so that frame cannot be resized


centreFrame();




}

private void centreFrame()
{
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
this.setLocation(dim.width/2-this.getSize().width/2,
dim.height/2-this.getSize().height/2);
}


// This was for debugging the application
private void showCharsUnicode()
{
Charset ascii = Charset.forName("US-ASCII");
byte[] buffer = new byte[1];
char[] cbuf = new char[1];
for (int i = 0; i

There’s a couple of other files for you so that you can launch this from a webpage ( Those of you who want to display this in a webpage for later use

The jar file is signed by myself (self signed at present )
The webpage is contained in the zip file named launch.zip inside is an HTML.html

Unzip this file to your local hard drive to experiment with

This will launch the jnlp file You will have to accept untrusted for now but the code is attached in a zip file which is named AsciiFrame.zip so you can see all source code yourselves (Nothing hidden inside what so ever)

I’ve also added a class so that you can sue this either from a JFrame or in the form of an embedded JApplet

See attached

Mark

www.harrington.force9.co.uk