Un rele en la lejania muy lejana :(

[septiembre_negro]

 Hola le yendo este magnifico hilo gracias al cual por fin logre hacer funcionar mi red rs485 hay una parte del código que por mas vueltas que le doy no logro entender se lo que hace ahí pero no entiendo la lógica de como lo hace la parte de código en cuestión es esta

Código: [Seleccionar]

 if(c==end_of_transmit){
      --USART_nextRec;
      if(USART_buffer[USART_nextRec-3]==WhatAmI){
         if(USART_buffer[USART_nextRec-2]==WhoAmI){
           if(USART_buffer[USART_nextRec-1]==Command_Execute){
              Command=0x01;
           }
         }
      }
      USART_nextRec = 0;
   }
OK como lo explica el señor red pic la intención de esta parte del código es comparar si la trama recibida es igual a la que tenemos definida en el código.
Asea que si transmito por el Terminal esto R1X! el programa lo recibe así en el buffer
USART_buffer[0]=R
USART_buffer[1]=1
USART_buffer[2]=X
USART_buffer[3]=!
Entonses porque hace esto        --USART_nextRec ????
Y esto                                        if(USART_buffer[USART_nextRec-3 ?????

Cuando mi poco desarrollada e inexperta lógica me dice que debería ser así

Código: [Seleccionar]


      if(USART_buffer[USART_nextRec[0]==WhatAmI){
         if(USART_buffer[USART_nextRec[1]==WhoAmI){
           if(USART_buffer[USART_nextRec[2]==Command_Execute

Como siempre agradezco la ayuda que puedan brindarme  por más que intento entenderlo solo me enredo más




   

[Nocturno]

Jaja, me ha encantado el título de tu hilo, muy bueno 

Te respondo a las dos preguntas:

Entonses porque hace esto        --USART_nextRec ????

USART_nextRec tiene el número total de caracteres recibidos, incluyendo el caracter de fin de línea (end_of_transmit). Le restas una unidad para que el valor que quede sea la longitud real sin incluir el fin de línea.

Y esto                                        if(USART_buffer[USART_nextRec-3 ?????

Si tienes en cuenta que USART_nextRec está apuntando al final de la línea, entenderás que restándole 3 estás recuperando el 4º carácter contando desde el final.
Y restándole 2 coges el antepenúltimo, y restándole 1 coges el penúltimo

[septiembre_negro]

Hola te agradezco la respuesta casi lon tengo pero es que me sigue sin cuadrar 
Lo que tengo es esto después des pues de que se termina la trama

USART_buffer[0]=R
USART_buffer[1]=1
USART_buffer[2]=X
USART_buffer[3]=!

Ok lo que entiendo con esta operación  --USART_nextRec es que se elimina  USART_buffer[3]=!
 Por lo que quedamos así
USART_buffer[0]=R
USART_buffer[1]=1
USART_buffer[2]=X
 
Y es así como ya no me salen las restas 2-3 ¿??

Me salen así
USART_buffer[0]=R
USART_buffer[1]=1
USART_buffer[2]=X
USART_buffer[3]=!
 

3-3=0
3-2=1
3-1=2


Por lo que sigo sin entender el  --USART_nextRec  o lo único que hace es que con el decremento indica que esa posición del array queda libre y queda apuntando USART_buffer[3]

[Nocturno]

Es que te falta un carácter en tu hipótesis inicial:
USART_buffer[0]=R
USART_buffer[1]=1
USART_buffer[2]=X
USART_buffer[3]=!
USART_buffer[4]=end_of_transmit

[septiembre_negro]

Chispas ya me enrede mas, según el señor red pic el fin de transmisión lo marca el carácter ! , Por lo que yo entiendo así

USART_buffer[0]=R
USART_buffer[1]=1
USART_buffer[2]=X
USART_buffer[3]=! end_of_transmit

Como es que  aparece  USART_buffer[4]=end_of_transmit

Creo que voy a tener que checar todo desde el principio 
Te agradezco mucho el tiempo que te as tomado para responder 

[Nocturno]

Disculpa, me había liado con el end_of_transmit.

Releyendo el código del amigo RedPic veo esto:

Código: C

1. void USART_add_to_buffer(char c){
2.  
3.    USART_buffer[USART_nextRec++]=c;
4.    if(USART_nextRec==bytes_for_USART_buffer){
5.       USART_nextRec=0;
6.    }
7.  
8.    if(c==end_of_transmit){
9.       --USART_nextRec;
10.       if(USART_buffer[USART_nextRec-3]==WhatAmI){
11.          if(USART_buffer[USART_nextRec-2]==WhoAmI){
12.            if(USART_buffer[USART_nextRec-1]==Command_Execute){
13.               Command=0x01;
14.            }
15.          }
16.       }

Si te fijas, en la instrucción USART_buffer[USART_nextRec++]=c; se mete el caracter "c" al final del buffer, y luego se incrementa en una unidad el puntero USART_nextRec, puesto que el operador ++ está situado detrás de la variable.

Por esa razón, luego al entrar en el if lo primero que hace es restarle una unidad.

[septiembre_negro]

OK por fin me queda claro   como estoy aprendiendo todavía me lió con variable++ o ++variable .
Te agradezco  

 

[Nocturno]

Disculpa, pero yo sigo viendo el operador ++ detrás de la variable.

[septiembre_negro]

Disculpa, pero yo sigo viendo el operador ++ detrás de la variable.

Ok como digo estoy aprendiendo y  seguramente estoy leyendo mal esa parte del código,
Lo que yo entiendo con esto   USART_buffer[USART_nextRec++]=c;  suponiendo que estamos en la primera vuelta  USART_nextRec=0 el contenido de c se almacena en USART_nextRec[0] y  después incrementa el índice en 1 . Si el enunciado fuera así
 USART_buffer[++USART_nextRec]=c;  como se leería el enunciado ¿?, esto es lo que no acabo de entender cual es la diferencia entre ++variable y variable++.
Y en ningún momento fue mi intención corregirte simplemente supuse que habías cometido un error de pluma e intente corregirlo para que cuando alguien mas lo leyera no se confundiera.
Una disculpa si  lo que intente sentar como cierto esta equivocado

[RedPic]

Vamos a ver si logro  expresarlo claramente.

USART_buffer[USART_nextRec++]=c;

Guarda el contenido de c dentro de USART_buffer en la posición que indique USART_nextRec e incrementa después en uno USART_nextRec.

USART_buffer[++USART_nextRec]=c;

Incrementa después en uno USART_nextRec y después guarda el contenido de c dentro de USART_buffer en la posición que indique USART_nextRec.

El concepto es solo diferente en que el operador incremento ++ antes de la variable indica que hay que incrementarla antes de utilizar su valor, después de la variable indica que hay que utilizar su valor antes de incrementarla.

n=++i; indica incrementar i y guardar el resultado en n
n= i++; indica guardar i en n e incrementar i

[RedPic]

Lo correcto es: puesto que el operador ++ está situado delante de la variable
Primero almacena c y luego incrementa el índice

Falso. Justo al revés.

Nota: Siempre y cuando delante signifique a la izquierda de la variable y detrás a la derecha de la variable, o sea delante o dtras en el sentido de la escritura.

[RedPic]

A la vista de este código

Código: CSS

1. void USART_add_to_buffer(char c){
2.  
3.    USART_buffer[USART_nextRec++]=c;
4.    if(USART_nextRec==bytes_for_USART_buffer){
5.       USART_nextRec=0;
6.    }
7.  
8.    if(c==end_of_transmit){
9.       --USART_nextRec;
10.       if(USART_buffer[USART_nextRec-3]==WhatAmI){
11.          if(USART_buffer[USART_nextRec-2]==WhoAmI){
12.            if(USART_buffer[USART_nextRec-1]==Command_Execute){
13.               Command=0x01;
14.            }
15.          }
16.       }
17.       USART_nextRec = 0;
18.    }
19. }

Fijaos que lo primero que se ejecuta es exactamente la asignación de c en USART_buffer y el incremento posterior de USART_nextRec. Cualquier instrucción posterior debe tener en cuenta este hecho.

Así al recibir la trama R1X! ocurre lo siguiente ...

USART_nextRec vale 0.
Se recibe R.
Se guarda R en USART_buffer[0] y se incrementa USART_nextRec.
USART_nextRec vale 1.
Como c no es ! (definido como end_of_transmit) no hacemos nada mas.
...
Se recibe 1.
Se guarda 1 en USART_buffer[1] y se incrementa USART_nextRec.
USART_nextRec vale 2.
Como c no es ! (definido como end_of_transmit) no hacemos nada mas.
...
Se recibe X.
Se guarda X en USART_buffer[2] y se incrementa USART_nextRec.
USART_nextRec vale 3.
Como c no es ! (definido como end_of_transmit) no hacemos nada mas.
...
Se recibe !.
Se guarda ! en USART_buffer[0] y se incrementa USART_nextRec.
USART_nextRec vale 4.
Como c si es ! (definido como end_of_transmit) ejecutamos el interior de if(c==end_of_transmit) que es este caso ya es cierto.

El estado al entrar dentro de este if es el descrito anteriormente como

USART_buffer[0]=R
USART_buffer[1]=1
USART_buffer[2]=X
USART_buffer[3]=! end_of_transmit


y USART_nextRec vale 4.

Y entonces lo primero que hago es decrementar en 1 el contenido de USART_nextRec con --USART_nextRec para que las comparaciones siguientes tengan sentido.

Con --USART_nextRec el valor de USART_nextRec es 3.

Y así los siguientes If's indican:

if(USART_buffer[USART_nextRec-3]==WhatAmI) es lo mismo que if(USART_buffer[0]==WhatAmI)
if(USART_buffer[USART_nextRec-2]==WhoAmI) es lo mismo que if(USART_buffer[1]==WhoAmI)
if(USART_buffer[USART_nextRec-1]==Command_Execute) es lo mismo que if(USART_buffer[2]==Command_Execute)

Si estos tres If's encadenados son verdad entonces se cambia la variable Command asignándole el valor 1 para que surta lo efectos a que sea menester.

En cualquier caso, y tras haber recibido ! (end_of_transmit) se vuelve a inicializar a 0 el valor de USART_nextRec para que la siguiente recepción vuelva a comenzar por USART_buffer[0].

Esta es la descripción, paso a paso, de este código.

Un saludo.
 

[septiembre_negro]

Tan claro como el agua maestro, aprovecho este momento para felicitarle por los excelentes hilos que a tenido a bien publicar han sido una luz en el camino.
Una vez más pido una disculpa por sentar a la ligera como cierto algo en lo que estaba rotundamente equivocado 

[ykornx]

Hola amigos!

Tengo un proyecto para hacer comunicación rs485. Lo que pasa es que estoy trabajando con MPLAB y no tengo claro como modificar el código de CCS para MPLAB.
En los foros no puedo encontrar nada de ejemplos para rs485 escrito para MPLAB.
Este tema le leí, le entiendo pero hay cosas que no se como implementar en MPLAB.

Alguien me puede ayudar por favor!

Muchas gracias!

[Suky]

Hola amigos!

Tengo un proyecto para hacer comunicación rs485. Lo que pasa es que estoy trabajando con MPLAB y no tengo claro como modificar el código de CCS para MPLAB.
En los foros no puedo encontrar nada de ejemplos para rs485 escrito para MPLAB.
Este tema le leí, le entiendo pero hay cosas que no se como implementar en MPLAB.

Alguien me puede ayudar por favor!

Muchas gracias!

Usaras CCS en MPLAB? Si es así hay que instalar un adicional y crear el proyecto correctamente, sobre ello hay información en el foro!


Saludos!