// *****************************************************************************************************************
void beispiele(void){
char datei[12]="TEST TXT"; // hier muss platz für 11 zeichen sein (8.3), da fat_str diesen string benutzt !!
fat_str(datei); // wandelt "test.txt" in das fat format 8.3 der form: "TEST TXT" muss immer dieses Format haben, auch ordner !!
// 0.) ______________löschen von dateien/ordnern (ordner rekursiv)____________________________________________
ffrm( datei ); // löschen der datei/ordner falls vorhanden
// 1.) ______________anlegen und schreiben____________________________________________________________________
// öffnet datei, wenn nicht vorhanden, legt ffopen datei an (rückgabewert = 1 datei existiert, also nur öffnen, 2 = angelegt).
ffopen( datei );
// schreibt string
ffwrites((char*)"Hallo Datei :)");
// neue zeile in der datei
ffwrite(0x0D);
ffwrite(0x0A);
// schließt datei
ffclose();
// 2.)________________ändern von vorhandenen daten in dateien__________________________________________________
ffopen( datei ); // siehe oben...
ffseek(12); // spult in datei auf position 12 vor (fängt immer bei 0 an zu zählen !)
ffwrite(';'); // schreibt dann ab position 12 (überschreibt daten der datei, hier nur 1 zeichen)
ffclose(); // schließt datei
// 3.)________________lesen von dateien_________________________________________________________________________
ffopen( datei ); // siehe oben...
unsigned long int seek=file.length; // eine variable setzen und runterzählen bis 0 geht am schnellsten !
do{
uputc(ffread()); // liest ein zeichen und gibt es über uart aus !
}while(--seek); // liest solange bytes da sind (von datei länge bis 0)
ffclose(); // schließt datei
uputc('\n'); // neue zeile weil neue unteraufgabe
// 4.)________________anhängen von daten an datei_______________________________________________________________
ffopen( datei); // siehe oben...
ffseek(file.length); // spult in datei ans ende
ffwrites((char*)"Dies ist ein Test..."); // siehe oben
// neue zeile in der datei
ffwrite(0x0D);
ffwrite(0x0A);
ffclose(); // schließt datei
// 3.)________________lesen von dateien_________________________________________________________________________
ffopen( datei ); // siehe oben...
seek=file.length; // eine variable setzen und runterzählen bis 0 geht am schnellsten !
do{
uputc(ffread()); // liest ein zeichen und gibt es über uart aus !
}while(--seek); // liest solange bytes da sind (von datei länge bis 0)
ffclose(); // schließt datei
}
int tty_read(uint8_t minor, uint8_t rawflag, uint8_t flag)
{
uint16_t nread;
unsigned char c;
struct s_queue *q;
struct termios *t;
rawflag;
flag; // shut up compiler
/* Minor == 0 means that it is the controlling tty of the process */
if (!minor)
minor = udata.u_ptab->p_tty;
if (!udata.u_ptab->p_tty)
udata.u_ptab->p_tty = minor;
q = &ttyinq[minor];
t = &ttydata[minor];
nread = 0;
while (nread < udata.u_count) {
for (;;) {
if (deadflag[minor]) {
udata.u_error = ENXIO;
return -1;
}
if (remq(q, &c)) {
if (udata.u_sysio)
*udata.u_base = c;
else
uputc(c, udata.u_base);
break;
}
if (psleep_flags(q, flag))
return -1;
}
++nread;
/* return according to mode */
if (!(t->c_lflag & ICANON)) {
if (nread >= t->c_cc[VMIN])
break;
} else {
if (nread == 1 && (c == t->c_cc[VEOF])) {
/* ^D */
nread = 0;
break;
}
if (c == '\n')
break;
}
++udata.u_base;
}
wakeup(&q->q_count);
return nread;
}
/*
* Read or recvfrom a socket. We don't yet handle message addresses
* sensibly and that needs fixing
*/
arg_t net_read(struct socket *s, uint8_t flag)
{
usize_t n = 0;
struct sockdata *sd = s->s_priv;
irqflags_t irq;
uint8_t st;
volatile uint8_t data;
while (1) {
irq = di();
netstat = s->s_num;
st = status(s);
/* Error */
if (st & 0xC0)
break;
if (s->s_state < SS_CONNECTED) {
irqrestore(irq);
udata.u_error = EINVAL;
return -1;
}
/* We hit the EOF */
if (s->s_state > SS_CLOSEWAIT)
break;
/* Check our status */
/* Data ready */
if (st & 0x01) {
data = netdata;
/* Could be an error */
if (data == 0) {
st = status(s);
if (st & 0xC0)
break;
}
uputc(data, udata.u_base++);
n++;
if (n < udata.u_count)
continue;
}
if (n)
break;
s->s_iflag &= ~SI_DATA;
if (psleep_flags_io(&s->s_iflag, flag, &n)) {
irqrestore(irq);
return -1;
}
}
if (n)
return n;
if (st & 0x80) {
err_xlate(s);
return -1;
}
return 0;
}
// *******************************************************************************************************************************
// zeigt reihen eines clusters an, wird für ffls benötigt !
// es wird ab dem start sektor start_sec, der dazugehörige cluster angezeigt. geprüft wird ob es ein richtiger
// eintrag in der reihe ist (nicht gelöscht, nicht frei usw). die sektoren des clusters werden nachgeladen.
// die dateien werden mit namen und datei größe angezeigt.
// *******************************************************************************************************************************
void lsRowsOfClust (unsigned long int start_sec){
unsigned char row; // reihen
unsigned char sec=0; // sektoren
unsigned char tmp[12]; // tmp string zur umwandlung
do{
fat_loadSector(start_sec + sec); // sektoren des clusters laden
for(row=0;row<16;row++){ // geht durch reihen des sektors
fat_loadRowOfSector(row); // reihe eines sektors (auf dem puffer) laden
if( (file.attrib==0x20||file.attrib==0x10) && (file.name[0]!=0xE5 && file.name[0]!=0x00) ){
uputs(file.name);
uputc(' ');
ultoa(file.length,(char*)tmp,10);
uputs(tmp);
uputc('\n');
}
}
}while(++sec<fat.secPerClust);
}
int pty_read(uint8_t minor, uint8_t rawflag, uint8_t flag)
{
struct s_queue q = &ttyinq[minor + PTY_OFFSET + PTY_PAIR];
char c;
while (nread < udata.u_count) {
if (remq(q, &c)) {
if (udata.u_sysio)
*udata.u_base = c;
else
uputc(c, udata.u_base);
udata.u_base++;
nread++;
continue;
}
if (nread == 0 && psleep_flags(q, flag))
return -1;
}
return nread;
}
arg_t net_read(struct socket *s, uint8_t flag)
{
uint16_t n = 0;
while(1) {
if (s->s_state < SS_CONNECTED) {
udata.u_error = EINVAL;
return -1;
}
while(netat_ready() && n < udata.u_count) {
uputc(netat_byte(), udata.u_base++);
n++;
}
if (n)
return n;
s->s_iflag &= ~SI_DATA;
netat_wake();
/* Could do with using timeouts here to be clever for non O_NDELAY so
we aggregate data. For now assume a fifo */
if (psleep_flags(&s->s_iflag, flag))
return -1;
}
}
int tty_read(uint8_t minor, uint8_t rawflag, uint8_t flag)
{
usize_t nread;
unsigned char c;
struct s_queue *q;
struct tty *t;
used(rawflag);
used(flag); /* shut up compiler */
q = &ttyinq[minor];
t = &ttydata[minor];
nread = 0;
while (nread < udata.u_count) {
for (;;) {
if ((t->flag & TTYF_DEAD)&&(!q->q_count)) {
udata.u_error = ENXIO;
return -1;
}
jobcontrol_in(minor, t);
if (remq(q, &c)) {
if (udata.u_sysio)
*udata.u_base = c;
else
uputc(c, udata.u_base);
break;
}
if (!(t->termios.c_lflag & ICANON)) {
uint8_t n = t->termios.c_cc[VTIME];
if (n)
udata.u_ptab->p_timeout = n + 1;
}
if (psleep_flags_io(q, flag, &nread))
return nread;
/* timer expired */
if (udata.u_ptab->p_timeout == 1)
goto out;
}
++nread;
/* return according to mode */
if (!(t->termios.c_lflag & ICANON)) {
if (nread >= t->termios.c_cc[VMIN])
break;
} else {
if (nread == 1 && (c == t->termios.c_cc[VEOF])) {
/* ^D */
nread = 0;
break;
}
if (c == '\n')
break;
}
++udata.u_base;
}
out:
wakeup(&q->q_count);
return nread;
}
