Newsgroup: it.hobby.elettronica.digitale
Titolo: rs232 mikro c

ciao a tutti,
con questo semplice codice in mikroC
unsigned short i;
void main() {
   USART_init(2400);                      // initialize USART module
                                          //  (8 bit, 2400 baud rate, no 
parity bit...
   while (1) {
   delay_ms(100);
       i = 'b';
       USART_Write(i);                    // send data via USART
       delay_ms(1000);
     }
}
rieso ad inviare solo un carattere per volta, come mai? se per esempio b 
assume il valore di 'abc' sul computer ricevo il carattere | mentre se invio 
un solo carattere funziona. Come posso fare per inviare delle stringhe ? 


con qualcosa del genere:
char *cp = "abc";	// stringa  costante da spedire
char *p;		// puntatore al carattere corrente
			// ( variabile temporanea )
	p = cp;		// p punta al primo carattere della stringa
	while (*p!=0) { // finche' non arrivi alla fine della stringa
		USART_write(*p); // trasmetti il carattere corrente
		delay_ms(1000);	// aspetta la fine della trasmissione
		p++;		// passa al prossimo carattere
	}
NOTA BENE: il delay puo' essere ( anzi dovrebbe ) sostituito con il test 
sull'avvenuta trasmissione del carattere corrente , se leggi il 
dsatasheet dell'integrato che stai usando e' spiegato tra i registri di 
controllo dell USART quale bit controllare
altra cosa:
i= 'abc'  ha poco senso in C
i= "abc" assegna ad i un qualcosa che 'somiglia' all'inidirizzo di 
memoria dove si trova la stringa "abc" da cui il carattere strano trasmesso

 ha scritto nel messaggio 
news:456afd68$0$19231$4faf...@reader4.news.tin.it...


 ?
Una possibilità è quella di creare un generico vettore di byte (unsigned
char, ipotizzando che siano a 8 bit come di solito avviene) di una certa
dimensione.
Questo è il tuo buffer di trasmissione. Unito a questo buffer hai una
variabile intera (es. num_bytes) il cui valore indica il numero di byte
presenti nel buffer (all'inizio vale zero ad indicare che il buffer è
vuoto).
Come prima cosa riempi il buffer partendo dalla prima locazione con quello
che vuoi inviare con una serie di assegnazioni.
Ogni volta che inserisci un byte nel buffer incrementi la variabile
num_bytes di 1. Attenzione a non andare oltre alla dimensione del vettore.
Se tra le altre cose vuoi spedire una variabile di tipo intero (char, short,
int, long, ...), dipende se vuoi che vengano spediti i byte che la
codificano come rappresentazione binaria (possono essere 2, 4, ...byte a
seconda di come la variabile intera è codificata nella tua architettura) o
se vuoi che venga spedita la stringa di caratteri ASCII che rappresenta il
valore della variabile (es. la stringa relativa al numero 356 è costituita
da 3 caratteri ASCII, quindi sono 3 byte, lo stesso numero 356 se assegnato
ad una variabile di tipo short può essere codificato ad esempio con 2 byte).
In ogni caso in genere si tratta di più di un byte. Quindi devi "costruirti"
questi byte partendo dalla variabile e inserirli nel vettore.
Preparato il tuo buffer di trasmissione con quello che vuoi spedire,
spedisci tutti i byte che sono presenti nel buffer di trasmissione (il
numero lo conosci) uno alla volta disinteressandosi del significato di tali
byte.

 
normalmente in C si utilizza la printf,vedi se il tuo compilatore la 
fornisce tra le funzioni di libreria, che ha i seguenti problemi:
1) e' piuttosto grande anche nelle implementazioni minimali,
2) va adattata al particolare modo di 'emettere' i singoli caratteri ( 
tieni conto che nelle implementazioni per sistemi grandi tutto si 
risolve con i files )
3) e' in  qualche modo ridondante in quanto ha una serie di 
funzionalita' aggiuntive di 'scarso' uso in ambito embedded
io personalmente tendo ad evitarla, essenzialmente per primo motivo
separando la trasmissione dei testo e la trasmissione dei numeri
avendo a disposizione le seguenti funzioni
UART_putc(char c);
UART_putstr(char *p);
UART_putnum(int n);
UART_putc() deve essere bloccante cioe' aspetta la fine di una eventuale 
trasmissione ( di un carattere ) prima di trasmettere il successivo
UART_putstr() e UART_putnum() vanno poi implementate utilizzando la 
UART_putc().
il tuo tramsetti("(aa B")) diventa una cosa del tipo
UART_putstr("(aa "); UART_putnum(n); UART_putc(')');
dove n e' la variabile che contiene il numero che vuoi trasmettere