TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: septiembre_negro en 09 de Octubre de 2009, 19:39:11

Título: Un rele en la lejania muy lejana :(
Publicado por: septiembre_negro en 09 de Octubre de 2009, 19:39:11

 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




   

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: Nocturno en 09 de Octubre de 2009, 19:45:47

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

Te respondo a las dos preguntas:

Cita de: septiembre_negro en 09 de Octubre de 2009, 19:39:11

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.

Cita de: septiembre_negro en 09 de Octubre de 2009, 19:39:11

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

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: septiembre_negro en 09 de Octubre de 2009, 20:12:42

Hola te agradezco la respuesta casi lon tengo pero es que me sigue sin cuadrar  :oops:
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]

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: Nocturno en 09 de Octubre de 2009, 20:19:06

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

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: septiembre_negro en 09 de Octubre de 2009, 20:39:21

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  ;-)

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: Nocturno en 09 de Octubre de 2009, 20:45:13

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.

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: septiembre_negro en 10 de Octubre de 2009, 15:24:10

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

 

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: Nocturno en 10 de Octubre de 2009, 16:01:02

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

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: septiembre_negro en 11 de Octubre de 2009, 14:42:40

Cita de: Nocturno en 10 de Octubre de 2009, 16:01:02

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

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: RedPic en 11 de Octubre de 2009, 15:03:18

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

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: RedPic en 11 de Octubre de 2009, 15:06:29

Cita de: septiembre_negro en 10 de Octubre de 2009, 15:24:10

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.

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: RedPic en 11 de Octubre de 2009, 15:45:24

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.
 

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: septiembre_negro en 11 de Octubre de 2009, 16:00:36

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  :oops: :oops:

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: ykornx en 13 de Julio de 2010, 13:19:53

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!

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: Suky en 13 de Julio de 2010, 13:43:33

Cita de: ykornx en 13 de Julio de 2010, 13:19:53

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!

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: Diego E. en 13 de Julio de 2010, 14:13:18

Hola amigo, pues lo que yo hago es lo siguiente:

Tengo instalados tanto CCS 4.0 como Mplab 8.3, luego abro Mplab y creo un nuevo proyecto, cundo me pide seleccionar el lenguaje selecciono CCS C compiler For PIC10/12/14/...
luego el la location si no está configurado el compilador busco el ejecutable Ccsc.exe, por lo general está en "C:\Archivos de programa\PICC\Ccsc.exe", ahora continúo la cración del proyecto normal.
ya de esta forma puedes abrir perfectamente cualquier archivo creado en CCS y trabajarlo conjuntamente con todas las herramientas del Mplab

saludos.

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: ykornx en 13 de Julio de 2010, 15:32:39

Hola, muchas gracias por las respuestas Suky y Diego E., como que soy nuevo en el PIC no lo sabía esto.
Ahorra mismo voy a probar!

Gracias

Título: Re: Un rele en la lejania muy lejana :(
Publicado por: elfrancho en 02 de Mayo de 2011, 12:39:11

Sres gracias a ustedes he entendido mucho mejor hacerca de este protocolo, sólo me queda una duda, este circuito de relay a distancia es capaz de recibir datos y también enviar?

Preguntitas varias:

- Siempre que se envía datos con el master, conviene ponerlo a la escucha con los pines DE/RE ? ¿lo mismo para los esclavos?
- Si tengo varios dispositivos conectados informando eventos al master, como podría evitar que dos esclavos transmitan al mismo tiempo?
- Hasta cuantos dispositivos esclavos se pueden colocar en la linea?


SALUDOS!!!

FrAnChO !!!!