//After running this, the sdBuf is ruined (tail pointer not on a sector boundary)
//so don't call flushSD or flushSDLast again
int flushSDLast() {
mark(&sdBuf);
int len=readylen(&sdBuf);
if(len==0) return 0;
len=len>SECTOR_LEN?SECTOR_LEN:len;
if(fat16_write_file(&ouf, &sdBuf.buf[sdBuf.tail], len) < 0) return -1;
sdBuf.tail=SECTOR_LEN-sdBuf.tail;
len=readylen(&sdBuf);
if(len>0) return fat16_write_file(&ouf, &sdBuf.buf[sdBuf.tail], len);
return 0;
}
/**
* \ingroup tcpcmdcommon
* \b Kamerabild auf SD-Karte speichern
*
* \b Syntax: bild<br>
*
* \author Fred Fröhlich
*/
int16_t Bild_speichern(char *outbuffer)
{
#if USE_MMC // nur sinnvoll mit SD-Karte
unsigned long apos;
uint16_t a;
char fname[13];
max_bytes = cam_picture_store(CAM_RESOLUTION); //Kamera läd neues Bild in Speicher
// positive Antwort mit Dateiname in outbuffer speichern
sprintf_P(fname,PSTR("%02i%02i%02i%02i.jpg"),TM_DD,TM_hh,TM_mm,TM_ss);
File *picfile = f16_open(fname,"a");
if (picfile) {
apos = 0;
do {
a = 0;
do {
cam_data_get(apos);
apos++;
a++;
if(a==512) break;
} while(apos < max_bytes);
fat16_write_file(picfile, (uint8_t *)&cam_dat_buffer[0], a);
} while(apos < max_bytes);
f16_close(picfile);
if (outbuffer) {
sprintf_P(outbuffer,PSTR("250 Datei: %s"),fname);
return strlen(outbuffer); // OK: 250 und Dateiname
}
else
return 0;
}
else
#endif
return cmd_550(outbuffer); // Fehler zurückgeben
}
//returns 0 on success, negative on failure
int flushSD() {
if(fat16_write_file(&ouf, &sdBuf.buf[sdBuf.tail], SECTOR_LEN) < 0) return -1;
sdBuf.tail=SECTOR_LEN-sdBuf.tail;
return 0;
}
int main()
{
/* setup uart */
uart_init();
/* setup stdio */
uart_connect_stdio();
/* setup sd card slot */
if(!sd_raw_init())
{
#if DEBUG
printf_P(PSTR("MMC/SD initialization failed\n"));
#endif
return 1;
}
/* open first partition */
struct partition_struct* partition = partition_open(sd_raw_read,
sd_raw_read_interval,
sd_raw_write,
0);
if(!partition)
{
/* If the partition did not open, assume the storage device
* is a "superfloppy", i.e. has no MBR.
*/
partition = partition_open(sd_raw_read,
sd_raw_read_interval,
sd_raw_write,
-1
);
if(!partition)
{
#if DEBUG
printf_P(PSTR("opening partition failed\n"));
#endif
return 1;
}
}
/* open file system */
struct fat16_fs_struct* fs = fat16_open(partition);
if(!fs)
{
#if DEBUG
printf_P(PSTR("opening filesystem failed\n"));
#endif
return 1;
}
/* open root directory */
struct fat16_dir_entry_struct directory;
fat16_get_dir_entry_of_path(fs, "/", &directory);
struct fat16_dir_struct* dd = fat16_open_dir(fs, &directory);
if(!dd)
{
#if DEBUG
printf_P(PSTR("opening root directory failed\n"));
#endif
return 1;
}
/* provide a simple shell */
char buffer[24];
while(1)
{
/* print prompt */
uart_putc('>');
uart_putc(' ');
/* read command */
char* command = buffer;
if(read_line(command, sizeof(buffer)) < 1)
continue;
/* execute command */
if(strncmp_P(command, PSTR("cd "), 3) == 0)
{
command += 3;
if(command[0] == '\0')
continue;
/* change directory */
struct fat16_dir_entry_struct subdir_entry;
if(find_file_in_dir(fs, dd, command, &subdir_entry))
{
struct fat16_dir_struct* dd_new = fat16_open_dir(fs, &subdir_entry);
if(dd_new)
{
fat16_close_dir(dd);
dd = dd_new;
continue;
}
}
printf_P(PSTR("directory not found: %s\n"), command);
}
else if(strcmp_P(command, PSTR("ls")) == 0)
{
/* print directory listing */
struct fat16_dir_entry_struct dir_entry;
while(fat16_read_dir(dd, &dir_entry))
{
printf_P(PSTR("%10lu %s%c\n"),
dir_entry.file_size,
dir_entry.long_name,
(dir_entry.attributes & FAT16_ATTRIB_DIR) ? '/' : ' '
);
}
}
else if(strncmp_P(command, PSTR("cat "), 4) == 0)
{
command += 4;
if(command[0] == '\0')
continue;
/* search file in current directory and open it */
struct fat16_file_struct* fd = open_file_in_dir(fs, dd, command);
if(!fd)
{
printf_P(PSTR("error opening %s\n"), command);
continue;
}
/* print file contents */
uint8_t buffer[8];
uint32_t offset = 0;
while(fat16_read_file(fd, buffer, sizeof(buffer)) > 0)
{
printf_P(PSTR("%08lx: %02x %02x %02x %02x %02x %02x %02x %02x\n"),
offset,
buffer[0],
buffer[1],
buffer[2],
buffer[3],
buffer[4],
buffer[5],
buffer[6],
buffer[7]
);
offset += 8;
}
fat16_close_file(fd);
}
#if FAT16_WRITE_SUPPORT
else if(strncmp_P(command, PSTR("rm "), 3) == 0)
{
command += 3;
if(command[0] == '\0')
continue;
struct fat16_dir_entry_struct file_entry;
if(find_file_in_dir(fs, dd, command, &file_entry))
{
if(fat16_delete_file(fs, &file_entry))
continue;
}
printf_P(PSTR("error deleting file: %s\n"), command);
}
else if(strncmp_P(command, PSTR("touch "), 6) == 0)
{
command += 6;
if(command[0] == '\0')
continue;
struct fat16_dir_entry_struct file_entry;
if(!fat16_create_file(dd, command, &file_entry))
printf_P(PSTR("error creating file: %s\n"), command);
}
else if(strncmp_P(command, PSTR("write "), 6) == 0)
{
command += 6;
if(command[0] == '\0')
continue;
char* offset_value = command;
while(*offset_value != ' ' && *offset_value != '\0')
++offset_value;
if(*offset_value == ' ')
*offset_value++ = '\0';
else
continue;
/* search file in current directory and open it */
struct fat16_file_struct* fd = open_file_in_dir(fs, dd, command);
if(!fd)
{
printf_P(PSTR("error opening %s\n"), command);
continue;
}
int32_t offset = strtol(offset_value, 0, 0);
if(!fat16_seek_file(fd, &offset, FAT16_SEEK_SET))
{
printf_P(PSTR("error seeking on %s\n"), command);
fat16_close_file(fd);
continue;
}
/* read text from the shell and write it to the file */
uint8_t data_len;
while(1)
{
/* give a different prompt */
uart_putc('<');
uart_putc(' ');
/* read one line of text */
data_len = read_line(buffer, sizeof(buffer));
if(!data_len)
break;
/* write text to file */
if(fat16_write_file(fd, (uint8_t*) buffer, data_len) != data_len)
{
printf_P(PSTR("error writing to file\n"));
break;
}
}
fat16_close_file(fd);
}
#endif
#if SD_RAW_WRITE_BUFFERING
else if(strcmp_P(command, PSTR("sync")) == 0)
{
if(!sd_raw_sync())
printf_P(PSTR("error syncing disk\n"));
}
#endif
else
{
printf_P(PSTR("unknown command: %s\n"), command);
}
}
/* close file system */
fat16_close(fs);
/* close partition */
partition_close(partition);
return 0;
}
//0 for success, negative for failure
int readLogCon(void) {
char keyword[64];
char value[64];
char stringBuf[512];
struct fat16_file_struct fd;
int len;
int s=0;
int t=0;
keyword[0]=0;
value[0]=0;
int result;
if(root_file_exists(LOGCON_NAME)) {
//There already is a logcon file, open it and suck int in
result = root_open(&fd,LOGCON_NAME);
if(result<0) return result;
len = fat16_read_file(&fd, (unsigned char *)stringBuf, 512);
if(len<0) return -1;
fat16_close_file(&fd);
} else {
//No existing logcon file, write a fresh one
result=root_open_new(&fd,LOGCON_NAME);
if(result<0) return result;
stringBuf[0]=0;
//Write out each default line
for(int i=0;strlen(fTable[i].tag)>0;i++) {
strcat(stringBuf,fTable[i].tag);
strcat(stringBuf,"=");
strcat(stringBuf,fTable[i].def);
strcat(stringBuf,"\r\n");
}
//write it out to the file
len=strlen(stringBuf);
fat16_write_file(&fd, (unsigned char*)stringBuf, len);
fat16_close_file(&fd);
sd_raw_sync();
}
//Either way, the logcon file is now in stringBuf and
//its length is in len
s=0;
t=0;
char inValue=0;
for(s = 0; s < len; s++) {
if(stringBuf[s] == '=') {
keyword[t]=0;
inValue=1;
t=0;
} else if(stringBuf[s]=='\n') {
value[t]=0;
inValue=0;
t=0;
result=processLine(keyword,value);
if(result<0) return result;
} else {
if(inValue) {
value[t]=stringBuf[s];
} else {
keyword[t]=stringBuf[s];
}
t++;
}
}
return 0;
}
