#include <avr/io.h>
#include <avr/interrupt.h>
#include "delay_x.h"
#include "usb_serial.h"
#define VERSIONSTRING "MEEPROMMER $Revision: 1.2 $ $Date: 2013/05/05 11:01:54 $, CMD:R,r,w,W,V"
#define DATA1_PORT PORTD
#define DATA1_PIN PIND
#define DATA1_DDR DDRD
#define ADDR1_PORT PORTF
#define ADDR1_PIN PINF
#define ADDR1_DDR DDRF
#define ADDR2_PORT PORTC
#define ADDR2_PIN PINC
#define ADDR2_DDR DDRC
#define CONT_PORT PORTE
#define CONT_DDR DDRE
#define CONT_PIN PINE
#define CONT_CE 8
#define CONT_OE 9 // Output Enable
//a buffer for bytes to burn
#define BUFFERSIZE 1024
byte buffer[BUFFERSIZE];
//command buffer for parsing commands
#define COMMANDSIZE 32
char cmdbuf[COMMANDSIZE];
uint32_t startAddress,endAddress;
uint32_t lineLength,dataLength;
//define COMMANDS
#define NOCOMMAND 0
#define VERSION 1
#define SET_ADDRESS 2
#define READ_HEX 100
#define READ_BIN 110
#define READ_ITL 120
#define WRITE_HEX 200
#define WRITE_BIN 210
#define WRITE_ITL 220
const PROGMEM unsigned char rawData[32767] = {
*insert large amounts of hex code here*
};
/*****************************************************************
*
* CONTROL and DATA functions
*
****************************************************************/
// switch IO lines of databus to INPUT state
void data_bus_input() {
pinMode(DATA1_DDR, INPUT);
}
//switch IO lines of databus to OUTPUT state
void data_bus_output() {
pinMode(DATA1_DDR, OUTPUT);
}
//set databus to input and read a complete byte from the bus
//be sure to set data_bus to input before
byte read_data_bus()
{
return(DATA1_PIN);
}
//write a byte to the data bus
//be sure to set data_bus to output before
void write_data_bus(byte data)
{
DATA1_PORT = data;
}
//shift out the given address to the 74hc595 registers
void set_address_bus(uint16_t address)
{
//get high - byte of 16 bit address
byte hi = address >> 8;
//get low - byte of 16 bit address
byte low = address & 0xff;
ADDR2_PORT = hi;
//shift out lowbyte
ADDR1_PORT = low;
}
//short function to set the OE(output enable line of the eeprom)
// attention, this line is LOW - active
void set_oe (byte state)
{
digitalWrite(CONT_OE, state);
}
//short function to set the CE(chip enable line of the eeprom)
// attention, this line is LOW - active
void set_ce (byte state)
{
digitalWrite(CONT_CE, state);
}
//short function to set the WE(write enable line of the eeprom)
// attention, this line is LOW - active
//highlevel function to read a byte from a given address
byte read_byte(unsigned int address)
{
byte data = 0;
//set databus for reading
data_bus_input();
//first disbale output
set_oe(HIGH);
//enable chip select
set_ce(LOW);
//disable write
//set address bus
set_address_bus(address);
//enable output
set_oe(LOW);
data = read_data_bus();
//disable output
set_oe(HIGH);
return data;
}
//highlevel function to write a byte to a given address
//this function uses /DATA polling to get the end of the
//write cycle. This is much faster then waiting 10ms
void fast_write(uint32_t address, byte data)
{
//set address bus
set_address_bus(address);
//set databus to output
data_bus_output();
//set data bus
write_data_bus(data);
//enable chip select
set_ce(LOW);
_delay_us(20);
set_ce(HIGH);
}
/************************************************
*
* COMMAND and PARSING functions
*
*************************************************/
//waits for a string submitted via serial connection
//returns only if linebreak is sent or the buffer is filled
void readCommand() {
//first clear command buffer
for(int i=0; i< COMMANDSIZE;i++) cmdbuf[i] = 0;
//initialize variables
char c = ' ';
int idx = 0;
//now read serial data until linebreak or buffer is full
do {
if(Serial.available()) {
c = Serial.read();
cmdbuf[idx++] = c;
}
}
while (c != '\n' && idx < (COMMANDSIZE)); //save the last '\0' for string end
//change last newline to '\0' termination
cmdbuf[idx - 1] = 0;
}
//parse the given command by separating command character and parameters
//at the moment only 5 commands are supported
byte parseCommand() {
//set ',' to '\0' terminator (command string has a fixed strucure)
//first string is the command character
cmdbuf[1] = 0;
//second string is startaddress (4 bytes)
cmdbuf[6] = 0;
//third string is endaddress (4 bytes)
cmdbuf[11] = 0;
//fourth string is length (2 bytes)
cmdbuf[14] = 0;
startAddress=hexWord((cmdbuf+2));
dataLength=hexWord((cmdbuf+7));
lineLength=hexByte(cmdbuf+12);
byte retval = 0;
switch(cmdbuf[0]) {
case 'A':
retval = SET_ADDRESS;
break;
case 'R':
retval = READ_HEX;
break;
case 'r':
retval = READ_BIN;
break;
case 'W':
retval = WRITE_HEX;
break;
case 'w':
retval = WRITE_BIN;
break;
case 'V':
retval = VERSION;
break;
default:
retval = NOCOMMAND;
break;
}
return retval;
}
/************************************************************
* convert a single hex digit (0-9,a-f) to byte
* @param char c single character (digit)
* @return byte represented by the digit
************************************************************/
byte hexDigit(char c)
{
if (c >= '0' && c <= '9') {
return c - '0';
}
else if (c >= 'a' && c <= 'f') {
return c - 'a' + 10;
}
else if (c >= 'A' && c <= 'F') {
return c - 'A' + 10;
}
else {
return 0; // getting here is bad: it means the character was invalid
}
}
/************************************************************
* convert a hex byte (00 - ff) to byte
* @param c-string with the hex value of the byte
* @return byte represented by the digits
************************************************************/
byte hexByte(char* a)
{
return ((hexDigit(a[0])*16) + hexDigit(a[1]));
}
/************************************************************
* convert a hex word (0000 - ffff) to unsigned int
* @param c-string with the hex value of the word
* @return unsigned int represented by the digits
************************************************************/
unsigned int hexWord(char* data) {
return ((hexDigit(data[0])*4096)+
(hexDigit(data[1])*256)+
(hexDigit(data[2])*16)+
(hexDigit(data[3])));
}
/************************************************
*
* INPUT / OUTPUT Functions
*
*************************************************/
/**
* read a data block from eeprom and write out a hex dump
* of the data to serial connection
* @param from start address to read fromm
* @param to last address to read from
* @param linelength how many hex values are written in one line
**/
void read_block(uint32_t from, uint32_t to, int linelength)
{
//count the number fo values that are already printed out on the
//current line
uint32_t outcount = 0;
//loop from "from address" to "to address" (included)
for (uint32_t address = from; address <= to; address++) {
if (outcount == 0) {
//print out the address at the beginning of the line
Serial.println();
Serial.print("0x");
printAddress(address);
Serial.print(" : ");
}
//print data, separated by a space
byte data = read_byte(address);
printByte(data);
Serial.print(" ");
outcount = (++outcount % linelength);
}
//print a newline after the last data line
Serial.println();
}
/**
* read a data block from eeprom and write out the binary data
* to the serial connection
* @param from start address to read fromm
* @param to last address to read from
**/
void read_binblock(unsigned int from, unsigned int to) {
for (unsigned int address = from; address <= to; address++) {
Serial.write(read_byte(address));
}
//print out an additional 0-byte as success return code
Serial.print('\0');
}
/**
* write a data block to the eeprom
* @param address startaddress to write on eeprom
* @param buffer data buffer to get the data from
* @param len number of bytes to be written
**/
void write_block(unsigned int address, byte* buffer, int len) {
for (uint8_t i = 0; i < len; i++) {
fast_write(address+i,buffer[i]);
}
}
/**
* print out a 16 bit word as 4 character hex value
**/
void printAddress(unsigned int address) {
if(address < 0x0010) Serial.print("0");
if(address < 0x0100) Serial.print("0");
if(address < 0x1000) Serial.print("0");
Serial.print(address, HEX);
}
/**
* print out a byte as 2 character hex value
**/
void printByte(byte data) {
if(data < 0x10) Serial.print("0");
Serial.print(data, HEX);
}
/************************************************
*
* MAIN
*
*************************************************/
void setup() {
//define the EEPROM Pins as output
// take care that they are HIGH
digitalWrite(CONT_OE, HIGH);
pinMode(CONT_OE, OUTPUT);
digitalWrite(CONT_CE, HIGH);
pinMode(CONT_CE, OUTPUT);
//set speed of serial connection
//Serial.begin(57600);
Serial.begin(115200);
}
/**
* main loop, that runs invinite times, parsing a given command and
* executing the given read or write requestes.
**/
void loop() {
int b = 32769;
int r = 0;
byte final = 0xE1;
readCommand();
byte cmd = parseCommand();
uint32_t bytes = 0;
switch(cmd) {
case SET_ADDRESS:
// Set the address bus to an arbitrary value.
// Useful for debugging shift-register wiring, byte-order.
// e.g. A,00FF
Serial.print("Setting address bus to 0x");
Serial.println(cmdbuf + 2);
set_address_bus(startAddress);
break;
case READ_HEX:
//set a default if needed to prevent infinite loop
if(lineLength==0) lineLength=16;
endAddress = startAddress + dataLength -1;
read_block(startAddress,endAddress,lineLength);
Serial.println('%');
break;
case READ_BIN:
endAddress = startAddress + dataLength -1;
read_binblock(startAddress,endAddress);
break;
case READ_ITL:
break;
case WRITE_BIN:
//take care for max buffer size
if(dataLength > 1024) dataLength = 1024;
endAddress = 32768 + dataLength -1;
while(bytes < dataLength) {
if(Serial.available()) buffer[bytes++] = Serial.read();
}
write_block(startAddress,buffer,dataLength);
Serial.println('%');
break;
case WRITE_HEX:
data_bus_output();
set_ce(HIGH);
while(b != 65536)
{
byte data;
data = pgm_read_word_near(rawData + r);
fast_write(b, data);
b++;
r++;
}
fast_write(65536, final);
Serial.println('\n');
Serial.println("Finished!");
break;
case WRITE_ITL:
break;
case VERSION:
while(r != 1)
{
byte data1;
data1 = 0xE1;
Serial.println(final, HEX);
++r;
}
break;
default:
break;
}
}
