Ahí va el set de respuestas:
1.- El protocolo
RS485 utiliza ambos hilos tanto para transmitir como para recibir. Por ello
Ó se transmite
Ó se recibe, no se puede hacer con dos hilos las dos cosas al mismo tiempo. Así que es imprescindible conmutar al
MAX485 (o el SN75176 en mi caso) para que
Ó transmita
Ó reciba.
2.- Efectivamente
RB1 y
RB2 son
RX y
TX del PIC y están conectados como corresponde a los
RO y
DI del
MAX485 (o el SN75176 en mi caso) pero como hay que conmutar el
MAX485 (o el SN75176 en mi caso) entre
recepción y
emisión entonces tengo que utilizar otro Pin del PIC para hacerlo y utilicé
RB5 aunque podía haber elegido cualquier otro que estuviese libre.
Ten en cuenta que el
MAX485 (o el SN75176 en mi caso) con
DE/RE en
Low recibe en
RS485 por
A y
B, lo decodifica y transmite en
TTL por
RO, y con
DE/RE en
High recibe en
TTL por
DI, lo codifica y lo transmite en
RS485 por
A y
B.
3.A.- El
PIC recibe caracteres de uno en uno, uno detrás de otro. Mi programa los va recibiendo y los va guardando en la variable
USART_buffer que es una matriz (un arreglo) de 12 bytes de largo.
USART_nextRec es una variable en RAM que incremento (le sumo 1) cada vez que recibo un carácter y que me sirve de índice para guardar el caracter recibido en
USART_buffer.
Así al principio
USART_nextRec vale
0 y
USART_buffer está vacío. Cuando llega el primer carácter lo guardo en
USART_buffer[USART_nextRec] (o sea en
USART_buffer[0]) e incremento
USART_nextRec por lo que
USART_nextRec vale
1.
Cuando llega el segundo carácter hago lo mismo, o sea que lo guardo en
USART_buffer[USART_nextRec] (o lo que es lo mismo: en
USART_buffer[1]) e incremento
USART_nextRec por lo que
USART_nextRec vale ahora
2.
Así ¿hasta cuando? ... Pues hasta que reciba un carácter especial que me diga "
YA HE TERMINADO". Pero si no recibo este carácter especial, por cualquier tipo de fallo, podría darse el caso de ir recibiendo caracteres mucho mas allá de los 12 bytes que tiene
USART_buffer de capacidad. Por ello tengo ese límite en el que si recibo mas caracteres de los que caben en
USART_buffer vuelvo a poner
USART_nextRec a 0 y así me aseguro que no voy a ir guardando caracteres recibidos a lo largo de toda mi RAM.
3.B.- Si no pones todo el código o lees todo el código va a ser difícil que lo entiendas. Me explico:
En la interrupción por recepción de la USART
void interrupt_service_rutine_rda(void) tengo
void interrupt_service_rutine_rda(void) {
char USART_nextChar;
USART_nextChar='\0';
if(kbhit()){
USART_nextChar=getc();
USART_add_to_buffer(USART_nextChar);
}
}
O sea que recibo un carácter sobre
USART_nextChar y simplemente llamo a la función
USART_add_to_buffer(USART_nextChar) pasándole como parámetro el carácter recibido.
Pero es que la definición de esta función es:
void USART_add_to_buffer(char c);
Y ahí es donde tienes la "
letra c"
Es el parámetro de entrada de la función encargada de guardar el último carácter recibido en el buffer de recepción.
Esta función de
USART_add_to_buffer hace dos cosas.
Una: guarda en el buffer el último carácter recibido y ...
Dos: Mira si se dan las condiciones necesarias para ejecutar una orden si, y solo sí, lo recibido está completo, y también que lo recibido es "para mí en concreto", y también que lo recibido es para "mi tipo de dispositivo", y también que la orden recibida es "ejecuta un comando".
Si todas estas condiciones se dan entonces cargo el valor
0x01 en
Command para que sea ejecutado en el
main() del programa.
Todo esto creía que lo tenía bien explicado en el texto del post original. Pero parece que o no esta suficientemente claro o simplemente no lo has leído e intentas comprender directamente qué hace el programa leyendo el código del mismo sin tener en cuenta qué es lo que pretendo hacer con este programa.
Un consejo: Yo, cuando intento comprender un programa primero sustituyo las constantes por sus valores definidos en ellas y después lo leo traduciéndolo al idioma hablado normal. Por ejemplo es ese trozo de código que no comprendes haría ...
Imaginemos que recibo "
R1A!" tal como digo en el texto que explica el programa, entonces las variables tendrían los siguientes contenidos:
USART_buffer = {
R,
1,
A,
!}
USART_nextRec =
3 if(c=='!'){
--USART_nextRec;
if(USART_buffer[0]=='1'){
if(USART_buffer[1]=='R'){
if(USART_buffer[2]=='X'){
Command=0x01;
Y lo leería: Si el carácter recibido es '
!' (el que me indica que la transmisión es completa) entonces decrementa el indice de caracteres recibidos y comprueba si el primer carácter recibido es '
1' (o sea si es para mí), y si el segundo cáracter es '
R' (o sea si es para mi tipo que es un Rele) y si el tercer carácter es '
X' (o sea que ejecute una orden). Si todo es correcto entonces carga un
1 en
Command.
Como decía en el texto original:
"
Todo esto significa que el PC MASTER va a transmitir un frame del estilo de "R1X!" cuyo significado sería: Mensaje a los Dispositivos de Tipo 'R', al concreto dispositivo '1' para que ejecute el Comando 'X', fin de transmisión.
Todos los PIC escucharán este mensaje pero sólo el PIC que sea de Tipo 'R', que tenga el identificador concreto '1' ejecutará el comando 'X'."
4.- En cuanto al
Proteus no tengo ni idea porque nunca lo he utilizado.
No se si habré sabido explicarme mejor, pero ya sabes que aquí estamos para lo que podamos ayudar.
