[C] Gestione I/O da ttyusb, File descriptor, mutex...

[mdr268]

Ciao a tutti!

Sto tentando di creare un programmino in C su linux per gestire una schedina elettrica.
In particolare, mandando un pacchetto a questa scheda dovrebbe restituirmi un pacchetto di risposta.

Per mandare il pacchetto utilizzo la funzione write di unistd.h e per leggere il pacchetto di risposta utilizzo read dello stesso header.
Come parametri a queste due funzioni, mando il file descriptor della porta /dev/ttyUSB0 opportunamente aperta, l'indirizzo dove leggere/scrivere il messaggio e la dimensione del messaggio.

Riporto le definizioni da unistd.h

extern ssize_t write (int __fd, const void *__buf, size_t __n) __wur;
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __wur;

il mio problema è che riesco a scrivere (o almeno credo) sul file descriptor ma non riesco a leggere nessun carattere!

Le mie domande ora sono:
1. Posso utilizzare lo stesso file descriptor sia per la lettura che per la scrittura?

2. Posso iniziare la lettura subito dopo la scrittura?

3. Va bene utilizzare bloccare il mutex prima della scrittura (write()) e sbloccarlo dopo la lettura (read())?

#include <pthread.h>
[...]
pthread_mutex_t serial_mutex = PTHREAD_MUTEX_INITIALIZER;
[write(...)...]
pthread_mutex_lock(&serial_mutex);
[read(...)...]
pthread_mutex_unlock(&serial_mutex);

Ho già visto la documentazione ma non ho trovato granchè.
Grazie a tutti quelli che mi daranno una mano!

[Oceans11]

Originariamente inviato da mdr268

Ciao a tutti!

Sto tentando di creare un programmino in C su linux per gestire una schedina elettrica.
In particolare, mandando un pacchetto a questa scheda dovrebbe restituirmi un pacchetto di risposta.

Per mandare il pacchetto utilizzo la funzione write di unistd.h e per leggere il pacchetto di risposta utilizzo read dello stesso header.
Come parametri a queste due funzioni, mando il file descriptor della porta /dev/ttyUSB0 opportunamente aperta, l'indirizzo dove leggere/scrivere il messaggio e la dimensione del messaggio.

Riporto le definizioni da unistd.h

extern ssize_t write (int __fd, const void *__buf, size_t __n) __wur;
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __wur;

il mio problema è che riesco a scrivere (o almeno credo) sul file descriptor ma non riesco a leggere nessun carattere!

sapere che vuol dire "non riesco a leggere nessun carattere" aiuterebbe.
che valore di ritorno ti dà l'invocazione della read? Eventualmente a cosa viene settato errno?

Le mie domande ora sono:
1. Posso utilizzare lo stesso file descriptor sia per la lettura che per la scrittura?

non mi è mai capitato un caso un cui non si potesse fare.

2. Posso iniziare la lettura subito dopo la scrittura?

Sì, ma non ti puoi aspettare che ciò che leggi è ciò che hai appena scritto. Dipende.

3. Va bene utilizzare bloccare il mutex prima della scrittura (write()) e sbloccarlo dopo la lettura (read())?

non credo siano necessari i mutex se un solo thread/processo legge e scrive.


ps: come lo ottieni il file descriptor?
riesci a leggere e scrivere da terminale con i redirect?
disclaimer: mi diletto con il c da pochi mesi a tempo perso, non sono l'oracolo

[mdr268]

Originariamente inviato da Oceans11

sapere che vuol dire "non riesco a leggere nessun carattere" aiuterebbe.
che valore di ritorno ti dà l'invocazione della read? Eventualmente a cosa viene settato errno?

Read come valore di ritorno dà il numero di bytes letti dalla schedina. Nel mio caso mi restituisce zero bytes.
Errno lo provo domattina, non lo conoscevo.

non mi è mai capitato un caso un cui non si potesse fare.

Perfetto!

Sì, ma non ti puoi aspettare che ciò che leggi è ciò che hai appena scritto. Dipende.

Nel mio caso mando un messaggio da pc alla schedina e ottengo in risposta un messaggio completamente diverso che genera la schedina.

non credo siano necessari i mutex se un solo thread/processo legge e scrive.

Allora per il momento li oscuro con i commenti, però di sicuro mi serviranno più avanti perchè l'obiettivo finale è quello di far comunicare tra di loro più schedine.

ps: come lo ottieni il file descriptor?

Il file descriptor lo ottengo da una funzione che lancio all'inizio del programma:

#include <unistd.h>
static int serial_fd;

int serial_open(char *port) {
	serial_fd = open(port, O_RDWR | O_NOCTTY | O_NDELAY);
	if (serial_fd == -1) {
		printf("Unable to open serial port write%s\n", port);
		return -1;
	}

	struct termios term;
	fcntl(serial_fd, F_SETFL, 0);	// blocking read
	tcgetattr(serial_fd,&term);
	term.c_lflag = 0;
	term.c_cc[VTIME]    = 20;   // 2s timeout
	term.c_cc[VMIN]     = 0;
	tcflush(serial_fd, TCIOFLUSH);
	
	cfsetispeed(&term, B57600);
	cfsetospeed(&term, B57600);
	tcsetattr(serial_fd,TCSANOW,&term);
	return 0;
}

riesci a leggere e scrivere da terminale con i redirect?

L'input è un pacchetto fatto da un array di 20 uint_8, che differenza fa darli in input da terminale o dal sorgente?

disclaimer: mi diletto con il c da pochi mesi a tempo perso, non sono l'oracolo

Io ci sto lavorando da circa tre settimane.
Mi hai dato comunque qualche spunto su cui lavorare ed un grosso aiuto, grazie!

[Oceans11]

Read come valore di ritorno dà il numero di bytes letti dalla schedina. Nel mio caso mi restituisce zero bytes.
Errno lo provo domattina, non lo conoscevo.

errno viene impostato solo quando read restituisce -1.

Il file descriptor lo ottengo da una funzione che lancio all'inizio del programma:

#include <unistd.h>
static int serial_fd;

int serial_open(char *port) {
	serial_fd = open(port, O_RDWR | O_NOCTTY | O_NDELAY);
	if (serial_fd == -1) {
		printf("Unable to open serial port write%s\n", port);
		return -1;
	}

	struct termios term;
	fcntl(serial_fd, F_SETFL, 0);	// blocking read
	tcgetattr(serial_fd,&term);
	term.c_lflag = 0;
	term.c_cc[VTIME]    = 20;   // 2s timeout
	term.c_cc[VMIN]     = 0;

	tcflush(serial_fd, TCIOFLUSH);
	
	cfsetispeed(&term, B57600);

	cfsetospeed(&term, B57600);
	tcsetattr(serial_fd,TCSANOW,&term);
	return 0;
}

Qui vado a spanne. Stai aprendo il file descriptor in lettura e scrittura, in modalità non bloccante (O_NDELAY), poi con la chiamata a fcntl la cambi in bloccante? perchè? controlla il valore di ritorno della fcntl (se -1 controlla errno)

L'input è un pacchetto fatto da un array di 20 uint_8, che differenza fa darli in input da terminale o dal sorgente?

se riesci a colloquiare con la schedina via terminale il problema è nel codice. Altrimenti potrebbe essere una questione di permessi o chissà cos'altro.

[mdr268]

Originariamente inviato da Oceans11

Qui vado a spanne. Stai aprendo il file descriptor in lettura e scrittura, in modalità non bloccante (O_NDELAY), poi con la chiamata a fcntl la cambi in bloccante? perchè? controlla il valore di ritorno della fcntl (se -1 controlla errno)

Le schede che utilizzo io sono la nuova versione di altre schede. Non conoscendo il C, sono partito dal codice delle schede vecchie per adattarlo a quelle nuove.
Questo potrebbe essere la causa della lettura di 0 caratteri, provo a verificarlo fra poco.

se riesci a colloquiare con la schedina via terminale il problema è nel codice. Altrimenti potrebbe essere una questione di permessi o chissà cos'altro.

Ci provo

[mdr268]

fcntl mi restituisce 0, quindi nessun errore.

Qui, http://www.dreamincode.net/forums/to...-f-setfl-0%3B/, spiegano cosa fa esattamente fcntl(serial_fd, F_SETFL, 0).

Non credo sia quello il problema.
La scheda mi restituisce un messaggio solo se prima riceve un messaggio.
Forse il problema è che non riceve nulla.

Questo cast a void* è corretto?

uint8_t cmd[] = { 0x16, 0x16, 0xC0}
int result;
result = write(serial_fd, (void*) &cmd, size);

result in questo caso mi restituisce 3.

Non riesco a utilizzare redirect da terminale, se provo a fare subito dopo la scrittura

cat < /dev/ttyUSB0

non mi restituisce nulla... forse sbaglio qualcosa.

[Oceans11]

Originariamente inviato da mdr268

Questo cast a void* è corretto?

uint8_t cmd[] = { 0x16, 0x16, 0xC0}
int result;
result = write(serial_fd, (void*) &cmd, size);

result in questo caso mi restituisce 3.

il cast a void è inutile. La write ritorna il valore esatto a quanto pare.
Dipende poi dal dispositivo se ciò che hai scritto viene effettivamente scritto immediatamente o meno.

Non riesco a utilizzare redirect da terminale, se provo a fare subito dopo la scrittura

cat < /dev/ttyUSB0

non mi restituisce nulla... forse sbaglio qualcosa.

prova a leggere così da terminale:

while read line < /dev/ttyUSB0; do echo $line; done

poi apri un altro terminale e scrivi con

echo "quellochetipare" >> /dev/ttyUSB0

ps: forse questo test è inutile, visto che la write sembra funzionare. Certo male non fà.

[mdr268]

Il programma funziona!

L'errore stava nel checksum del messaggio che veniva calcolato in maniera sbagliata e quindi la scheda non inviava la risposta al computer!

Grazie dell'aiuto!