c't

c't-Projekte - Mailinglisten


[Voriger (Datum)] [Nächster (Datum)] [Voriger (Thread)] [Nächster (Thread)]
[Nach Datum][Nach Thread]

Re: [ct-bot] Kalibrierung der Distanzsensren mittels EEPROM-Tabelle und eeprom@pc

Absender: Achim Pankalla
Datum: Mo, 07.05.2007 18:24:03
In-reply-to: <463F3E0A.7020605@xxxxxx>
References: <BCF016D5ED5AC34FBB655D109519ABCF083EBE@xxxxxxxxxxxxxxxxxxxx> <45ED3B46.4030400@xxxxxx> <45EF385C.3080609@xxxxxx> <A2ED0A68-A8F1-438A-B1E3-18033ED489E3@xxxxxxxxxxxxxxx> <45F135B9.5030203@xxxxxx> <45F13A91.6090904@xxxxxxxx> <D053B7F5-6BDD-4052-B45F-28FCF0EF45F8@xxxxxxxxxxxxxxx> <45F2B74F.8090706@xxxxxx> <38A4BFD9-CA32-436A-9A1E-B4E6E0652A5D@xxxxxxxxxxxxxxx> <463E0782.1050406@xxxxxx> <0FBD95CF-DA3B-461B-B12B-9FDCD84984D2@xxxxxxxxxxxxxxx> <463F3E0A.7020605@xxxxxx>


hallo,
habe nun access aus den kode entfernt. bitte einfach die datei austauschen oder halt kopieren und einfügen.

gruss
   a. pankalla
/*
 * c't-Bot
 * 
 * This program is free software; you can redistribute it
 * and/or modify it under the terms of the GNU General
 * Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your
 * option) any later version. 
 * This program is distributed in the hope that it will be 
 * useful, but WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
 * PURPOSE. See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public 
 * License along with this program; if not, write to the Free 
 * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307, USA.
 * 
 */

/* @file 	eeprom-emu_pc.c  
 * @brief 	Low-Level Routinen fuer den Zugriff auf das emulierte EEPROM des Sim-c't-Bots
 * @author 	Achim Pankalla (achim.pankalla@xxxxxx)
 * @date 	21.03.07
*/

#include "ct-Bot.h"

#ifdef PC

#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

#include "log.h"

extern long _eeprom_start__;

#ifdef __AVR_ATmega644__
	#define EE_SIZE 2048
#else
	#define EE_SIZE 1024
#endif

#define EEPROM_FILENAME	".\\eeprom.bin" 	/*<! Name und Pfad der EEPROM Datei. Verzeichnis muss existieren. Backslash doppeln!*/

/*! 
 * Traegt die uebergebenen Daten in das simulierte EEPROM ein. Dieses simulierte EEPROM 
 * besteht aus einer Datei. Ist sie nicht vorhanden, so wird eine leereangelegt. Sie ist im 
 * Binaer Format und kann direkt mit zB. PonyProg in den realen Bot eingespielt werden.
 * Es koennen Bytes (uint8 size = 1) und Integer (uint16 size = 2) uebergeben werden.
 * @param address Adresse im EEPROM zwischen 0 und 1023.
 * @param data Daten die abgelegt werden sollen.
 * @param size Groesse der Daten in Byte.
 */  
static void store_parameter(uint16 address, uint16 data, uint8 size) {
	FILE  *fpw; 	//Dateizeiger
	uint16 i = 0; //Laufvariable
	uint8 dataline[2];	//Speicher fuer Datenausgabe

//LOG_DEBUG(("write-addr=0x%x/%d", address, data));
	if(address > (size == 1 ? EE_SIZE-1 : EE_SIZE-2)) //Adresse checken
		return;

	if(!(fpw = fopen(EEPROM_FILENAME, "r+b"))){ //Testen, ob Datei vorhanden ist.
		if(!(fpw = fopen(EEPROM_FILENAME, "w+b"))) //wenn nicht, dann erstellen
			return;
		for(i = 0; i < EE_SIZE; i++) //Leere EEPROM Datei erstellen
			fwrite("\377", 1, 1, fpw);
		fclose(fpw);
		if(!(fpw = fopen(EEPROM_FILENAME, "r+b")))
			return;
	}

	//Daten eintragen
	fseek(fpw, address, SEEK_SET); //Schreibzeiger setzen
	dataline[0] = data%256;
	dataline[1] = data/256;
	fwrite(dataline, 1, size, fpw);	//Daten schreiben);

	fclose(fpw);
	return;	
}

/*! 
 * Liest die gewuenschten Daten aus eine simulierten EEPROM. Dieses simulierte EEPROM 
 * besteht aus der Datei eeprom.bin. Ist die Datei nicht vorhanden, so wird eine leere angelegt.
 * @param address Adresse im EEPROM zwischen 0 und 1023.
 * @param size Groesse der Daten in Byte.
 * @return Aus dem EEPROM gelesener Wert.
 */  
static uint16 load_parameter(uint16 address, uint8 size) {
	FILE *fpr; 	//Dateizeiger
	uint16 i = 0; //Laufvariable
	uint8 dataline[2] = {0,0};	//String fuer Datenausgabe

	if(address > (size == 1 ? EE_SIZE-1 : EE_SIZE-2)) //Adresse checken
		return(0);

	if(!(fpr = fopen(EEPROM_FILENAME, "rb"))){ //Datei öffnen
		if(!(fpr = fopen(EEPROM_FILENAME, "wb+"))) //wenn nicht vorhanden, dann erstellen
			return(0);
		for(i = 0; i < EE_SIZE; i++) //Leere EEPROM Datei erstellen
			fwrite("\377", 1, 1, fpr);
		fclose(fpr);
		return((size == 1 ? 0xff : 0xffff));
	}

	//Daten eintragen
	fseek(fpr, address, SEEK_SET); //Lesezeiger setzen
	fread(dataline, 1, size, fpr);	//Daten lesen);
	fclose(fpr);
//LOG_DEBUG(("load-addr=0x%x/%d", address,(uint16)dataline[0] + (uint16)dataline[1]*256));
	return((uint16)dataline[0] + (uint16)dataline[1]*256);	
}

/*!
 * Liest ein Byte aus den simulierten EEPROM
 * @param address Adresse im EEPROM
 * @return Aus dem EEPROM gelesener Wert.
 */  
uint8 eeprom_read_byte(uint8 *adr) {
	return((uint8)load_parameter((uint16)((uint32)adr - (uint32)&_eeprom_start__), 1));
}

/*!
 * Liest ein Word aus den simulierten EEPROM
 * @param address Adresse im EEPROM
 * @return Aus dem EEPROM gelesener Wert.
 */  
uint16 eeprom_read_word(uint16 *adr) {
	return(load_parameter((uint16)((uint32)adr - (uint32)&_eeprom_start__), 2));
}

/*!
 * Schreibt ein Byte in das simulierte EEPROM
 * @param address Adresse im EEPROM
 * @param Zu schreibender Wert.
 */  
void eeprom_write_byte(uint8 *adr, uint8 value) {
	store_parameter((uint16)((uint32)adr - (uint32)&_eeprom_start__), (uint16)value, 1);
}

/*!
 * Schreibt ein Word in das simulierte EEPROM
 * @param address Adresse im EEPROM
 * @param Zu schreibender Wert.
 */  
void eeprom_write_word(uint16 *adr, uint16 value) {
	store_parameter((uint16)((uint32)adr - (uint32)&_eeprom_start__), value, 2);
}

/*!
 * Liest ein Speicherblock aus dem simulierte EEPROM
 * @param pointer_ram Adresse im Hauptspeicher
 * @param pointer_eeprom Adresse im EEPROM
 * @param Groeße des Block.
 */  
void eeprom_read_block (void *pointer_ram, const void *pointer_eeprom, size_t size) {
	uint32 i;
	uint8 *ram;
	
	ram = (uint8 *)pointer_ram;
	for(i=0; i< size; i++){
		ram[i]=(uint16)load_parameter((uint16)((uint32)pointer_eeprom - (uint32)&_eeprom_start__ + i), 1);
	}
}

/*!
 * Schreibt ein Speicherblock in das simulierte EEPROM
 * @param pointer_ram Adresse im Hauptspeicher
 * @param pointer_eeprom Adresse im EEPROM
 * @param Groeße des Block.
 */  
void eeprom_write_block (const void *pointer_ram, void *pointer_eeprom, size_t size) {
	uint32 i;
	uint8 *ram;
	
	ram = (uint8 *)pointer_ram;
	for(i=0; i< size; i++){
		store_parameter((uint16)((uint32)pointer_eeprom - (uint32)&_eeprom_start__ + i), (uint16)ram[i] ,1);
	}
}

#endif