Si te fijas bien, el primer nodo usa una memoria I2C 24C256
Bravo Marcos, you can be the boss with the can bus
Marco esta muy bien eso, en mi empresa usamos uno para communtar EBU, con Mesa Yamaha Digital, usamos un DME32, bueno ya hay varios, lastima no estoz ahora en mi trabajo, pero desde alli te dare mas informe del que usamos,me gustaria saber que tipo de software usa para trabajar con ellos, ya estare por aqui dandote la lata, no tengo todas la informacion aqui para hacerte pregunta. :mrgreen:
pero te molestare, lo que me enviaste lo estoy estudiando, pero tu sabe que quiero acabar eso dichoso DMXPACK que por culpa de muchos trabajos no me da tiempo, pero voy piano piano :D
saludo amigo :-/
Hay muchos protocolos montados sobre el BUS CAN.Tiene Razon, porque uso un Tongle que corre con el software, pero voy intentar averiguar con el Hardware y el code, ese que tu vee ahi es CanOpen, asi con el controlamos la Etapa de potencia via ETHERNET, con el controla desde una pc todas las etapa de potencia, es muy interesante, pero dime a ver que programa tu usa para controlar tu CAN?
En la industria los mas conocidos son DeviceNet, CanOpen, y otros mas que no recuerdo.
Por lo que veo en otras ramas tambien usan el BUS CAN para montar un protocolo arriba, pero lo unico que es publico es la definicion del BUS CAN, no el protocolo montado arriba que DEBERIA SER publico...
Si investigas sobre DeviceNet y CanOpen, veras que abren a los desarrolladores que quieran utilizarlo las especificaciones (en algunos casos es pago y en otros te cobran la auditoria de cumplimiento de la especificacion), pero dudo que puedas conseguir el protocolo verdadero de ese BUS que pones en el link, salvo que sea pago...
Para informacion general, los ID del BUS CAN estan grabados en el dispositivo, aqui no se usan direcciones de red...
Por lo tanto para especificar direcciones se debe montar arriba un protocolo adicional, que es lo que hacen estos fabricantes...
Si bien el BUS CAN esta considerado un protocolo en si mismo, es mas a nivel de hardware, por eso lo usan como medio fisico para establecer arriba un protocolo mas amplio.
Aprovechan la genialidad y fortaleza de este noble bus de campo. 8)
En realidad no se porque, pero en la pagina no veo nada... :shock: :(Lo se :? esa pagina siempre da problema, pero tranquilo buscare la informacion y los llamare :D
Hay muchos protocolos montados sobre el BUS CAN.
Si bien el BUS CAN esta considerado un protocolo en si mismo, es mas a nivel de hardware, por eso lo usan como medio fisico para establecer arriba un protocolo mas amplio.
Aprovechan la genialidad y fortaleza de este noble bus de campo. 8)
Ahi se explica el funcionamiento del CAN bit a bit, tanto el modo stantdard como el modo extendido. El uso de los filtros para la deteccion de mensajes, etc.
No veo forma que implementes una grabacion a tal velocidad, considerando que un bit dura unos pocos microsegundos y las eeprom tardan mas tiempo en grabar que lo que tarda en pasar un chorizo de datos por el BUS... :(Hola marcos
Por eso es que el monitoreo de datos normalmente se hace con software en PC, donde no hay problemas de almacenamiento.
Yo no dispongo de ninguno de los softwares para realizar monitoreo, tengo entendido que todos son pagos y lo que intento aqui es usar software de uso libre...
Si sabes de alguno que no sea pago para poder hablar aqui, te pido me avises y lo buscare para ponerlo, la idea del hilo es ir compartiendo experiencias sobre un tema que es un poco Tabú en el ambiente, porque cada uno tuvo que pelarse la frente para poder acceder a la información y le cuesta soltarla... :mrgreen: :mrgreen:
Gracias STK, pero no anda, es decir, este software esta hecho para usar con los analizadores de esa firma... :( :(:x eso mama racho :D
Yo tengo el CanKing, en la version que viene con las placas de Microchip, y esa version es gratuita...
Voy a ver de utilizar esa por ahora, para las practicas... :) :)
Por supuesto que tambien CanKing no es gratis en todas sus versiones, pero si lo es en las que entrega para Microchip, personalizadas para sus placas...quizas tu conozca esta pagina http://www.kvaser.com/index.htm
Veremos si logro personalizar alguna version para usar con mi placa... :mrgreen:
Marcos, ¿podrías explicar el significado de los parámetros en estas funciones?Como no, Maestro Manolo!!
can_getd(rx_id, &buffer[0], rx_len, rxstat);
can_putd(SET_LED_ID_B, &b_leds, 1, 1, 1, 0);
Gracias guapetón :D
Nose si es muy tarde la pregunta pero, esque estoy interesado en el tema, ya que debo hacer una aplicacion sencilla entre 2 o 3 micros que usen en BUS CAN, y esto que veo talvez sea mas trabajado, y como menciono solo quisiera iniciarme con algo sencillo, tengo a la disposicion 3 micros 18f4685, y pues del CAN nunca sape nada, jeje, hasta ahora, y si no fuera molestia me explican mas o menos en que consiste?? es como el I2C?
bueno disculpen si interfiero, un saludo, muchas gracias por la ayuda
crees que manden muestras hasta mi pais?? ya que aca no mandan casi nada :( pero lo intentareAsí me gusta!!
mmm, bueno no hay problema si se hace solo entre dos PIC's solo es para iniciarse, si puedo disponer de crisatales de 10MHz :-/
gracias :mrgreen:
Marcos, según Microchip todos estos micros tienen periférico CAN:
http://www.microchip.com/ParamChartSearch/chart.aspx?branchID=50&mid=10&lang=en&pageId=74
¿sabes si con ellos nos podemos ahorrar los transceptores?, ¿conoces la diferencia entre bus CAN y ECAN?
ECAN es la version extendida del CAN. La diferencia radica en la longitud del identificador en el frame. Para CAN, la longitud del identificador es de 11 bits, en el caso de ECAN es de 23 bits.
Una vez que estan ambos con su codigo y conectados deberias poder ver algo por sus puertos serie (en cada ejemplo, para hacer debug, deberan estar conectados), utilizando el Port Monitor de CCS.
:) :) :)
CitarUna vez que estan ambos con su codigo y conectados deberias poder ver algo por sus puertos serie (en cada ejemplo, para hacer debug, deberan estar conectados), utilizando el Port Monitor de CCS.
:) :) :)
me puedes hablar algo mas del port monitor ... es una conexion por puerto serial?? :shock: o es algo especifico de ccs....
saludos
... la mitad de las tareas que estan representadas aquí son realizadas por el transceptor CAN, en mi caso utilizo el MCP2551, pero hay cantidades de transceptores de excelente calidad, de casi todas las marcas...
Despues di con el problemas y es que el transceptor MCP2551 necesitaba una resistencia que en algunos diagramas habia visto que no lo usaban y por eso yo no lo puse. este problema lo venia arrastrando desde que use el MCP2515 por eso no me funciono en su momento.
otra aclaracion.... hice pruebas y halle que es lo mismo usar el transceptor MCP2515 de microchip y el 82C250 DE PHILIPS los son equivalentes.Casi todas las marcas poseen sus transceiver de CAN, yo uso ademas del MCP2551, uno de la firma Texas.
:-/ :-/ en horas buenas Marcos :-/ :-/
ya nos aclarara´ lo que hace con los pulsadores, donde me imagino que es el Menu del Display activando comando :mrgreen:
muchas suerte amigo en tu projectos :-/ :-/ sigue ahi que eso va................. :-/ :-/ :-/ :-/
El PLC es un TWIDO de TELEMECANIQUE (grupo Schneider).Pregunta:
El uso del PLC es por que ya dispongo del mismo, y también por el grado de fiabilidad en horas de funcionamiento.
Otra de las ventajas es que la medida ya que su reducido espacio permite introducirlo en la caja de los térmicos de la vivienda sobre carril DIN.
Antes te he realiza la consulta sobre como has programado el MCP2515... Yo compre para las primeras pruebas este kit de desarrollo (te adjunto el link del PDF http://ww1.microchip.com/downloads/en/DeviceDoc/51416a.pdf ), y no he tenido narices a realizar la programación. Supongo que tu lo estas programando mediante conector ICSP. Pero claro lo que no entiendo es como lo has configurado.
Si tienes un doc de como programar el tema o me comentas donde puedo bajar documentación para la programación del mismo.
Yo me he leído al documentación de microchip y no he conseguido nada. También me hace falta saber el programador que usas (yo uso el USB LITE) pero en el WIN800 no da soporte para el MCP2515.
Aquí les pongo el link al .pdf, así pueden bajarlo a sus máquinas...
Placa en pdf (http://rapidshare.com/files/75629129/Placa_CAN_ETH.pdf)
Aquí les pongo el link al .pdf, así pueden bajarlo a sus máquinas...
Placa en pdf (http://rapidshare.com/files/75629129/Placa_CAN_ETH.pdf)
:D :D QUE HIJO DE POTTER!!!!!!!!!! :D :D
Marcos, es impresionante ese circuito! 8)
Felicitaciones por hacer andar algo asi....
(que lejos estoy!!!!!!!!!!!!!!! :shock:)
Ariel.
Buenas MGLSOFT!!!
1º- Lo primero es pedirte perdon porque ayer con las cosas del as prisas me equivoque con el tema delos PIC.
Si es cierto ayer me te dije lo del mcp2515, pero no se como cometí este error. Perdón :( . Los que tengo que de programar son los MCP25050 y los MCP25020. Esos si que hay que programarlos, y la gente de micro chip me dice que lo puedo hacer de la placa de desarrollo es la de los MCP250xx.
Con esta y el programa que me han dado los de micro chip (que se llama MCP250xx programer version 1.1) no soy capaz de programarlos.
Estos chip ahora mismo no les estoy dando uso por que no se como hacer ir, pero bueno espero que todo llegara.
2º- Lo segundo es que el PLC tiene CANopen. Te he dejado una foto para descargar. Si te interesa te puedo pasar mas informacion sobre el tema del PLC.
Cambiando de tercio....
Bueno lo que estoy haciendo con los otros son 18F2580 es intentar mandar un mensaje de uno al otro y por lo menos que se vean, que de momento no lo he conseguido. Por eso te pedí el esquema de tu placa de desarrollo para poder fabricarla y por lo menos tener claro que si no comunica es error de HW y no se SW.
Os pego aquí el código de programa muy básico a ver si alguien lo puede verificar y asegurarme que funciona correctamente y así por lo menos me podre centrar en donde tengo ahora mismo el error.
La comunicacion que pretendo mantener es que emita de momento el NODO1 y el NODO2 interprete lo que manda el NODO1
// *************** ESTO SERIA NODO1 que solo manda mensajes. El 18F2580_BASIC_CAN.hexCódigo: [Seleccionar]
unsigned short init, init_send, len, aa2;
unsigned char count, data[8];
long id;
unsigned short zr, cont, oldstate;
void main() {
// ******************** CONFIGURACION OSCILADOR INTERNO *******************//
// Con esta configuracion no sera necesario instalar oscilador externo, de //
// este modo ganaremos un par RA6 y RA7 I/O pag 27 manual 18F2580 //
OSCTUNE = 0x8F; // OSCILADOR ineterno a maxima frecuencia 8Mhz Pag 27
OSCCON = 0xFF; // Pag 30
// ******************* CONFIGUATACION DE LOS PUERTOS ****************//
// con el TRIS_ lo que decimos si el bit = 1 que es entrada y =0 que es salida
TRISA = 0x00;
ADCON0 = 0; // con esto digo q NO uso los conversores A/D pag 247 manual
ADCON1 = 0x0F; // y q I/O son digitales para A,B,C pag 248 manual del 18F2580
// OJO con la asignacion a los registros ADCON0 y ADCON1, si no la haces no
// funcionan como entradas digitales y lospulsadores RA0...RA3 no funcionan.
TRISB = 0X04; //Pin CAN TX lo congfiguro como digital OUT
LATC.F2 = 0;
//TRISB.F3 = 1; //Pin CAN RX lo congfiguro como digital INPUT
LATB.F3 =0;
TRISC = 0xFF;
// La configuracion de los puertos de SALIDA se realiza mediante la sentancia
// TRIS, pero ahora el acceso a estos puertos se realiza mediante la sentencia
// LATX. Siendo X el nombre del puerto en cuestion. OJO ESTO ES SOLO PARA LOS
// PUERTOS DE SALIDA OUTPUT. (Pag 130 del manual 18F2580)
LATA = 0;
// ******************* CONFIGURACION CAN BUS PARA 500.000 Kbs ***************//
init = 0;
init_send = 0;
aa2 = 0;
init_send = CAN_TX_PRIORITY_0 & // Form value to be used
CAN_TX_XTD_FRAME & // with CANSendMessage
CAN_TX_NO_RTR_FRAME;
init = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_VALID_XTD_MSG &
CAN_CONFIG_LINE_FILTER_OFF;
data[0] = 9;
// CANInitialize(SJW, BRP, PHSEG1, PHSEG2, PROPSEG, CAN_CONFIG_FLAGS);
CANInitialize(0,1,1,2,1,init); // initialize CAN
// CANSetOperationMode(mode, wait_flag);
CANSetOperationMode(CAN_MODE_CONFIG,0xFF); // Pasamos a modo configuracion
id = -1; // 0xFFFFFFFFFFFFFFFF
// Configuramos las mascaras con todo a 1, ya que id=(-1 q es lo mismo 0xfffffffffffff)
// CAN_CONFIG_XTD_MSG se refiere a CAN extendido
CANSetMask(CAN_MASK_B1,id,CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CANSetMask(CAN_MASK_B2,id,CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CANSetFilter(CAN_FILTER_B2_F3,3,CAN_CONFIG_XTD_MSG); // set id of filter B1_F1 to 3
CANSetOperationMode(CAN_MODE_NORMAL,0xFF); // set NORMAL mode
LATA = 0x0;
for(id=0; id<8;id++)
{
data[id]=0;
}
//CANWrite(id,data,1,aa1);
count=0;
id = 12111;
while (1) {
LATA.F1 = ~LATA.F1; // output second byte at portA
if(count==5)
{
data[0]= LATA.F0;
CANWrite(id, data, 8, init_send);
count=0;
LATA.F0 = ~LATA.F0;
}
Delay_ms(1000);
count++;
}
}//~!
//************************** EL NODO 2 solo los recibe. 18F2580_ESPEJO_CAN.hex ************************////Código: [Seleccionar]unsigned short aa, aa1, len, aa2;
unsigned char data[8];
long id;
unsigned short zr;
void main() {
// ******************** CONFIGURACION OSCILADOR INTERNO *******************//
// Con esta configuracion no sera necesario instalar oscilador externo, de //
// este modo ganaremos un par RA6 y RA7 I/O pag 27 manual 18F2580 //
OSCTUNE = 0x8F; // OSCILADOR ineterno a maxima frecuencia 8Mhz Pag 27
OSCCON = 0xFF; // Pag 30
// ******************* CONFIGUATACION DE LOS PUERTOS ****************//
// con el TRIS_ lo que decimos si el bit = 1 que es entrada y =0 que es salida
TRISA = 0x00;
ADCON0 = 0; // con esto digo q NO uso los conversores A/D pag 247 manual
ADCON1 = 0x0F; // y q I/O son digitales para A,B,C pag 248 manual del 18F2580
// OJO con la asignacion a los registros ADCON0 y ADCON1, si no la haces no
// funcionan como entradas digitales y lospulsadores RA0...RA3 no funcionan.
TRISB = 0X04; //Pin CAN TX lo congfiguro como digital OUT
LATC.F2 = 0;
//TRISB.F3 = 1; //Pin CAN RX lo congfiguro como digital INPUT
LATB.F3 =0;
aa = 0;
aa1 = 0;
aa2 = 0;
aa1 = CAN_TX_PRIORITY_0 & // Form value to be used
CAN_TX_XTD_FRAME & // with CANSendMessage
CAN_TX_NO_RTR_FRAME;
aa = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_VALID_XTD_MSG &
CAN_CONFIG_LINE_FILTER_OFF;
data[0] = 0;
//CANInitialize(1,1,3,3,1,aa); // initialize CAN
CANInitialize(0,1,1,2,1,aa); // initialize CAN
CANSetOperationMode(CAN_MODE_CONFIG,0xFF); // set CONFIGURATION mode
id = -1;
CANSetMask(CAN_MASK_B1,id,CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CANSetMask(CAN_MASK_B2,id,CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CANSetFilter(CAN_FILTER_B2_F3,12111,CAN_CONFIG_XTD_MSG); // set id of filter B1_F1 to 3
CANSetOperationMode(CAN_MODE_NORMAL,0xFF); // set NORMAL mode
//id = 3;
LATA.F5 = 1;
while (1) {
zr = CANRead(&id , data , &len, &aa2);
if ((id == 12111) && zr)
{
LATA.F0 = data[0];
Delay_ms(1000);
// output data at portC
}
else
{
LATA.F5 = ~LATA.F5;
Delay_ms(500);
}
}
}//~!
Este código es muy básico pero aun así no me funciona. Os he adjuntado directamente los ficheros .HEX por si alguien los puede probar. Aquí que ver que he configurado la velocidad del bus a 500.000 Kbs.
También fijaros en que no estoy usando cristal oscilador externo, estoy utilizando el oscilador interno del PIC que llega hasta 8Mhz.
Bueno de momento no os molesto mas con el tema....
Os agradezco el tiempo prestado y que paséis un buen día.
Un saludo
PERE.
PD: MGLSOFT muy bueno el esquema GRACIAS :-/ . Remitirme si puedes el diseño de las pistas de la placa para insolar (el fotolito de las pitas) si es que lo tienes claro. GRACIAS DE NEW.
Si es cierto ayer me te dije lo del mcp2515, pero no se como cometí este error. Perdón . Los que tengo que de programar son los MCP25050 y los MCP25020. Esos si que hay que programarlos, y la gente de micro chip me dice que lo puedo hacer de la placa de desarrollo es la de los MCP250xx.
Con esta y el programa que me han dado los de micro chip (que se llama MCP250xx programer version 1.1) no soy capaz de programarlos.
Lo segundo es que el PLC tiene CANopen. Te he dejado una foto para descargar. Si te interesa te puedo pasar mas informacion sobre el tema del PLC.
// ******************** CONFIGURACION OSCILADOR INTERNO *******************//
// Con esta configuracion no sera necesario instalar oscilador externo, de //
// este modo ganaremos un par RA6 y RA7 I/O pag 27 manual 18F2580 //
OSCTUNE = 0x8F; // OSCILADOR ineterno a maxima frecuencia 8Mhz Pag 27
OSCCON = 0xFF; // Pag 30
//CANInitialize(1,1,3,3,1,aa); // initialize CAN
CANInitialize(0,1,1,2,1,aa); // initialize CAN
MGLSOFT excelente trabajo. Una pregunta: ¿podrías poner una relación de los integrados utilizados y la utilidad de cada uno de ellos, con un pequeño dibujo de su conexión al bus o circuito?. Se que es mucho pedir pero seguro que nos aclararía a todos los integrados que son necesario.
Un saludo
// CANInitialize(SJW, BRP, PHSEG1, PHSEG2, [b]PROPSEG[/b], CAN_CONFIG_FLAGS);
CANInitialize(2,0,8,6,1,init); // initialize CAN
init = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_VALID_XTD_MSG &
CAN_CONFIG_LINE_FILTER_OFF;
Buenos días MGLSOFT!!!
Atendiendo a tus correcciones ya he cambiado el tema de los cristales de y los he puesto de 16Mhz.
Si que es cierto que retoque el código de MikroC en un interno desesperado por ver si era eso lo necesario para realizar la comunicación. Pero claro también es verdad que puse el resultado de la configuración que me proporciono el programa BIT Time Calculator. De todos modos he realizado un recalculo de los parámetros y os he adjuntado 3 reports en PDF, de varias configuraciones. 3 de ellas con 16 time quanta y una de ellas con 8 time quanta. Notar que en todas ellas le he dado preferencia o mas quantas a la PROPAGATION... ¿no se si esto es del todo correcto????
Ahora bien con estos ajustes que te da el Bit Time Calculatorl, se mas o menos donde se corresponden con la función de MikroC todos a falta de uno el "Propagation Delay" yo se lo asigno este valor al "PROSEG" ya que la llamada a la función es tal que así :Código: [Seleccionar]// CANInitialize(SJW, BRP, PHSEG1, PHSEG2, [b]PROPSEG[/b], CAN_CONFIG_FLAGS);
CANInitialize(2,0,8,6,1,init); // initialize CAN
init = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_VALID_XTD_MSG &
CAN_CONFIG_LINE_FILTER_OFF;
Buenas noches MGLSOFT!!!
Es que en España es de noche ja ja ja....
Ya he montado la nueva placa y lo único que me falta es el detalle de que el conflagración me hablas de un "H4 a CERO".
Pero no se a que te refieres :shock:.
Te importaría aclarármelo :).
Muchas GRACIAS :-/
Un saludo
PERE.
unsigned short init, init_send, len;
unsigned char count, data[8];
long id;
unsigned short zr;
void main() {
// ******************* CONFIGUATACION DE LOS PUERTOS ****************//
// con el TRIS_ lo que decimos si el bit = 1 que es entrada y =0 que es salida
TRISA = 0x00;
ADCON0 = 0; // con esto digo q NO uso los conversores A/D pag 247 manual
ADCON1 = 0x0F; // y q I/O son digitales para A,B,C pag 248 manual del 18F2580
// OJO con la asignacion a los registros ADCON0 y ADCON1, si no la haces no
// funcionan como entradas digitales y lospulsadores RA0...RA3 no funcionan.
TRISB = 0X04; //Pin CAN TX lo congfiguro como digital OUT
//TRISB.F3 = 1; //Pin CAN RX lo congfiguro como digital INPUT
LATB.F3 =0;
// La configuracion de los puertos de SALIDA se realiza mediante la sentancia
// TRIS, pero ahora el acceso a estos puertos se realiza mediante la sentencia
// LATX. Siendo X el nombre del puerto en cuestion. OJO ESTO ES SOLO PARA LOS
// PUERTOS DE SALIDA OUTPUT. (Pag 130 del manual 18F2580)
// ******************* CONFIGURACION CAN BUS PARA 500.000 Kbs ***************//
init = 0;
init_send = 0;
init_send = CAN_TX_PRIORITY_0 & // Form value to be used
CAN_TX_XTD_FRAME & // with CANSendMessage
CAN_TX_NO_RTR_FRAME;
init = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_VALID_XTD_MSG &
CAN_CONFIG_LINE_FILTER_OFF;
data[0] = 0;
// CANInitialize(SJW, BRP, PHSEG1, PHSEG2, PROPSEG, CAN_CONFIG_FLAGS);
CANInitialize(1,0,8,6,1,init); // initialize CAN
// CANSetOperationMode(mode, wait_flag);
CANSetOperationMode(CAN_MODE_CONFIG,0xFF); // Pasamos a modo configuracion
id = -1; // 0xFFFFFFFFFFFFFFFF
// Configuramos las mascaras con todo a 1, ya que id=(-1 q es lo mismo 0xfffffffffffff)
// CAN_CONFIG_XTD_MSG se refiere a CAN extendido
CANSetMask(CAN_MASK_B1,id,CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CANSetMask(CAN_MASK_B2,id,CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CANSetFilter(CAN_FILTER_B2_F3,3,CAN_CONFIG_XTD_MSG); // set id of filter B1_F1 to 3
CANSetOperationMode(CAN_MODE_NORMAL,0xFF); // set NORMAL mode
for(id=0; id<8;id++)
{
data[id]=id;
}
LATA = 0;
LATA.F3 = 1;
count=0;
id = 12111;
while (1) {
LATA.F3 = ~LATA.F3; // output second byte at portA
if(count==5)
{
data[0]= LATA.F0;
CANWrite(id, data, 8, init_send);
count=0;
LATA.F0= ~LATA.F0;
}
Delay_ms(1000);
count++;
}
}
unsigned short init,init_send, len, aa2;
unsigned char data[8];
long id;
unsigned short zr;
void main() {
// ******************* CONFIGUATACION DE LOS PUERTOS ****************//
// con el TRIS_ lo que decimos si el bit = 1 que es entrada y =0 que es salida
TRISA = 0x00;
ADCON0 = 0; // con esto digo q NO uso los conversores A/D pag 247 manual
ADCON1 = 0x0F; // y q I/O son digitales para A,B,C pag 248 manual del 18F2580
// OJO con la asignacion a los registros ADCON0 y ADCON1, si no la haces no
// funcionan como entradas digitales y lospulsadores RA0...RA3 no funcionan.
TRISB = 0X04; //Pin CAN TX lo congfiguro como digital OUT
//TRISB.F3 = 1; //Pin CAN RX lo congfiguro como digital INPUT
LATB.F3 =0;
init = 0;
init_send = 0;
init_send = CAN_TX_PRIORITY_0 & // Form value to be used
CAN_TX_XTD_FRAME & // with CANSendMessage
CAN_TX_NO_RTR_FRAME;
init = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_VALID_XTD_MSG &
CAN_CONFIG_LINE_FILTER_OFF;
data[0] = 0;
// CANInitialize(SJW, BRP, PHSEG1, PHSEG2, PROPSEG, CAN_CONFIG_FLAGS);
CANInitialize(1,0,8,6,1,init); // initialize CAN
CANSetOperationMode(CAN_MODE_CONFIG,0xFF); // set CONFIGURATION mode
id = -1;
CANSetMask(CAN_MASK_B1,id,CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CANSetMask(CAN_MASK_B2,id,CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CANSetFilter(CAN_FILTER_B2_F3,12111,CAN_CONFIG_XTD_MSG); // set id of filter B1_F1 to 3
CANSetOperationMode(CAN_MODE_NORMAL,0xFF); // set NORMAL mode
//id = 3;
LATA=0;
LATA.F3 = 1;
while (1) {
zr = CANRead(&id , data , &len, &aa2);
if ((id == 12111) && zr)
{
LATA.F0 = data[0];
Delay_ms(1000);
// output data at portC
}
else
{
LATA.F3 = ~LATA.F3;
Delay_ms(500);
}
}
}//~!
#include "C:\Documents and Settings\Administrador\Escritorio\kk\main2.h"
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7, stream=outstream)
#define CAN_USE_EXTENDED_ID FALSE
#include <can-18xxx8.c>
void main()
{
int32 can_id;
int can_data[8],i;
int can_length, counter;
struct rx_stat rxstat;
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF|ADC_TAD_MUL_0);
setup_spi(SPI_SS_DISABLED);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
setup_vref(FALSE);
//Setup_Oscillator parameter not selected from Intr Oscillotar Config tab
// TODO: USER CODE!!
can_init();
can_set_mode(CAN_OP_CONFIG);
// configuracion 50kbs q=8 62.5% oscilador 16MHZ
BRGCON1=0x53;
BRGCON2=0x90;
BRGCON3=0x02;
/*
// configuracion 125kbs q=8 62.5% oscilador 16MHZ
BRGCON1=0x07;
BRGCON2=0x90;
BRGCON3=0x02;
*/
/*
// configuracion 250kbs q=8 62.5% oscilador 16MHZ
BRGCON1=0x03;
BRGCON2=0x90;
BRGCON3=0x02;
*/
can_set_mode(CAN_OP_NORMAL);
counter = 0;
puts("Starting");
can_data[0] = 0x55;
can_data[1] = 0x99;
delay_ms(10000);
if(can_putd(0x111, can_data, 2, 3, 0,0))
{
puts("tx ok");
delay_ms(10000);
}
can_data[0] = 0x66;
can_data[1] = 0x47;
if(can_putd(0x222, can_data, 2, 0, 0, 0))
{
puts("tx ok");
delay_ms(10000);
}
if ( can_tbe())
{
can_data[0] = 0x45;
can_data[1] = 0x36;
if (can_putd(0x123, can_data, 2,3,0,0)) { //success, a transmit buffer was open
fprintf(outstream,"OKOK ");
for (i=0;i<2;i++) {
fprintf(outstream,"%X ",can_data[i]);
}
fprintf(outstream,"\r\n");
}
else { //fail, no transmit buffer was open
fprintf(outstream,"\r\nFAIL on PUTD\r\n");
}
}
}
#include "C:\Documents and Settings\Administrador\Escritorio\kk\main2.h"
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7, stream=outstream)
#define CAN_USE_EXTENDED_ID FALSE
#include <can-18xxx8.c>
void main()
{
int32 can_id;
int can_data[8],i;
int can_length, counter;
struct rx_stat rxstat;
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF|ADC_TAD_MUL_0);
setup_spi(SPI_SS_DISABLED);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
setup_vref(FALSE);
//Setup_Oscillator parameter not selected from Intr Oscillotar Config tab
// TODO: USER CODE!!
can_init();
can_set_mode(CAN_OP_CONFIG);
// configuracion 50kbs q=8 62.5% oscilador 16MHZ
/*
BRGCON1=0x53;
BRGCON2=0x90;
BRGCON3=0x02;
*/
// configuracion 125kbs q=8 62.5% oscilador 16MHZ
BRGCON1=0x07;
BRGCON2=0x90;
BRGCON3=0x02;
/*
// configuracion 250kbs q=8 62.5% oscilador 16MHZ
BRGCON1=0x03;
BRGCON2=0x90;
BRGCON3=0x02;
*/
can_set_mode(CAN_OP_NORMAL);
counter = 0;
puts("Starting");
can_data[0] = 0x55;
can_data[1] = 0x99;
delay_ms(10000);
if(can_putd(0x111, can_data, 2, 3, 0,0))
{
puts("tx ok");
delay_ms(10000);
}
can_data[0] = 0x66;
can_data[1] = 0x47;
if(can_putd(0x222, can_data, 2, 0, 0, 0))
{
puts("tx ok");
delay_ms(10000);
}
if ( can_tbe())
{
can_data[0] = 0x45;
can_data[1] = 0x36;
if (can_putd(0x123, can_data, 2,3,0,0)) { //success, a transmit buffer was open
fprintf(outstream,"OKOK ");
for (i=0;i<2;i++) {
fprintf(outstream,"%X ",can_data[i]);
}
fprintf(outstream,"\r\n");
}
else { //fail, no transmit buffer was open
fprintf(outstream,"\r\nFAIL on PUTD\r\n");
}
}
}
// conflagración 50kbs q=8 62.5% oscilador 16MHZ
/*
BRGCON1=0x53;
BRGCON2=0x90;
BRGCON3=0x02;
*/
// conflagración 125kbs q=8 62.5% oscilador 16MHZ
BRGCON1=0x07;
BRGCON2=0x90;
BRGCON3=0x02;
/*
// conflagración 250kbs q=8 62.5% oscilador 16MHZ
BRGCON1=0x03;
BRGCON2=0x90;
BRGCON3=0x02;
#include "C:\Documents and Settings\Administrador\Escritorio\kk\main2.h"
(can_putd(0x111, can_data, 2, 3, 0,0))
(can_putd(0x111, can_data, 2, 3, 1,0))
#define CAN_USE_EXTENDED_ID FALSE
#define CAN_USE_EXTENDED_ID TRUE
Contexto del taller.pdf (201.23 KB - descargado 5 veces.)
Buenos días MGLSOFT!!!!
Esto sigue sin ir y yo soy un tío muy empeñado... Por lo tanto no pienso rendirme.
El correo de hoy es ya el de vamos a sincronizarnos para dar solución al asunto.
Te propongo una cosa, como no se si el HW mio funciona correctamente y tu tarjeta de desarrollo parece que si lo va a soportar, te planteo lo siguiente:
- Manda un privado con tu dirección personal (la de tu casa por ejemplo), y cuando la tenga te remito un par de PIC 18F2580. Así tendré una referencia segura y fiable del porque esto no funciona. ¿¿¿Vamos si no te importa???
Espero tu respuesta
Un saludo
PERE.
PD: Gracias por tu atención y apoyo.
También estoy trabajando en otra en SMD con el 18F4580 y 18F2580 que estoy a la espera de material. Esta se prototipo definitivo para el tema de la domotización de la casa ya que el tamaño en este caso ya es muy importante....
> Bienvenido al foro Electrolinux !!
> Me alegra mucho que el tema te sirva, esa es la idea !!
> Como a vos te ha pasado, no hay mucha información en Español acerca del BUS CAN, por eso abrí este tema, para que nos
> ayudemos entre todos.
> Sera bienvenida tu experiencia con los AVR, sientete en libertad de postear aquí tus avances y dudas, y todos
> aprenderemos juntos mientras nos ayudamos mutuamente.
> Te recomiendo leer las reglas del foro, así tu comportamiento dentro del mismo será acorde a ellas...
> Nuevamente te deseo una larga estadía dentro de este foro maravilloso.
MGLSOFT :mrgreen:
Buenos días compañeros del foro!!! :mrgreen:Bueno, si de corregir se trata!! :) :)
Como os comente la semana pasada, he estado trabajando en una placa con 18F4580 en SMD con CANBUS y 3 PORT de E/S.
Aquí os dejo la documentación para que le echéis un vistazo y me comentáis cualquier tipo de error o anomalía.
MGLSOFT ya comentamos....espero vuestras aportaciones y correcciones :-/
Un saludo
PERE.
Estimados amigos:
Bueno cuento un poco lo que estoy desarrollando, es una placa que tiene un AVR-ATmega16 y otra con en ATmega8, ambas trabajando (o intentando trabajar) con el MCP2515 y el PCA82C250, aun estoy en la etapa de desarrollo del codigo. Adjunto una foto de la PCB.
Ambos uC-AVR los programa en lenguaje 'C' con el compiolador AVR-GCC-4.1.0, trabajo habitualmente sobre maquinas Unix (Debian, FreeBSD) y todo lo hago desde este S.O., desde el diseNo del esquematico hasta el PCB, la programacion y su grabacion en la Flash del Microcontrolador. Les dejo este link para que lean un articulo que publica respecto de este tema (http://www.eldemonio.org/documentos/020507184907.html).
Los pasos que he seguido en el codigo son los siguiente:
(1) Inicializacion de la interfaz SPI del controlador.
(2) Funciones de acceso a los registros del MCP2515 de read y write.
(3) Funciones de imprimir los registros del MCP2515 para debug a la puerta serial del AVR.
(4) Inicializacion del MCP2515.
Lo que me queda es ahora trabajar en las rutinas de envio y recepcionar mensajes desde el MCP2515. Tengo un primer hacercamiento que aun no me ha funcionado.
Bueno eso por el momento, si alguien tiene algunas rutinas de envio y recepcion de mensajes que pudiese compartir, serial genial poder verlas, aunque haya que cambiarlas, pero al menos ya es una idea de como tomar el desarrollo.
Saludos a todos.
Muy buen trabajo Electrolinux!!
Te ha quedado muy profesional!!
Felicitaciones!!
Respecto a la comunicacion con el MCP2515, el creador del software CanKing (buscalo en google) tiene un software en C de PC para establecer la comunicacion spi y cargar los datos, configurar y utilizarlo.
En su web esta todo el codigo fuente, yo no te lo dije, pero me pasaria por alli a ver, je..je
Para que podamos ayudarte mejor te pediria si puedes poner la parte del esquematico donde conectas el AVR > MCP2515 > 82C250...
Eso si no te molesta y puedes hacerlo.
Interesante el proyecto de balanza inteligente, puedes contarnos mas ?? , por curiosidad solamente... :mrgreen: :mrgreen:
El lenguaje C, nacido en un laboratorio, es el lenguaje de computacion mas portable que existe...
Si tienes el fuente y un compilador que funcione sobre Linux (el mismo Linux esta escrito en C) podras utilizarlo tal y como viene sin inconvenientes. :lol: :lol:
Te hago una correccion. :lol:
El lenguaje C, nacido en un laboratorio, es el lenguaje de computacion mas portable que existe...
Si tienes el fuente y un compilador que funcione sobre Linux (el mismo Linux esta escrito en C) podras utilizarlo tal y como viene sin inconvenientes. :lol: :lol:
Respecto al proyecto, era solo curiosidad, no hay problema... :mrgreen: :mrgreen:
Lo podras bajar de aqui (piden registro).
http://www.kvaser.com/cgi-bin/sendfile.cgi?dir=files&file=mcp2510-pc.txt (http://www.kvaser.com/cgi-bin/sendfile.cgi?dir=files&file=mcp2510-pc.txt)
y de aqui otro ejemplo...
http://www.kvaser.com/cgi-bin/sendfile.cgi?dir=files&file=mcp2510.txt (http://www.kvaser.com/cgi-bin/sendfile.cgi?dir=files&file=mcp2510.txt)
Lo podras bajar de aqui (piden registro).
http://www.kvaser.com/cgi-bin/sendfile.cgi?dir=files&file=mcp2510-pc.txt (http://www.kvaser.com/cgi-bin/sendfile.cgi?dir=files&file=mcp2510-pc.txt)
y de aqui otro ejemplo...
http://www.kvaser.com/cgi-bin/sendfile.cgi?dir=files&file=mcp2510.txt (http://www.kvaser.com/cgi-bin/sendfile.cgi?dir=files&file=mcp2510.txt)
Gracias MGLSOFT.... estoy haciendo el esquematico en forma decente para ponerlo en el foro.
Saludos
Te hago una correccion. :lol:
El lenguaje C, nacido en un laboratorio, es el lenguaje de computacion mas portable que existe...
Si y no... si el lenguaje 'C' es estandart POSIX, si lo es, pero hay cada fabricante que le ponen 'C' a algunas cosas que son solo entendidas por el compilador especifico y eso NO tiene nada de PORTABLE.
Gracias Maunix, por tus aclaraciones ante mi tremenda ignorancia sobre Linux.
intentaba darle al amigo una herramienta de software que le permita probar la conexion y aprender de la configuracion sin adentrarme en el ambiente de desarrollo de AVR, del cual soy tremendamente ignorante.
El sistema operativo (si lo hubiere) también debe cumplir con el estándar... no solo el compilador.
Gracias Maunix, por tus aclaraciones ante mi tremenda ignorancia sobre Linux.
intentaba darle al amigo una herramienta de software que le permita probar la conexion y aprender de la configuracion sin adentrarme en el ambiente de desarrollo de AVR, del cual soy tremendamente ignorante.Si leiste el link que deje sobre sistemas embebidos en FreeBSD... ya sabes algo por donde partir :-)
Ahora lo que voy a hacer para ayudarlo es pasarle un codigo para PIC y tratar juntos de adaptarlo a sus necesidades... :mrgreen:
En el caso de Linux y BSD (FreeBSD, NetBSD, OpenBSD), siempre lo son, cumplen fielmente el standart POSIX, por eso ni siquiera lo mencione asumi eso como sabido, ya que es asi de base siempre y todo el codigo Open-Source lo es.
todo el codigo Open-Source lo es.Disciento, yo puedo hacer un código "open source" de un led que parpadee hecho en assembly y que no cumpla con ningún estándar... y como ese miles de ejemplos. Una cosa no implica la otra.
Si pones el esquematico escaneado de uno hecho a mano alzada, si se entiende es lo mismo, la intencion es ayudarte, no complicarte.
respecto al codigo, dame tu mail por el privado y te paso un ejemplo hecho en lenguaje C para los PICs, luego seguramente tu mismo podras descartar lo que sirve y lo que no para usarlo en AVR, disculpa que no se nada sobre AVR para ayudarte mejor... :mrgreen: :mrgreen:
electrolinux lo aclaré en el contexto del sentido genérico de la portabilidad de un código entre plataformas, cualquiera sea. Este foro es visitado por mucha gente y conviene aclarar algunas cosas, nada más, no fue una corrección sino un agregado.
Disciento, yo puedo hacer un código "open source" de un led que parpadee hecho en assembly y que no cumpla con ningún estándar... y como ese miles de ejemplos. Una cosa no implica la otra.
Cierto lo que dices, pero eso un caso especial el que planteas, cuando uno hace un proyecto Open-Source hay ciertos estandares que cumplir y es a eso a lo que me referia, hay normas y procedmientos en ello. Pero la idea es simplificarle la vida a la gento no al reves. :)
No lo quiero hacer más offtopic al hilo pero me parece que estás mezclando el uso y buenas costumbres, las sugerencias de cómo hacer un código a la filosofía de open source en sí. Open source es lo que uno haga y quiera liberar el código para que otro lo use, modifique , etc. Si está documentado, fácil o no de entender, eso es otro tema. Eso lo hará más o menos popular, lo hará más masivo, hará que la gente se sienta más interesado en él, etc.
Te doy un ejemplo -> KTechLab, lo comenzó alguien porque quería aprender C++, está en pañales, de hecho sigo su lista de correo, su código no está muy documentado y sin embargo es open source!
Otro ejemplo -> El proyecto GnuPIc y sus software asociados.
Bueno, espero que no nos vayamos nuevamente de tema en este hilo... :mrgreen: :mrgreen:
Veo que el software libre tambien crea polemicas, de todos modos cada uno elige con que trabaja, y como o cuanto reniega para cumplir su objetivo.
Eso debe respetarse.
Volviendo al tema del hilo, la mayor parte del codigo que te envie esta relacionado con los PICs, pero las funciones de inicializacion y librerias del MCP2510 (antecesor del MCP2515) seguramente con muy pocos cambios te serviran en tu software C.Los imprimi y los estoy mirando detenidamente.
Podras enviarme el codigo que estas utilizando en C para el AVR??
Un poco para aprender y otro para ayudar a adaptar estas rutinas a tus AVR, de paso te quedan las librerias.
No se si Maunix o Pikman u otros trabajaron en AVR, pero si leen el hilo los conmino a ayudar a nuestro amigo ElectroLinux... :mrgreen: :mrgreen:
Los archivos siguientes:
main.c -> programa principal
mcp2515_tool (extension C y H)-> definiciones de funciones basicas de acceso al mcp2515 que estan funcionales
No se pueden leer bien con el block de notas, estan llenos de espacios y caracteres raros.
El resto se leen perfectamente, podras limpiar y pasar nuevamente esos tres archivos??
Saludos a todos, quisiera hacerles una consulta: quiero comunicar varios pic's entre si en modo multimaestro, no puedo usar el MCP2515 u otro parecido porque por aqui dificil encontrar esos componentes, podria usar el bus I2C en modo multimaestro o hay otro protocolo que me recomienden?
He usado el I2C pero nunca en modo multimaestro, y recien he leido que su arbitraje funciona practicamente igual que el del bus CAN (gana el bus el que hace prevalecer su "0" frente a otro que envia un "1" en dicho instante). Por ello por ahora apuntaré a usar el I2C ya que con este arbitraje aseguraria que ningún pic se cruce con otro y hasta tal vez implemente el tratamiento de errores que tiene el bus CAN por si algún nodo comeinza a actuar erroneamente y asi no perjudique a los demas.
Quisiera escuchar sus opiniones y sugerencias o si hay otra manera mas practica y eficiente de evitar colisiones en modos multimaestros. Gracias.
Javicho.
Saludos a todos, quisiera hacerles una consulta: quiero comunicar varios pic's entre si en modo multimaestro, no puedo usar el MCP2515 u otro parecido porque por aqui dificil encontrar esos componentes, podria usar el bus I2C en modo multimaestro o hay otro protocolo que me recomienden?
He usado el I2C pero nunca en modo multimaestro, y recien he leido que su arbitraje funciona practicamente igual que el del bus CAN (gana el bus el que hace prevalecer su "0" frente a otro que envia un "1" en dicho instante). Por ello por ahora apuntaré a usar el I2C ya que con este arbitraje aseguraria que ningún pic se cruce con otro y hasta tal vez implemente el tratamiento de errores que tiene el bus CAN por si algún nodo comeinza a actuar erroneamente y asi no perjudique a los demas.
Quisiera escuchar sus opiniones y sugerencias o si hay otra manera mas practica y eficiente de evitar colisiones en modos multimaestros. Gracias.
Javicho.
Ahora estoy viendo los modos de operacion del MCP2515... bueno al menos algo de avance estoy obteniendo, de a poco.
Respecto del codigo que me enviaste MGLSOFT.. entoy analizandolo y ciertas cosas aun no entiendo, por ejemplo en la funcion can_init() llamam a la funcion can_set_modo(CAN_OP_NORMAL);, la cual no me queda muy claro lo que hace exactamente, ya que lee el registro CANCTRL que lo maneja con una estructura... pero no es muy evidente como manejan los bits de ese registro.
Saludos
Si miras en el archivo Can-mcp2510.h veras que enumera los modos de operacion asi:Código: C
enum CAN_OP_MODE {CAN_OP_CONFIG=4, CAN_OP_LISTEN=3, CAN_OP_LOOPBACK=2, CAN_OP_SLEEP=1, CAN_OP_NORMAL=0};
Si lees la hoja de datos del MCP2515, encontraras que existen esos modos de operacion.
Los mas utilizados son el Normal (logicamente, sino no andarian los proyectos) el modo Loopback (permite hacer un envio y recibir lo mismo que envias, para testear tu software, es recomendable ya que alli ya sabes si funciona lo que haces sin tener un sniffer o un Bus armado) y el modo Listen, que aun no entiendo bien para que sirve...
En realidad no hay mucha ciencia, es una placa de una sola faz, bastante rebuscada porque esta hecha por un Neofito como yo, pero si te sirve, aqui esta... :mrgreen: :mrgreen:
Placa Entrenador CAN (http://rapidshare.com/files/88049847/Preview_ETH_CAN.pdf)
Prueba ahora, por las dudas tambien lo subi comprimido (lleva CRC adentro) a ver si anda... :mrgreen:En realidad no hay mucha ciencia, es una placa de una sola faz, bastante rebuscada porque esta hecha por un Neofito como yo, pero si te sirve, aqui esta... :mrgreen: :mrgreen:
Placa Entrenador CAN (http://rapidshare.com/files/88049847/Preview_ETH_CAN.pdf)
Estimado amigo... el PDF al parecer esta erroneo, no lo pude habrir con Acroread, xpdf y kpdf, da un error de "damaged" o "maltrecho"... :?
Saludos
Prestar atencion a los puentes, que son varios, producto de mi alta ineficiencia para hacer este trabajo...hombre pero te ha salido un trabajo en esencia muy bueno, fantastico diria yo, felicitaciones por la dediocación y por ser tan buena persona y compartirlo con nosostros sin ningun interés, eres un IDOLO!!! :mrgreen:
[..........]
Respecto a publicarlo, si miras el comienzo del hilo, me comprometi a dejar todo lo que se y/o aprenda en el hilo.
Ayudandonos entre nosotros aprenderemos mas, cometeremos menos errores y lo que es mejor, aprenderemos mas rapido la solucion correcta, porque hay mas masa cerebral al servicio de obtener un resultado.
Bueno, nos dejaste tarea para leer un rato!! :D
Lo vemos y empezamos a comentar...
Estoy en el proyecto de armarme la interfase CAN para el CanKing, una vez tenga algo mas concreto, lo posteo aqui... :mrgreen:
Primo impianto domestico con Can-Bus(http://www.elettronicain.it/Main/riviste/imgSommario/VELBUS.jpg)
Iniziamo ad utilizzare i moduli Velbus realizzando un piccolo impianto domestico che ci darà la possibilità di approfondire la conoscenza dei vari moduli e del sistema di programmazione manuale.
Me refería a esto que aparece en el número 116 y siguientes:CitarPrimo impianto domestico con Can-Bus(http://www.elettronicain.it/Main/riviste/imgSommario/VELBUS.jpg)
Iniziamo ad utilizzare i moduli Velbus realizzando un piccolo impianto domestico che ci darà la possibilità di approfondire la conoscenza dei vari moduli e del sistema di programmazione manuale.
Que está basado en el velbus de velleman http://www.vellemanprojects.com/be/en/product/list/?id=361192
Bienvenido al clan !!
Puedes reemplazar un PIC18F2580 por PIC18F258, son compatibles pin a pin y la diferencia (asi lo tengo entendido) es que el 2580 implementa Extended CAN.Hmm tampoco se encuentra disponible :(
Para el uso que les damos aqui es igual uno que otro, la otra diferencia entiendo es que tiene mas memoria flash y de datos...
Cuanto sale el AVR + el MCP2515 ??
En el PIC18F2580 los tienes a ambos juntos en un solo circuito integrado !! :mrgreen: :mrgreen:
Hola Electrolinux!!
Seguramente si lo que quieres es armar un sniffer, puedo ofrecerte la programacion para hacerlo a traves de un PIC16F876 Mismo pinout del PIC18F2580 pero no tiene CAN.
En este caso iria acompañado de un MCP2515, que tu si tienes.
Averigua alli si consigues el PIC16F876 para cristal de 20 Mhz, a ver si va!!
Si lo consigues y el precio no es ofensivo para tus deseos de gastar, podremos desarrollar un sniffer que a todos nos sirva, te parece bien??Me parece perfecto, ya que un sniffer lo considero una muy buena herramienta.
Luego no importaria que gama de micros usemos cada uno, los mensajes los veriamos todos por igual... :mrgreen:Si exacto...
Yo tengo PIC18F252, con ese podemos desarrollar el sniffer con el 2515 !!Tu mandas en esto amigo... te hera caso en lo que me indiques :)
Lo hariamos al hardware de tal forma que pueda ser usado con el PIC18F2580 tambien, haciendo dos versiones de firmware, por supuesto!!Ok me parece perfecto.
Te parece bien asi?? :lol: :lol:Genial...
Si tienes un esquematico de tu programador, veriamos si adaptandolo al software del winpic pudieramos manejarlo, en todo caso consulto al maestro Sisco... :mrgreen: :mrgreen:
Le envie un privado al maestro Sisco, a ver si sabe si es posible que se grabe un PIC con tu hardware...esperemos pueda contestarnos...
pasanos el esquema y lo miramos electrolinux .
Lo podrias adaptar pero le falta una salida para controlar los 13v de Vpp que necesitan los pics .
Y para eso te recomiendo te hagas uno completo para pic y no modificar este.
Señor DIOS, podras tu saber quien hizo el mundo en 7 dias???
Era broma... Sisco es el genio de los programadores en este foro, pero es el tipo de mas bajo perfil y colaborador que hay por este lugar...Perfecto... no tenia idea, lo siento.
Pero para que no tengas tantos problemas para llegar a buen fin, te ofrezco programarte el micro aqui y luego te lo envio (eso si, por cobrar alli) a Chile.Ok...no hay problema, te lo agradeceria, una de las formas que ha resultado bien, es por correo ordinario en un buen embalaje pequeño, ya lo he probado de esa forma con proveedores de chips... Atmel :) y funciona super bien.
En ese caso te pondria un MCP2515 y el PIC16F876, que tengo varios...
Ya arranque con el esquematico de la placa del Sniffer, voy a dejar la posibilidad de usarlo con el PIC reportando al puerto serie, pero tambien poder utilizarlo conectado por el puerto paralelo al CanKing...Creo que mientras mas funcionalidades tenga una placa mejor...
Que opinan, sera util asi??
Muy bueno Ricardo!!
Yo lo habia revisado, pero no vi que usabas el PCA82C250, tal vez por prestarle mas atencion a la parte del conexionado con el MCP2515...
Segun lei el 82C250 (verificalo, tal vez me confunda por otro) necesita una resistencia de Pull-Up o de Pull-Down en una de sus pines de comunicacion con el micro, cosa que el transceiver CAN de Microchip no necesita, esto lo lei en el foro de CCS y realmente el de Microchip lo trae interno, por eso no se ve en los circuitos.
este es un tema que yo me olvide de dibujar en mis circuitos a pesar que lo conozco, pero no es menos importante, ya que la comunicacion no se realiza...
Problem:
If i connect my board (CAN-L/H, VSS, VDD) to the CCS test board using CAN-H and CAN-L (of the MCP2551), i am not able to establish a functioning connection.
If i don?t use the MCP2551 and wire directly from the TX and RX pins of the uC to the TX and RX pins of the CCS-CAN test board, then everything works fine....
As far as i know the PCA82C251 and MCP2551 should work together - but they don?t ?
I checked the connections and soldering of the MCP2551, seems to be fine. I also get an output out of the MCP2551.
Is there enything else i have to keep in mind ?!?
The PCA82C251 may not have built-in pullups
Tengo que configurar, la velocidad del puerto serie, que tengo que poner la que el propio dongle me indica con un codigo de parpadeos nada más ser conectado, inicialmente es de 57600 baudios(3 parpadeos), pero no sé que tengo que poner en Can bit rate, como se cual es esta velocidad?.
Sn[CR] Setup with standard CAN bit-rates where n is 0-8.
This command is only active if the CAN channel is closed.
(V1010)
S0 Setup 10Kbit
S1 Setup 20Kbit
S2 Setup 50Kbit
S3 Setup 100Kbit
S4 Setup 125Kbit
S5 Setup 250Kbit
S6 Setup 500Kbit
S7 Setup 800Kbit
S8 Setup 1Mbit
Example: S4[CR]
Setup CAN to 125Kbit.
Returns: CR (Ascii 13) for OK or BELL (Ascii 7) for ERROR.
En que lenguaje vas a programar o ya programas?
No lo has explicado, pero supongo que los blancos también son controlados por otro PIC, ¿no?
Hola muchachos:
Yo también estoy comenzando mis experimentos con el protocolo can.
Y por supuesto al ser novato estoy empezando a experimentar algunas dudas:
uno) cuando uno implementa un circuito con un micro controlador que tiene bus can se puede usar el transeptor 2551.
Dos) cuando el circuito está implementado con un micro controlador que no contiene bus can en ese caso se utiliza otro tipo de transeptor por ejemplo el 2510 (u otros).
tres) el otro circuito es muy similar solo que no tiene entrada a la pc.
Por el momento he implementado dos circuitos uno será el transmisor y otro será el receptor con el micro controlador pic 18 F. 2580; aquí les adjunto por favor corríjanme si he cometido algún error.
Desde ya muchas gracias.
Pedro Córdoba Argentina
Buenas noches compañeros!!!! :-/
He estado un poco ausente por que tengo varias cosas en marcha y no tengo tiempo para todo.
En primer lugar comunicaros que el SNIFFER no lo tengo aun operativo (porque no he tenido tiempo de montarlo...). Lo haré en breve y os comento.
En segundo lugar y visto que se que hay gente que tiene dificultades para la construcción de las placas de circuito impreso a 2 caras en SMD, os he preparado un nodo genérico de CANBUS súper reducido que os permitirá su construcción con placas a una sola cara y con componentes DIL.
Este placa no está probada. Pero he seguido el mismo esquema que en las los entrenadores (que os remití en el pasado) que funcionan a las 1000 maravillas a todas las velocidades. Luego doy por bueno y estoy seguro que el resultado será el mismo.
Esta vez me lo he currado un poco más y he añadido el tema de la lista de los componentes y en la vista de placa lado componentes he puesto el valor de los mismos.
Fijaos que hay que realizar unos puentes ya que al poner todas las pistas en una cara la cosa se ha complicado mucho, y también esto es debido a que la placa solo mide 60mm*40mm. He dejado también en este prototipo una borna AUX que no va conectada a ningún sitio para poder realizar aquello que os comente de la conexión CANBUS en estrella (en estrella desde el punto de vista óptico, no nos confundamos)...
Bueno a lo que vamos....
El archivo RAR contiene:
1- Lista de componentes TXT
2- Lado pistas listo imprimir en un fotolito y posteriormente insolar... PDF
3- Lado componentes con sus valores y posición. PDF
4- Puentes necesarios que no he sido capaz de poner en la placa directos..... Pondremos unos hilitos ja ja ja PDF
5- Esquema eléctrico.... Muy importante ya que como el 18F2580 el puerto A solo tiene disponible para I/O del pin 0...5 lo he completado con los pines del puerto B 0 y 4 (si hay dudas mirar el esquema eléctrico). El puerto C esta completo del 0...7. PDF
6- Vista 3D del circuito. JPG
Después de ver todo esto, podréis ver que lo que he construido es un MICRO nodo CANBUS, con jumper y su resistencia terminal de 120 ohm para nodos fianles del BUS, y dos puertos de 8 I/O cada uno (total 16 I/O)... Creo que no está nada mal.
Espero que os guste y que os sea de ayuda.... ya sabéis que como siempre para cualquier tipo de consulta o duda os ponéis en contacto y comentamos... También si veis que se puede mejorar no dudéis en comentarlo.
Un saludo para todos
PERE. :mrgreen:
PD:MGLSOFT estamos en contacto y comentamos que tal lo has visto.... sigo currando. :-)
Porque no subes el codigo modificado del emisor y receptor aqui, a ver si puedo probartelos.
Me parece buena idea que pruebes el codigo de Mikroe en las placas, asi podras determinar si funciona correcto antes de seguir.
Como andás allí con la provisión de yerba mate??
Podríamos cambiarte yerba por PICs... :D :D
Muy buena!!
Un poco de envidia (de la sana) por el manejo con SMD...
La mia esta casi armada ya, por ley de Murphy me olvide el regulador y otras pequeñeces de pedirlos.
La puse en una caja bastante dicharachera, ya pondre fotos por aqui, si es posible mostrandola encendida, que por ahora no puedo hacerlo..
solo estaba contemplando la posibilidad de que se envie una cadena de caracteres a travez del bus , si pudieras poner solo esa parte de ejemplo nada mas, por supuesto seria y de hecho es ma comodo que se detecte un evento y el propio nodo imprima en su diplay algun mensaje "X", solo era para contemplar distintos caso , en este caso mi duda se presento en como enviar una cadena de carateres a travez del nodo y que se imprima en el display del nodo que recibio esa cadena por supuesto intervendran el can_getd y el can_putd.
Antes de empezar con esto ya me surgio a primera duda: me equivoque al pedir los Samples y me llegaron el pic18f458 y el pic18Lf458 Hay alguna diferencia substancial¿?¿ he buscado informacion en el datasheet peor no he visto lo que buscaba.
discupen mi ignorancia pero me gustaria saber para que sirve el sniffer can?¿ sirve para rastrear las tramas¿?puedo utilizar el esquematico que han colgado en el foro como nodo primcipal?
Hola MGLSOFT:
Mira con 8 caracteres seria mas que suficiente , por ej 'E'N'C'I'E'N'D'E' que tiene 7 caracteres
Saludos
El CanKing es compatible con el hardware de Mi sniffer, sin usar PIC. La idea es desarrollar un sniffer que se comunicara con un software en PC para visualizar las tramas. Mr. Green |
Mas o menos seria ponerlos en un vector Char y enviarlo , se reduce a eso?
ok vale, ya entiendo (eso creo) lo que se necesita es tener conectado el bus (sin necesodad de un pic) atraves del puerto serie del computador para que el cankinfg en este caso lea las tramas no¿??¿ supongo q este sw se puede utilizar sin ninguna modificación, voy a bajarmelo para cuando tenga lista la placa provarlo.La placa sniffer comunica por el port paralelo, no por el serial.
Me que da una duda: si quiero controlar los distintos nodos de mi bus can mediante el PC habira que hacer modificaciones substanciles a la palca de pierno10 de nodo + sniffer ¿?¿?
Hola MGLSFT:
En que parte del programa del nodo A defines la velocidad del bus can?
Controlas tu placa tambien desde el teclado de la pc o solo usas el rs232 para monitorear el bus ?
Saludos
pues porque el tipo de encapsulado que utilizo es TQFP y los puertos estan juntos en uno de los lados del 42 al 35¡¡
por lo demas si ves algo que no concuerde comentamelo, mañana colgare el layout que lo estoy acabando esta noche con seguridad. utilizo proltel si puedes decirme como colgar el archivo ya que ocupa mucho mas de lo que me permite colgar lo pongo aqui con mucho gust.
como va el tema del sniffer? jejeje
Yo ando con un pequeño desarrollo de can, que tengo que implementar un hardware en una red, de la cual no tengo informacion
y tengo que quitar un hardware para poner este, pero nose el id ni los datos que le llegan, asi que tendria que capturar el id y los datos para emularlos.
saludos de antonio :-/
Estimado Leo, podras reescribir este mensaje en tu idioma natural, el portugues ???
Pasa que aunque soy incapaz de hablarlo, si puedo leerlo.
Lamentablemente la traduccion que has hecho no es buena, y se entiende menos que si lo escribieras en tu idioma natural.
Gracias. :mrgreen: :mrgreen:
Bien, ahora se entiende mejor, no queria equivocar la respuesta, por eso te pedi escribieras en portugues.
Veo que necesitas ayuda sobre el MCP25050, que es un dispositivo magnifico para hacer cosas baratas pero limitadas.
Ya hablamos del mismo aqui en el foro.
Debes saber dos cosas del mismo:
- debes especificar cuales tareas hara el dispositivo en el bus CAN a la perfeccion, ya que es OTP (One Time Programming)
- los parametros o direcciones que NO se pueden cambiar luego haciendo uso del BUS CAN son todos aquellos que programan a que velocidad y modo trabajara el dispositivo en el BUS, por razones obvias son los que debes conocer antes que todo
Si bien el resto de los parametros son reprogramables por medio del bus CAN, debes saber que cada vez que el dispositivo pierde su alimentacion, vuelve a los valores con los cuales fue programado, por lo tanto es obvio que si lo programas como deseas de entrada, evitaras tener que reprogramarlo cada vez que reinicies el sistema.
Si mal no entiendo, tienes una placa desarrollo de Microchip, debo advertirte algo, el programa no graba correctamente los valores dentro del MCP25050 (hay mucha info en la WEB, incluso en el mismo foro de Microchip) por lo tanto te sugiero armarte de paciencia y de las herramientas necesarias para poder programarlos sin arruinarlos.
espero te sea de ayuda. :mrgreen: :mrgreen: :mrgreen:
Yo utilize el software que provee Microchip para hacer la aplicacion, el problema es que no guarda la aplicacion en formato .hex, por lo tanto hay que obligarlo a hacerlo.
Cuando fui a programar el chip, mi programador me dijo que el archivo no correspondia con el cheksum, afortunadamente no me dejo grabarlo, sino lo perdia....
La aplicacion la hice con las plantillas que vienen con el MPLAB y las compile con el MPLAB, luego las pase al chip con el ICDS40 que tengo, que permite hacerlo, ya que los programadores de Microchip no lo soportan, salvo los grandes... :mrgreen:
Los recursos del Nodo B son los siguientes:
- Zócalos para líneas de PIC de 28 y 40 pines, puede usarse un PIC sin CAN o la línea PIC18 con CAN incorporado.
- Hardware de comunicacion CAN a PC con software CanKing (permite hacer Debug del BUS CAN).
- Memoria 93C86 con interfaz SPI.
- Pulsador para pruebas.
- Conjunto de LEDs en configuración semáforo.
- Un puerto completo de LEDs.
- Canal de comunicación serial.
- Conector ICD / ICSP, para programación In Circuit y Debug.
- Controlador CAN MCP2515, para utilizar con micros sin CAN incorporado.
- Selector de origen de Controlador CAN.
- Hardware de comunicación CAN.
Primero gracias por la respuesta anterior, ahora otra, cuando mencionas el 2515, lo haces vinculado a la frase para utilizar con micros sin CAN incorporado, entonces es posible omitir esta pieza cuando se utilizan chips con CAN incorporado, o es imprescindible para cualquier configuracion.
Me explico si tienes varios chips de cualquier gama que incorporen CAN o ECAN son necesarios los transceivers y el 25050, o los micros se pueden comunicar entre si sin la necesidad de estos
*******************
* *
* 18F458_emisor.c *
* *
*******************
#include <18F458.h>
#use delay(clock=2000000)
#include "can-18xxx8.c"
void main(void)
{
int DATA_TX=5;
can_init();
enable_interrupts(GLOBAL);
while(true)
{
can_putd(0, &DATA_TX, 1, 1, 1, 0);
delay_ms(5000);
}
}
*********************
* *
* 18F458_receptor.c *
* *
*********************
#include <18F458.h>
#fuses HS,NOPROTECT,NOLVP,NOWDT
#use delay(clock=20000000)
#include "can-18xxx8.c"
#use rs232(baud=9600,bits=8,parity=N,xmit=PIN_C6,rcv=PIN_C7)
void main(void)
{
int data[8];
struct rx_stat rxstat;
int32 id;
int leng;
int i;
for(i=0;i<8;i++) {
data[i]=0;
}
can_init();
enable_interrupts(GLOBAL);
while (true)
{
if ( can_kbhit() )
{
if(can_getd(id, &data[0], leng, rxstat))
{
printf("%s", "Se ha transmitido via CAN el caracter: ");
printf("\%X\r", data[0]);
}
}
}
}
veo que le pones cristales de 20 mhz y los ejemplos de CCS son para cristales de 16 MHz (hay que respetar las velocidades porque eso da las velocidades del bus CAN.
Puedes verlo durante el transcurso del hilo, la incidencia que tiene la frecuencia del reloj sobre la velocidad del BUS.
:g) Hola, perdon por perderme; pero mi proyecto me tiene loco, ya no se me ocurre q mas hacer, a si que diganme en que simulador encuentro el PIC 18F4685?
veo que le pones cristales de 20 mhz y los ejemplos de CCS son para cristales de 16 MHz (hay que respetar las velocidades porque eso da las velocidades del bus CAN.
Puedes verlo durante el transcurso del hilo, la incidencia que tiene la frecuencia del reloj sobre la velocidad del BUS.
Cierto. Inicialmente los puse a 16Mhz pero lo probe a diferentes velocidades entre ellas 20Mhz para ver que efecto producian.... no producian ninguno.
En la linea que dice:
CANSendMessage 0x001, MessageData, 8, CAN_TX_STD_FRAME & CAN_TX_NO_RTR_FRAME
Indicas al Bus CAN que trasmita 8 bytes (tercer argumento), pero antes le das valores a solo 4 argumentos de MessageData...
Una pregunta:
Estas probando en un circuito real o intentando simular??
hola marcos como estas
tenias razon los valores de configuracion estaban mal te mando la pagina de calculo para que la revises, tambien quisiera saber si puedo conectar el canking con un mcp2510, es que tengo un stand alone can y lo quiero conectar a la pc para generar trafico pero no se si me funcionara. aqui te mando la informacion del nodo para que la revises porfa
cuidate estamos en contacto
hola marco que tal
sabes arme el nodo CAN con el mcp2510, pero no me lo detecta la pc
como mi pc no tiene puerto paralelo compre un conversor de usb a paralelo pero no funciona no de tecta el hardware, luego lo probe en una desktop con un puerto paralelo directo y me da el mismo error de software en canking y no se porque
te mando el esquema del circuito que arme
revisalo porfa cuidate estamos en contacto
Hola, soy nuevo en el tema del bus can y me gustaria saber si es posible realizar la transmision de informacion entre dos pics sin necesidad del transaiver. O si existe alguna forma de realizarlo con electronica convencional. En verdad les agradezco la informacion ke puedan suministrarme. A y a proposito si tienen un ejemplo en ASM les agradezco muchisimo ya ke e estado trabando como 2 semanas en el mplab y no e podido avanzar mucho . Adios y gracias de antemanoRespuesta a la pregunta del transceiver, la respuesta es no.
el max232 es imprescindible, pon el virtual terminal directamente al pic.
Y explicando un poco de la placa, los 2 conectores que hay a la izquierda, son los interruptores internos que tiene el conector de la MMC, uno para tarjeta insertada y otro para la protección de escritura.
Posiblemente ya lo hayas visto, pero no esta demas darte este link, me parece importante.
PICOBDII Proyect source Code (http://picobdii.googlecode.com/svn/trunk/Code/)
Espero le saques utilidad... :mrgreen:
Esta basado en esta nueva placa de Microchip:
(http://img241.imageshack.us/img241/1002/mcp2515dmbmoj3.png)
Usa un PIC18F4550, un MCP2515 y un MCP2551, ademas de otros componentes, ya pondre el circuito mio, pero si quieren obtener mas informacion, la encontraran en este link:
http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en537141&part=MCP2515DM-BM (http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en537141&part=MCP2515DM-BM)
Saludos!! :mrgreen: :mrgreen: :mrgreen:
Hola a todos,
actualmente dispongo de una placa con 2 micros 18F4680, y para cada micro; 1 reset, 2 pulsadores,
1 potenciometro y 9 Leds. Solo uno de los 2 micros posee interfaz rs232 para comunicarse con el PC.
La idea es realizar un analizador logico del protocolo CAN de manera que, cada vez que se pulse
algun boton o el potenciometro del micro sin rs232, este envie un mensaje can al micro con rs232 y
que este ultimo envie y muestre la trama can COMPLETA en el Hyperterminal o similar del PC.
El problema es que no se me ocurre de que manera podria mostrar la información de TODA la trama
CAN.
Como todos los que estais siguiendo este hilo sabreis, una trama can se compone de varios campos:
inicio, asignacion, control, datos, CRC, confirmacion y fin de trama. Sin embargo, en todos los
ejemplos expuestos en relacion al sniffer can, la unica informacion que se muestra es el campo de
datos, el identificador, el tipo de trama, el RTR y poco mas.
No habria alguna manera de mostrar por pantalla toda la tira de bits que recibe el nodo con rs232
cuando se le envia una trama can desde el otro micro???
Cualquier tipo de ayuda o sugerencia sera eternamente agradecida.
Saludos.
PD: Marcos recuerdas el tema de la consulta de hacer las placas a doble cara, ya me dices algo. Un abrazo.
En realidad no se si podemos acceder realmente a esta informacion, salvo por los codigos de error y otros valores del BUS, es muy probable que no se acceda a esa informacion normalmente, y esa es la razon por la cual no se muestra.
Gente, aca dejo un pequeño aporte espero que a alguien le sirva. Vendria siendo un simulador del Bus CAN del automovil, bajando la demo se pueden ver varios ejemplos con sistemas completos funcionando (timing, datos, eventos)
Link: https://www.vector-worldwide.com/vi_downloadcenter_en.html
Elegir: CANanalyzer - Demo - Show Results: 5 items.
CANalyzer / CANoe 7.0
Fully functional demo including CAN, LIN, MOST, FlexRay, J1939, NMEA 2000, and J1587. The only limitation is that access to any hardware interface is not possible. The time-management is done with Windows timers, so it cannot be assumed that the time behaviour of the full version will be the same as of the demo. This means that the simulation time of the demo version does not necessarily correspond to real time.
Como comente anteriormente estoy armando un circuito que pronto subire para recibir sus consejos...
Quieres decir que podemos acceder al campo CRC de una trama??? o algun otro valor del bus???
A lo que puedes acceder es a los bits de error que envian los nodos del bus...
#include "main.h"
#define CAN_USE_EXTENDED_ID FALSE
#include <can-18xxx8.c>
#byte porta = 0
#byte portb = 6
#byte portc = 7
void main()
{
struct rx_stat rxstat;
int32 rx_id;
int in_data[8];
int rx_len;
//send a request (tx_rtr=1) for 8 bytes of data (tx_len=8) from id 24 (tx_id=24)
int out_data[8];
int32 tx_id=24;
int1 tx_rtr=1;
int1 tx_ext=0;
int tx_len=8;
int tx_pri=3;
int corrida;
int i;
for (i=0;i<8;i++) {
out_data[i]=0;
in_data[i]=0;
}
set_tris_a(0b11111111);
set_tris_b(0b00001000);
set_tris_c(0b10000000);
porta=0;
portb=0;
portc=0;
can_init();
can_set_mode(CAN_OP_CONFIG);
//Configuracion CAN 500 kbps
BRGCON1.brp=2;
BRGCON1.sjw=1;
BRGCON2.prseg=1;
BRGCON2.seg1ph=4;
BRGCON2.sam=FALSE;
BRGCON2.seg2phts=FALSE;
BRGCON3.seg2ph=4;
BRGCON3.wakfil=TRUE;
can_set_mode(CAN_OP_NORMAL);
corrida = 0;
while (corrida < 31) //Numero aleatorio de corrida para una lectura mas limpia y analisis posterior.
{
if ( can_kbhit() ) //if data is waiting in buffer...
{
if(can_getd(rx_id, &in_data[0], rx_len, rxstat)) //...then get data from buffer
{
printf("\r\nGOT: BUFF=%U ID=%LU LEN=%U OVF=%U ", rxstat.buffer, rx_id, rx_len, rxstat.err_ovfl);
printf("FILT=%U RTR=%U EXT=%U INV=%U", rxstat.filthit, rxstat.rtr, rxstat.ext, rxstat.inv);
printf("\r\n DATA = ");
for (i=0;i<rx_len;i++) {
printf("%X ",in_data[i]);
}
}
else
{
printf("\r\nFallo can_getd()\r\n");
}
}
if ( can_tbe() )
{
i=can_putd(tx_id, out_data, tx_len,tx_pri,tx_ext,tx_rtr); //put data on transmit buffer
if (i != 0xFF)
{
printf("\r\nPUT %U: ID=%LU LEN=%U ", i, tx_id, tx_len);
printf("PRI=%U EXT=%U RTR=%U\r\n DATA = ", tx_pri, tx_ext, tx_rtr);
for (i=0;i<tx_len;i++) {
printf("%X ",out_data[i]);
}
printf("\r\n");
}
else
{ //fail, no transmit buffer was open
printf("\r\nFallo can_putd(); \r\n");
}
}
corrida++;
}
}
Entro al main...
Previo a can_init();
CAN Inicializado ...
Modo CAN en Configuracion
500 kps...
Modo CAN en Normal
Previo a can_kbhit(); ...
Previo a can_tbe(); - Analisis del buffer de emision - Si esta vacio entra
Entro can_tbe(); - Buffer de Transmision Vacio, puedo escribir - Espero 4seg.
PUT 1: ID=24 LEN=8 PRI=3 EXT=0 RTR=0
DATA = 00 00 00 00 00 00 00 00
Termino corrida bandera ...
Entro can_tbe(); - Buffer de Transmision Vacio, puedo escribir - Espero 4seg.
PUT 1: ID=24 LEN=8 PRI=3 EXT=0 RTR=0
DATA = 00 00 00 00 00 00 00 00
Entro can_tbe(); - Buffer de Transmision Vacio, puedo escribir - Espero 4seg.
PUT 1: ID=24 LEN=8 PRI=3 EXT=0 RTR=0
DATA = 00 00 00 00 00 00 00 00
-----------------------------------------------------------------------------
RESPUESTA DEL AUTO EN MARCHA
-----------------------------------------------------------------------------
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 00 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=442 LEN=5 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 35 00 3E 09
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1C CC 33 10 00 31 31
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1B 6B 34 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1B EB 32 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1B AE 32 10 00 31 31
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1B 77 33 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1B 1B 33 10 00 31 31
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1B 56 34 10 00 31 31
Entro al main...
Previo a can_init();
CAN Inicializado ...
Modo CAN en Configuracion
500 kps...
Modo CAN en Normal
Previo a can_kbhit(); ...
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1A AD 34 10 00 31 32
Previo a can_tbe(); - Analisis del buffer de emision - Si esta vacio entra
Entro can_tbe(); - Buffer de Transmision Vacio, puedo escribir - Espero 4seg.
PUT 1: ID=24 LEN=8 PRI=3 EXT=0 RTR=0
DATA = 00 00 00 00 00 00 00 00
Termino corrida bandera ...
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1A 73 34 10 00 32 32
Entro can_tbe(); - Buffer de Transmision Vacio, puedo escribir - Espero 4seg.
PUT 1: ID=24 LEN=8 PRI=3 EXT=0 RTR=0
DATA = 00 00 00 00 00 00 00 00
-----------------------------------------------------------------------------
RESPUESTA DEL AUTO EN MARCHA Acelerado
-----------------------------------------------------------------------------
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 1A 69 33 10 00 31 31
Entro can_tbe(); - Buffer de Transmision Vacio, puedo escribir - Espero 4seg.
PUT 1: ID=24 LEN=8 PRI=3 EXT=0 RTR=0
DATA = 00 00 00 00 00 00 00 00
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 18 DF 33 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 18 D7 33 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 18 D8 34 10 00 31 31
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=442 LEN=5 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 33 00 3D 09
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 17 F2 33 10 00 32 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 18 4B 33 10 00 31 31
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 17 FF 33 10 00 31 31
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=442 LEN=5 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 00 34 00 3D 09
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 17 8A 34 10 00 31 32
Se supero can_kbhit(); - Hay datos en Buffer de entrada esperando...
GOT: BUFF=0 ID=250 LEN=7 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 16 EA 33 10 00 32 32
> The PID for MAP is 0B, MAF is $10, intake temp is $0F, RPM is 0C and
> vehicle speed is $0D.
>
> If you send this into a CAN vehicle with OBDII: You use Srvice 01 for this
> request:
>
> 7DF 02 01 0C I think you will get the RPM returned.
>
> It will look like this:
>
> 7E8 04 41 00 xx yy where xx yy is the RPM 1/4 RPM per bit.
>
> 1st line - 7DF - CAN ID - to all OBDII modules. 02 - 2 bytes of data
> following, 01 - service 1, 0C - get RPM
> 2nd line - 7E8 - a OBDII module responding (its adrress is 7E8 - 8 = 7E0),
> 04 - 4 data bytes following, 41 - service 01+40, 00 - RPM, xx yy the two
> byte data.
>
> I think this is correct - if you get no response, msend 8 data bytes with
> rest of frame with $FF in the unused data bytes.
>
#define tx_id 0x7DF
stat.inv=CAN_INT_IRXIF;
IRXIF: CAN Invalid Received Message Interrupt Flag bit
1 = An invalid message has occurred on the CAN bus
0 = No invalid message on CAN bus
BRGCON1.brp=1; //prescaler
BRGCON1.sjw=0; //SYNCH_JUMP 0+1
BRGCON2.prseg=2; //propagation 2+1
BRGCON2.seg1ph=7; //7+1
BRGCON2.sam=FALSE;
BRGCON2.seg2phts=FALSE;
BRGCON3.seg2ph=7; //7+1
BRGCON3.wakfil=TRUE;
CAN_GETD(): BUFF=0 ID=000007E8 LEN=8 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 03 7F 01 11 AA AA AA AA
...
2) Mi segundo problema es el "vacie" antes puesto entre comillas... :-p
Tengo puesto unos LED's tanto en TX y RX del Serie del PIC y en TX y RX del CAN del PIC
EL led de TX del PIC NUNCA prende (ya lo teste y funciona bien)
Asi que imagino que tengo cierto problema con la funcion can_putd() , estoy investigando sobre ello.
La buena noticia es que con la configuracion de baud_rate antes mencionada recibo la siguiente trama una sola vez al principio:Código: [Seleccionar]
CAN_GETD(): BUFF=0 ID=000007E8 LEN=8 OVF=0 FILT=0 RTR=0 EXT=0 INV=1
DATA = 03 7F 01 11 AA AA AA AA
Es la primera vez que recibo una trama con ID 7E8, asi que eso me pone contento y pilas para seguir. Tambien tengo que descifrar el significado de la misma.
Bueno, cualquier otra novedad se las comentare a la brevedad.
Agradezco nuevamente por la ayuda brindada.
Hola gente, bueno, terrible post!!! Recién luego de 3 días (entrecortados) leyendo termino con esto. Bueno les cuento que mi proyecto està parado hace tiempo por la selección del método de comunicación.
Básicamente son sensores dispuestos en un brazo robótico para ver su posición espacial (3D). Primero pensé en SMACK pero se me fue complicando el tema velocidad y CRC y demás, luego el I2C tampoco servía por no estar orientado a grandes distancias, luego RS485 pero no me gustaba por el tema de los cables y de nuevo el CRC que nunca entendí bien. Ahora luego de leer todo el hilo creo que este protocolo puede servirme a mis propósitos. Siempre hice proyectos interesantes pero la parte comunicación se la dejaba a otra persona y ahora decidí aprender y me cuesta bastante.
Me gustaría si alguno de los que entienden más que yo (el 90%) de los del hilo puedan resumirme en una respuesta o cita que necesito para practicar seriamente con CanBus.
Puede ser la placa de entrenamiento de CCS? Puede ser otra placa o placas? Las que hicieron algunos de los de aquí, cuál/es? Podrían si es así poner los esquemáticos y los negativos para hacer las placas.
Luego para debbugear, como proceden? Leí sobre los sniffers pero al parecer ninguno está completamente funcional, al menos los seriales.
Sería una especie de resumen para alguien que desea empezar a practicar. No importan que chips hagan falta, los compraré o de ser una placa X también estoy dispuesto a hacerlo.
Muchísimas gracias y espero que sus proyectos sigan adelante.
Aristides - Campana, Bs. As.
Hola gente, bueno, terrible post!!! Recién luego de 3 días (entrecortados) leyendo termino con esto. Bueno les cuento que mi proyecto està parado hace tiempo por la selección del método de comunicación.
Básicamente son sensores dispuestos en un brazo robótico para ver su posición espacial (3D). Primero pensé en SMACK pero se me fue complicando el tema velocidad y CRC y demás, luego el I2C tampoco servía por no estar orientado a grandes distancias, luego RS485 pero no me gustaba por el tema de los cables y de nuevo el CRC que nunca entendí bien. Ahora luego de leer todo el hilo creo que este protocolo puede servirme a mis propósitos. Siempre hice proyectos interesantes pero la parte comunicación se la dejaba a otra persona y ahora decidí aprender y me cuesta bastante.
Me gustaría si alguno de los que entienden más que yo (el 90%) de los del hilo puedan resumirme en una respuesta o cita que necesito para practicar seriamente con CanBus.
Puede ser la placa de entrenamiento de CCS? Puede ser otra placa o placas? Las que hicieron algunos de los de aquí, cuál/es? Podrían si es así poner los esquemáticos y los negativos para hacer las placas.
Luego para debbugear, como proceden? Leí sobre los sniffers pero al parecer ninguno está completamente funcional, al menos los seriales.
Sería una especie de resumen para alguien que desea empezar a practicar. No importan que chips hagan falta, los compraré o de ser una placa X también estoy dispuesto a hacerlo.
Muchísimas gracias y espero que sus proyectos sigan adelante.
Aristides - Campana, Bs. As.
Creo que lo mejor que podrias hacer es armarte o comprarte una placa como la de CCS o de MikroC.
De la de CCS puedo pasarte los esquematicos.
Mi placa la hice siguiendo en parte la de CCS, mezclada con algunas de Microchip.
De microchip esta interesante la placa que puse unos post antes, tiene buen precio y conecta por USB, tienes una placa para hacer debug y otra para aplicaciones.
Quien eres en ese foro??
Lo del ELM, sabes donde se consigue??
Hola a todos, este mi primer aporte en el tema del Bus-Can, bueno les cuento, me compre una interface can usb http://www.canusb.com/index.htm, muy buena por cierto te dan un programa para ver los datos y algunos ejemplos con labview y otros, lo probe en un vehiculo y me leyo todos los datos, con esos datos me dispuse a armar mi propia interface usando el dspic 30f4011 con el mcp2551 y cristal de 20Mhz, lo programe con el mikrobasic para dspic, y bueno despues de tanto lidiar logre configurar para enviar y recibir mensajes 500Kbps, y aqui viene mi problema cuando conecto el dspic con la interface usb me envia y recibe bien los datos, pero cuando lo conecto con el vehiculo, este se resetea, si solo programo el dspic para enviar no hay problema, pero si lo configuro asi sea solo para recibir se me resetea, nose porque si alguien me puede ayudar, les adjunto el programa del dspic. graciasCódigo: FreeBasic
program TX_RX_CAN_500Kbs include "logo" dim Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags, MSG_RCVD, RX_DATA_LEN, X as word Tx_Data as byte[8] Rx_Data as byte[8] txt as string[3] Rx_ID, Tx_ID as longint main: ADPCFG = $FFFF Can_Init_Flags = 0 Can_Send_Flags = 0 Can_Rcv_Flags = 0 Can_Send_Flags = CAN_TX_PRIORITY_1 and ' SE UTILIZA PARA CAN_TX_STD_FRAME and ' CANSendMessage CAN_TX_RTR_FRAME Can_Init_Flags = CAN_CONFIG_SAMPLE_THRICE and ' SE ULILIZA PARA CAN_CONFIG_PHSEG2_PRG_ON and ' CANInitialize CAN_CONFIG_XTD_MSG and CAN_CONFIG_DBL_BUFFER_ON and CAN_CONFIG_ALL_VALID_MSG and CAN_CONFIG_LINE_FILTER_OFF CAN1Initialize(1,2,4,4,1,Can_Init_Flags) ' configurado a 500kbs con oscilador 'de 20 MHz CAN1SetOperationMode(CAN_MODE_NORMAL, 0x00) ' set CONFIGURATION mode CAN1SetMask(CAN_MASK_B1, -1, CAN_CONFIG_MATCH_MSG_TYPE and CAN_CONFIG_STD_MSG) ' set all mask1 bits to ones CAN1SetMask(CAN_MASK_B2, -1, CAN_CONFIG_MATCH_MSG_TYPE and CAN_CONFIG_STD_MSG) ' set all mask2 bits to ones CAN1SetFilter(CAN_FILTER_B1_F1, 5,CAN_CONFIG_STD_MSG) ' set id of filter B2_F3 to 3 CAN1SetOperationMode(CAN_MODE_NORMAL, 0x00) ' modo Normal ENVIA Y RECIBE ' -----------------configuracion del glcd 128x64 Glcd_Init(PORTC,13,PORTC,14,PORTE,8,PORTD,1,PORTB,8,PORTD,3,PORTB) 'conf d puertos delay_ms(2000) Glcd_Fill(0x00) ' Limpiar pantalla Glcd_Image(LOGOTIPO_bmp) 'dibujar imagen Delay_MS(5000) Uart2_Init(9600) 'INICIALIZAMOS RS232 Glcd_Fill(0x00) ' Limpiar pantalla MOSTAR: while TRUE Tx_ID=$100 Tx_Data[0] = $EC Tx_Data[1] = $04 Tx_Data[2] = $00 Tx_Data[3] = $00 Tx_Data[4] = $00 Tx_Data[5] = $A9 Tx_Data[6] = $0B Tx_Data[7] = $6a CAN1Write(Tx_ID, Tx_Data, 8, Can_Send_Flags) ' envio los datos Tx_ID=$500 Tx_Data[0] = $5E Tx_Data[1] = $00 Tx_Data[2] = $F8 Tx_Data[3] = $02 Tx_Data[4] = $D2 Tx_Data[5] = $02 Tx_Data[6] = $26 Tx_Data[7] = $02 CAN1Write(Tx_ID, Tx_Data, 8, Can_Send_Flags) ' envio los datos FOR X=0 TO 100 DELAY_MS(1) 'PAUSA ENTRE ENVIO RECEPCION NEXT X Msg_Rcvd = CAN1Read(Rx_ID , Rx_Data , Rx_Data_Len, Can_Rcv_Flags) IF Rx_ID=$112 THEN Uart2_Write_TEXT ("112") Glcd_Set_Font(@System3x6, 3, 6, 32) Glcd_Write_TEXT("RX_ID=112 DLC=", 3, 0, 2) ByteToStr(Rx_Data_LEN, txt) Glcd_Write_TEXT(TXT, 63, 0, 2) ByteToStr(Rx_Data[0], txt) Glcd_Write_TEXT(TXT, 3, 1, 0) ByteToStr(Rx_Data[1], txt) Glcd_Write_TEXT(TXT, 18, 1, 0) ByteToStr(Rx_Data[2], txt) Glcd_Write_TEXT(TXT, 33, 1, 0) ByteToStr(Rx_Data[3], txt) Glcd_Write_TEXT(TXT, 48, 1, 0) ByteToStr(Rx_Data[4], txt) Glcd_Write_TEXT(TXT, 63, 1, 0) ByteToStr(Rx_Data[5], txt) Glcd_Write_TEXT(TXT, 78, 1, 0) ByteToStr(Rx_Data[6], txt) Glcd_Write_TEXT(TXT, 93, 1, 0) ByteToStr(Rx_Data[7], txt) Glcd_Write_TEXT(TXT, 108, 1, 0) END IF IF Rx_ID=$512 THEN Uart2_Write_TEXT ("512") Glcd_Set_Font(@System3x6, 3, 6, 32) Glcd_Write_TEXT("RX_ID=512 DLC=", 3, 2, 2) ByteToStr(Rx_Data_LEN, txt) Glcd_Write_TEXT(TXT, 63, 2, 2) ByteToStr(Rx_Data[0], txt) Glcd_Write_TEXT(TXT, 3, 3, 0) ByteToStr(Rx_Data[1], txt) Glcd_Write_TEXT(TXT, 18, 3, 0) ByteToStr(Rx_Data[2], txt) Glcd_Write_TEXT(TXT, 33, 3, 0) ByteToStr(Rx_Data[3], txt) Glcd_Write_TEXT(TXT, 48, 3, 0) ByteToStr(Rx_Data[4], txt) Glcd_Write_TEXT(TXT, 63, 3, 0) ByteToStr(Rx_Data[5], txt) Glcd_Write_TEXT(TXT, 78, 3, 0) ByteToStr(Rx_Data[6], txt) Glcd_Write_TEXT(TXT, 93, 3, 0) ByteToStr(Rx_Data[7], txt) Glcd_Write_TEXT(TXT, 108, 3, 0) END IF IF Rx_ID=$712 THEN Uart2_Write_TEXT ("700") Glcd_Set_Font(@System3x6, 3, 6, 32) Glcd_Write_TEXT("RX_ID=700 DLC=", 3, 4, 2) ByteToStr(Rx_Data_LEN, txt) Glcd_Write_TEXT(TXT, 63, 4, 2) ByteToStr(Rx_Data[0], txt) Glcd_Write_TEXT(TXT, 3, 5, 0) ByteToStr(Rx_Data[1], txt) Glcd_Write_TEXT(TXT, 18, 5, 0) ByteToStr(Rx_Data[2], txt) Glcd_Write_TEXT(TXT, 33, 5, 0) ByteToStr(Rx_Data[3], txt) Glcd_Write_TEXT(TXT, 48, 5, 0) ByteToStr(Rx_Data[4], txt) Glcd_Write_TEXT(TXT, 63, 5, 0) ByteToStr(Rx_Data[5], txt) Glcd_Write_TEXT(TXT, 78, 5, 0) ByteToStr(Rx_Data[6], txt) Glcd_Write_TEXT(TXT, 93, 5, 0) ByteToStr(Rx_Data[7], txt) Glcd_Write_TEXT(TXT, 108, 5, 0) END IF wend GOTO MOSTRAR end.
MGL. Perdon por la edicion, pero asi se puede ver tu codigo sin tener el editor...
hech, a que vehiculo te conectaste ?
Estas seguro que tiene implementado el Bus-CAN ? , la interface que adquiriste puede estar leyendo los datos de algun otro protocolo (ISO 9141 , ISO 14230 , etc.)
Te lo pregunto pq tengo armada un interfaz con un PIC 18F258 y un MCP2551 , logre la comunicacion y el auto me responde con tramas de PIDs no soportados.
Saludos
hech, a que vehiculo te conectaste ?no te te entiendo arameo?
Hola a todos, este mi primer aporte en el tema del Bus-Can, bueno les cuento, me compre una interface can usb http://www.canusb.com/index.htm, muy buena por cierto te dan un programa para ver los datos y algunos ejemplos con labview y otros, lo probe en un vehiculo y me leyo todos los datos, con esos datos me dispuse a armar mi propia interface usando el dspic 30f4011 con el mcp2551 y cristal de 20Mhz, lo programe con el mikrobasic para dspic, y bueno despues de tanto lidiar logre configurar para enviar y recibir mensajes 500Kbps, y aqui viene mi problema cuando conecto el dspic con la interface usb me envia y recibe bien los datos, pero cuando lo conecto con el vehiculo, este se resetea, si solo programo el dspic para enviar no hay problema, pero si lo configuro asi sea solo para recibir se me resetea, nose porque si alguien me puede ayudar, les adjunto el programa del dspic. gracias
soy nuievo en este tema y estoy haciendo un proyecto con el mencioado bus can utilizando el dspic304013 y quiesiera saber si algruin tiene algunos ejemplos de esta paluicaion con domotica, ante antes mis felisitaciones MGSOFT por abrir este tema que es un poco escaso la informacion pero bastante empleado e interesante y de antemano agradecer buestras respuestas gracias
Bueno gente, me compré luego de valorar opciones la placa de ccs para CAN BUS junto con el programador MatchX que ofrecen. Apenas lo tenga les comento que onda. Por ahora estoy renegando con RS485 que me está sacando canas de todos colores con el PIC 18F2553. Abrazo
Si, son los libros de ejercicios de CCS, si ponen solo http://www.ccsinfo.com/pdfs les aparece todos los que tienen... y el de CAN me pareció que esta bueno por el tema que explican bien los distintos modos y los filtros...
Bueno yo empece a hacer un proyecto de domótica usando RS-485 y SNAP (http://www.hth.com/snap/) y pude desde una pequeña aplicación en C# mandar tramas SNAP vía serie con CRC y capturarlas con un 16F628 y prender y apagar una luz. El tema es que luego vi esto de CAN y me pareció mucho más fácil de implementar, así que buscando info encontré este foro y ya pedí unas muestras para empezar a programar. Así que ni bien me lleguen compartiré mis experiencias....
Mi idea es hacer nodos que controlen las luces, un nodo que se conecte a la alarma y ya que la alarma tiene un conector serial poder capturar los eventos de la alarma para saber el estado. Me interesaria que el nodo de la alarma transmita por CAN cuando se activa y desactiva, de modo que la casa sepa si estoy en casa o no....
Bueno les mando saludos y ni bien empiece a hacer pruebas las compartire con ustedes...
Saludos
En este link puedes bajarte el manual de la placa de CCS y su libro de ejemplos.
Placa CCS (http://www.ccsinfo.com/pdfs/Development_Kit_for_the_CANBus_Exercise_Book.pdf)
Aca una imagen del software funcionando en PC...
Ya terminé mi proyecto, al final he conseguido comunicarme con el bus CAN del coche. El PIC lee los datos de OBD y muestra los PIDS seleccionados por la pantalla LCD.
Tiene 2 modos de funcionamiento, uno conectado al ordenador por puerto serie, y se le envían comandos para transmitir al vehículo y configurar las opciones. El otro modo, es automático cuando no se le envia nada por el puerto serie, comienza a hacer peticiones de los datos del OBD, según el protocolo ISO 15765 (OBD sobre CAN).
En este video se muestra como funciona la placa del montaje.
Ya terminé mi proyecto, al final he conseguido comunicarme con el bus CAN del coche. El PIC lee los datos de OBD y muestra los PIDS seleccionados por la pantalla LCD.
Tiene 2 modos de funcionamiento, uno conectado al ordenador por puerto serie, y se le envían comandos para transmitir al vehículo y configurar las opciones. El otro modo, es automático cuando no se le envia nada por el puerto serie, comienza a hacer peticiones de los datos del OBD, según el protocolo ISO 15765 (OBD sobre CAN).
En este video se muestra como funciona la placa del montaje.
Felicitaciones TELEKO !!
Lo has logrado!!
Si quieres despues comentarnos mas sobre tu proyecto, puedes hacerlo aqui, ya que hay seguidores de tu proyecto.
Si abres otro hilo, por favor pon aqui un link asi van directo al hilo tuyo... :mrgreen: :mrgreen:
http://code.google.com/p/avrobdii/source/browse/trunk/code/obdii.c
//#include <18F4580.h>
#FUSES NOWDT //No Watch Dog Timer
#FUSES WDT128 //Watch Dog Timer uses 1:128 Postscale
#FUSES HS //High speed Osc (> 4mhz)
#FUSES NOPROTECT //Code not protected from reading
#FUSES BROWNOUT //Reset when brownout detected
#FUSES BORV21 //Brownout reset at 2.1V
#FUSES PUT //Power Up Timer
#FUSES NOCPD //No EE protection
#FUSES STVREN //Stack full/underflow will cause reset
#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOWRT //Program memory not write protected
#FUSES NOWRTD //Data EEPROM not write protected
#FUSES NOIESO //Internal External Switch Over mode enabled
#FUSES FCMEN //Fail-safe clock monitor enabled
//#FUSES PBADEN //PORTB pins are configured as analog input channels on RESET
#FUSES BBSIZ1K //1K words Boot Block size
#FUSES NOWRTC //configuration not registers write protected
#FUSES NOWRTB //Boot block not write protected
#FUSES NOEBTR //Memory not protected from table reads
#FUSES NOEBTRB //Boot block not protected from table reads
#FUSES NOCPB //No Boot Block code protection
#FUSES NOLPT1OSC //Timer1 is not configured for low-power operation
//#FUSES MCLR //Master Clear pin enabled
#FUSES NOXINST //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#include "can-18F4580.c"
#define PIC_ID 26//identificação deste PIC
#define PIN_LED1 PIN_A0
#define PIN_LED2 PIN_A1
#define LED1_LOW output_low(PIN_LED1)
#define LED1_HIGH output_high(PIN_LED1)
#define LED2_LOW output_low(PIN_LED2)
#define LED2_HIGH output_high(PIN_LED2)
#define BUTTON1 PIN_A2
#define BUTTON2 PIN_A3
#define BUTTON_PRESSED1 input(BUTTON1)
#define BUTTON_PRESSED2 input(BUTTON2)
void main()
{
int led=9;
int cnt1 = 0;
int cnt2 = 0;
int cnt3 = 0;
int cnt4 = 0;
//recv message
struct rx_stat rxstat;
int32 rx_id;
int in_data[8];
int rx_len;
int out_data[8];
int i = 0;
//clear recv buffer
for(i=0;i<8;i++)
{
in_data[i]=0;
}
can_init();
//can_set_mode(CAN_OP_LISTEN);
while(TRUE)
{
// mensagem recebida
if ( can_kbhit() )
{
if(can_getd(rx_id, &in_data[0], rx_len, rxstat)) //se existem dados no buffer in_data, guarda os dados recebidos nas variáveis
{
if(rx_id == PIC_ID) // Se a mensagem é para este PIC
{
led =~ (in_data[0]);
if(bit_test(led, 0))
LED1_HIGH;//turn ON Led 1
if(bit_test(led, 1))
LED1_LOW;//turn OFF Led 1
if(bit_test(led, 2))
LED2_HIGH;//tunr ON Led 2
if(bit_test(led, 3))
LED2_LOW;//turn OFF Led 2
}
}
}//fim do tratamento da mensagem recebida
if( (!BUTTON_PRESSED1) && (cnt1 == 0) ) // if button 1 is OFF
{
out_data[0] = 4;
can_putd(25, &out_data[0], 1, 1, 1, 0);
cnt1 = 1;
cnt2 = 0;
}
if( (BUTTON_PRESSED1) && (cnt2 == 0) ) //if button 1 is ON
{
out_data[0] = 5;
can_putd(25, &out_data[0], 1, 1, 1, 0);
cnt2 = 1;
cnt1 = 0;
}
if( (!BUTTON_PRESSED2) && (cnt3 == 0) ) // if button 2 is OFF
{
out_data[0] = 6;
can_putd(25, &out_data[0], 1, 1, 1, 0);
cnt3 = 1;
cnt4 = 0;
}
if( (BUTTON_PRESSED2) && (cnt4 == 0) ) // if button 2 is ON
{
out_data[0] = 7;
can_putd(25, &out_data[0], 1, 1, 1, 0);
cnt4 = 1;
cnt3 = 0;
}
}
}
Revisando el codigo, creo que esta bien operativo.
No entiendo lo de los cnt1 a 4.
Supongo es para saber que boton presionaste ultimo, es asi ??
NI (mezcla de No con sI).A... Si, si! Eso también tiene que solucionarlo. Y en el caso que quiera usar debug puede usar USART por software.
Aun asi no esta declarando las salidas o entradas necesarias, por eso insisto en que retorne a Standard_IO().
#FUSES NOWDT //No Watch Dog Timer
#FUSES WDT128 //Watch Dog Timer uses 1:128 Postscale
#FUSES HS //High speed Osc (> 4mhz)
#FUSES NOPROTECT //Code not protected from reading
#FUSES BROWNOUT //Reset when brownout detected
#FUSES BORV21 //Brownout reset at 2.1V
#FUSES PUT //Power Up Timer
#FUSES NOCPD //No EE protection
#FUSES STVREN //Stack full/underflow will cause reset
#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOWRT //Program memory not write protected
#FUSES NOWRTD //Data EEPROM not write protected
#FUSES NOIESO //Internal External Switch Over mode enabled
#FUSES FCMEN //Fail-safe clock monitor enabled
//#FUSES PBADEN //PORTB pins are configured as analog input channels on RESET
#FUSES BBSIZ1K //1K words Boot Block size
#FUSES NOWRTC //configuration not registers write protected
#FUSES NOWRTB //Boot block not write protected
#FUSES NOEBTR //Memory not protected from table reads
#FUSES NOEBTRB //Boot block not protected from table reads
#FUSES NOCPB //No Boot Block code protection
#FUSES NOLPT1OSC //Timer1 is not configured for low-power operation
//#FUSES MCLR //Master Clear pin enabled
#FUSES NOXINST //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
#include "can-18F4580.c"
#define PIC_ID 25//identificação deste PIC
void main()
{
//recv message
struct rx_stat rxstat;
int32 rx_id;
int in_data[8];
int rx_len;
int data = 9;
int out_data[8];
int i = 0;
int8 buffer[8];
//clear recv buffer
for(i=0;i<8;i++)
{
in_data[i]=0;
}
can_init();
//can_set_mode(CAN_OP_LISTEN);
while(TRUE)
{
// mensagem recebida
if ( can_kbhit() )
{
if(can_getd(rx_id, &in_data[0], rx_len, rxstat)) //se existem dados no buffer in_data, guarda os dados recebidos nas variáveis
{
if(rx_id == PIC_ID) // Se a mensagem é para este PIC
{
data =~ (in_data[0]);
if(bit_test(data, 4))
printf("Botão 1 está OFF.\n");
if(bit_test(data, 5))
printf("Botão 1 está ON.\n");
if(bit_test(data, 6))
printf("Botão 2 está OFF.\n");
if(bit_test(data, 7))
printf("Botão 2 está ON.\n");
}
}
}//fim do tratamento da mensagem recebida
buffer[0] = getc();
if(buffer[0] == "0" )//liga Led 1
{
out_data[0] = 0;
can_putd(26, &out_data[0], 1, 1, 1, 0);
}
if(buffer[0] == "1" )//desliga Led 1
{
out_data[0] = 1;
can_putd(26, &out_data[0], 1, 1, 1, 0);
}
if(buffer[0] == "2")//liga Led 2
{
out_data[0] = 2;
can_putd(26, &out_data[0], 1, 1, 1, 0);
}
if(buffer[0] == "3")//desliga Led 2
{
out_data[0] = 3;
can_putd(26, &out_data[0], 1, 1, 1, 0);
}
}
}
///// 3 /////////
////////////////////////////////////////////////////////////////////////
//
// can_abort()
//
// Aborts all pending tranmissions.
//
//////////////////////////////////////////////////////////////////////////////
void can_abort(void) {
struct struct_CANCTRL b_CANCTRL;
b_CANCTRL=mcp2510_read(CANCTRL);
b_CANCTRL.abat=1;
mcp2510_write(CANCTRL, (int)b_CANCTRL);
delay_ms(5);
b_CANCTRL.abat=0;
mcp2510_write(CANCTRL, (int)b_CANCTRL);
}
///////////////////
///
//
// SPI CODE. Antes por sofware, cambiando funciones para usar SPI por HW.
//
///
//////////////////
//data clocked in on rising edge
//data driven out on falling edge
/*int mcp2510_read(int address) ///////// Esta es por software ////////
{
int command[2];
int i;
int data;
command[1]=0x03;
command[0]=address;
output_low(EXT_CAN_CS);
for (i=0;i<16;i++) {
output_bit(EXT_CAN_SI, shift_left(&command[0],2,0));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
for (i=0;i<8;i++) {
shift_left(&data,1,input(EXT_CAN_SO));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
output_high(EXT_CAN_CS);
return(data);
}*/
/////////////////////////////////////////////////
//////////////////////////////////// Esta es por hardware //////////////////////////////////
int mcp2510_read(int address)
{
//enviar ( o sea escribir) al MCP desde el PIC que se quiere hacer.PIC contesta a la peticion de
//lectura ( y el que hemos dicho) sobre data. Devuelve data
int data;
output_low(EXT_CAN_CS); // pic espera intsrucción. Primero mira cual es:
spi_write(0x03); // escribir instrucción 0x03 es instruccion leer.Va a instruccion leer->
spi_write(address); //escribir dirección de donde se quiere leer
spi_read(data); // escribir dato enviado por el pic
output_high(EXT_CAN_CS);
return(data); //devuelbe lo que queremos leer
}
////////////////////////////////////////////////
/*
int mcp2510_status(void) { //////////////////// por software////////////////////////////
int command;
int data;
int i;
command=0xA0;
output_low(EXT_CAN_CS);
for (i=0;i<8;i++) {
output_bit(EXT_CAN_SI, shift_left(&command,1,0));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
for (i=0;i<8;i++) {
shift_left(&data,1,input(EXT_CAN_SO));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
for (i=0;i<8;i++) {
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
output_high(EXT_CAN_CS);
return(data);
}*/
/////////////////////////////////////////////////////
//////////////////////////////////// Esta es por hardware //////////////////////////////////
int mcp2510_status(void) {
int data;
output_low(EXT_CAN_CS); //podriamos hacer algo par comrpbar error, si la 2a lectura!=1a lectura
spi_write(0xA0);
spi_read(data);
spi_read();
output_high(EXT_CAN_CS);
return(data); ///////////
}
////////////////////////////////////////////////////
/*
void mcp2510_write(int address, int data) { //////////////////// por software////////////////////////////
int command[3];
int i;
command[2]=0x02;
command[1]=address;
command[0]=data;
output_low(EXT_CAN_CS);
for (i=0;i<24;i++) {
output_bit(EXT_CAN_SI, shift_left(&command[0],3,0));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
output_high(EXT_CAN_CS);
} */
///////////////////////////////////////////////////////////////////////
//////////////////////////////////// Esta es por hardware //////////////////////////////////
void mcp2510_write(int address, int data) {
output_low(EXT_CAN_CS);
spi_write(0x02); //
spi_write(address); //estas 2 siempre es spi_write ya que se ha de decir desde el pic la fun.
spi_write(data);
output_high(EXT_CAN_CS);
}
////////////////////////////////////////////////////////////////////////
/*
void mcp2510_command(int command) { /////////// por software //////////////////////////
int i;
output_low(EXT_CAN_CS);
for (i=0;i<8;i++) {
output_bit(EXT_CAN_SI, shift_left(&command,1,0));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
output_high(EXT_CAN_CS);
}*/
////////////////////////////////////////////// /por Hardware //////////////////////////////
void mcp2510_command(int command){
output_low(EXT_CAN_CS);
spi_write(command);
output_high(EXT_CAN_CS);
}
////////////////////////////////////////
/*
void mcp2510_init(void) { ///////////// por software //////////////////////////
output_high(EXT_CAN_CS);
output_low(EXT_CAN_SCK);
#ifdef EXT_CAN_TX0RTS
output_high(EXT_CAN_TX0RTS);
#endif
#ifdef EXT_CAN_TX1RTS
output_high(EXT_CAN_TX1RTS);
#endif
#ifdef EXT_CAN_TX2RTS
output_high(EXT_CAN_TX2RTS);
#endif
#ifdef EXT_CAN_TX0RTS
output_high(EXT_CAN_RESET);
output_low(EXT_CAN_RESET);
output_high(EXT_CAN_RESET);
delay_ms(5);
#endif
mcp2510_command(0xC0); //reset
delay_ms(5);
} */
/////////////////////////////////////////////////////////////////
/////////////////////////////// por harware ////////////////////////////////////
void mcp2510_init(void) {
output_high(EXT_CAN_CS);
#ifdef EXT_CAN_TX0RTS
output_high(EXT_CAN_TX0RTS);
spi_write(); orden de escribir
#endif
#ifdef EXT_CAN_TX1RTS
output_high(EXT_CAN_TX1RTS);
#endif
#ifdef EXT_CAN_TX2RTS
output_high(EXT_CAN_TX2RTS);
#endif
#ifdef EXT_CAN_TX0RTS
output_high(EXT_CAN_RESET);
output_low(EXT_CAN_RESET);
output_high(EXT_CAN_RESET);
delay_ms(5);
#endif
mcp2510_command(0xC0); //reset
delay_ms(5);
}
/////////////////////////////////////////////////////////////////
Dejame organizarme y subire toda esa informacion aqui.
El codigo es de Microchip, asi que solo voy a subir el hex, para evitar lios con ellos, igual en su pagina esta el codigo fuente, para C18.
si, en efecto, eso lo hice por probar simplemente el envio de datos desde el MCP al PIC ( ne respuesat de éste claro) . He podido solucionarlo, aunque el problema de envio de can persiste.O sea que te comunicas con el MCP2515 pero no sale nada desde este hacia el BUS??
Aquí pueden descargar la memoria de mi proyecto:
memoria pdf (http://dl.getdropbox.com/u/913254/memoria%20sin%20portada.pdf)
Ahí se explica lo necesario sobre la normativa OBD, aunque no viene nada del código del PIC.
PD: Espero que les sea de ayuda, me ha llevado mucho tiempo hacer este proyecto y su memoria.
Aquí pueden descargar la memoria de mi proyecto:
memoria pdf (http://dl.getdropbox.com/u/913254/memoria%20sin%20portada.pdf)
Ahí se explica lo necesario sobre la normativa OBD, aunque no viene nada del código del PIC.
PD: Espero que les sea de ayuda, me ha llevado mucho tiempo hacer este proyecto y su memoria.
Hola a todos.
Estoy empezando ahora un proyecto consistente en realizar lecturas y escrituras del CAN-Bus con un PIC. Parece ser que hace cosa de unos 4 meses un miembro del foro colgó una memoria sobre un proyecto que tenía mucho que ver con esto. He intentado acceder a ella a través del link pero ya no se encuentra disponible...
Sería posible que algún miembro que disponga del documento lo volviera a colgar para que pudiera echarle un vistazo.
Muchísimas gracias de antemano.
Un cordial saludo.
Dejame organizarme y subire toda esa informacion aqui.
El codigo es de Microchip, asi que solo voy a subir el hex, para evitar lios con ellos, igual en su pagina esta el codigo fuente, para C18.
Me parece buena idea trabajar en equipo... Ya estare presentando avances con mi experiencias con los Dspic, por ahora estoy buscando los transceiver para poder arrancar... 8)
Me parece buena idea trabajar en equipo... Ya estare presentando avances con mi experiencias con los Dspic, por ahora estoy buscando los transceiver para poder arrancar... 8)
Hola buenos dias estimado colega, oye un placerver colegas de mi pais en el foro y mas en el tema de can bus, lastima que yo aun no toco los Dspic aun estoy en los pic18 esa gama aun para mi es uy avanzada pero todo a su tiempo espero proton trabajar con ellos; ahora encuanto a los trasceiver MCP2551 yo dispongo de varios cualquier cosa t puedo facilitar uno para que vayas trabajando en el tema y esta demas decirte que podemos hacerlo en conjunto.
Saludos y cualquier cosa me contactas amigo que estamos a la orden aunque estos dias estoy un poco alejado del tema pero por cuestion de animo solo no es facil uno se ladilla como decimos aca los enezolanos no hay nada mejor que tener conquien hablar del tema y presentarle tus ideas y avance y asi ambos se llenan de animo para continuar y como lo hacia yo en la universidad onerme retos para ver quien lo hacia mejor son retos sanos y dan mucho fruto ajajaja.
Atten.
Alexander Santana
Barcelona-Venezuela.
ok entonce seran dos.Me parece buena idea trabajar en equipo... Ya estare presentando avances con mi experiencias con los Dspic, por ahora estoy buscando los transceiver para poder arrancar... 8)
Hola buenos dias estimado colega, oye un placerver colegas de mi pais en el foro y mas en el tema de can bus, lastima que yo aun no toco los Dspic aun estoy en los pic18 esa gama aun para mi es uy avanzada pero todo a su tiempo espero proton trabajar con ellos; ahora encuanto a los trasceiver MCP2551 yo dispongo de varios cualquier cosa t puedo facilitar uno para que vayas trabajando en el tema y esta demas decirte que podemos hacerlo en conjunto.
Saludos y cualquier cosa me contactas amigo que estamos a la orden aunque estos dias estoy un poco alejado del tema pero por cuestion de animo solo no es facil uno se ladilla como decimos aca los enezolanos no hay nada mejor que tener conquien hablar del tema y presentarle tus ideas y avance y asi ambos se llenan de animo para continuar y como lo hacia yo en la universidad onerme retos para ver quien lo hacia mejor son retos sanos y dan mucho fruto ajajaja.
Atten.
Alexander Santana
Barcelona-Venezuela.
Je..Je... :mrgreen: :mrgreen:
Con uno no hace nada!! :D :D :D
No lo puedo creer!! no hay 1 solo MCP2551 en mi pueblo(ni ningun chip analogo de otra casa fabricante)..... si alguno sabe donde conseguirlos a traves de un proveedor , que me lo notifique por este medio... por favorrr. si quisieran ustedes mismos venderme unos tambien los acepto.... GRACIAS :mrgreen:.......................... :-/(necesito dos) :-/
Colega te anotaste 20 Puntos por ese altruismo !! no perdere mas tiempo... Mi direccion te la estare dejando en un privado mañana en la tarde . Espero esten trabajando las empresas de envio de paquetes para estos dias... GRACIAS AMIGO. :mrgreen:
char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
char Rx_Data_Len; // received data length in bytes
char RxTx_Data[8]; // can rx/tx data buffer
char Msg_Rcvd; // reception flag
long Tx_ID, Rx_ID; // can rx and tx ID
char ErrorCount;
// CANSPI module connections
sbit CanSpi_CS at PORTB.B0; // Chip select (CS) pin for CANSPI board
sbit CanSpi_CS_Direction at DDRB.B0; // Direction register for CS pin
sbit CanSpi_Rst at PORTB.B2; // Reset pin for CANSPI board
sbit CanSpi_Rst_Direction at DDRB.B2; // Direction register for Reset pin
// End CANSPI module connections
void main(){
ADCSRA.B7 = 0; // Configure analog pins as digital I/O
PORTB = 0; DDRB = 255; // Initialize ports
PORTD = 0; DDRD = 255;
PORTC = 0; DDRC = 255;
ErrorCount = 0; // Error flag
Can_Init_Flags = 0; Can_Send_Flags = 0; Can_Rcv_Flags = 0; // clear flags
Can_Send_Flags = _CANSPI_TX_PRIORITY_0 & // form value to be used
_CANSPI_TX_XTD_FRAME & // with CANSPIWrite
_CANSPI_TX_NO_RTR_FRAME;
Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE & // form value to be used
_CANSPI_CONFIG_PHSEG2_PRG_ON & // with CANSPIInit
_CANSPI_CONFIG_XTD_MSG &
_CANSPI_CONFIG_DBL_BUFFER_ON &
_CANSPI_CONFIG_VALID_XTD_MSG;
SPI1_Init();
Spi_Rd_Ptr = SPI1_Read; // initialize SPI module
CANSPIInitialize(1, 3, 3, 3, 1, Can_Init_Flags); // Initialize external CANSPI module
CANSPISetOperationMode(_CANSPI_MODE_CONFIG, 0xFF); // set CONFIGURATION mode
CANSPISetMask(_CANSPI_MASK_B1, -1, _CANSPI_CONFIG_XTD_MSG); // set all mask1 bits to ones
CANSPISetMask(_CANSPI_MASK_B2, -1, _CANSPI_CONFIG_XTD_MSG); // set all mask2 bits to ones
CANSPISetFilter(_CANSPI_FILTER_B2_F4, 0x12, _CANSPI_CONFIG_XTD_MSG); // Node1 accepts messages with ID 0x12
CANSPISetFilter(_CANSPI_FILTER_B1_F1, 0x13, _CANSPI_CONFIG_XTD_MSG); // Node1 accepts messages with ID 0x13
CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF); // set NORMAL mode
RxTx_Data[0] = 0x40; // set initial data to be sent
Tx_ID = 0x10; // set transmit ID for CAN message
CANSPIWrite(Tx_ID, &RxTx_Data, 1, Can_Send_Flags); // Node1 sends initial message
while (1) // endless loop
{
Msg_Rcvd = CANSPIRead(&Rx_ID, RxTx_Data, &Rx_Data_Len, &Can_Rcv_Flags); // attempt receive message
if (Msg_Rcvd) { // if message is received then check id
if (Rx_ID == 0x12) // check ID
PORTC = RxTx_Data[0]; // output data at PORTC
else
PORTD = RxTx_Data[0]; // output data at PORTD
Delay_ms(50); // wait for a while between messages
CANSPIWrite(Tx_ID, RxTx_Data, 1, Can_Send_Flags); // send one byte of data
Tx_ID++; // switch to next message
if (Tx_ID > 0x11) Tx_ID = 0x10; // check overflow
}
else { // an error occured, wait for a while
ErrorCount++; // increment error indicator
Delay_ms(10); // wait for 10ms
if (ErrorCount > 10) { // timeout expired - process errors
ErrorCount = 0; // reset error counter
Tx_ID++; // switch to another message
if (Tx_ID > 0x11) Tx_ID = 0x10; // check overflow
CANSPIWrite(Tx_ID, RxTx_Data, 1, Can_Send_Flags); // send new message
}
}
}
}
unsigned int aa, aa1, len, aa2,data;
unsigned long id;
unsigned int zr;
void int_INT1 () org 0x34 //Funcion de INT1
{
PORTFbits.RF4=1;
delay_ms(3000);
data=PORTEbits.RE1;
delay_ms(1000);
PORTB=data;
delay_ms(1000);
id=2;
CAN1Write(id,data,1,aa1);
IFS1bits.INT1IF = 0; //Desahabilitar bandera de INT1
}
void int_INT2 () org 0x42 //Funcion de INT2
{
PORTFbits.RF5=1;
delay_ms(3000);
data=PORTEbits.RE2;
delay_ms(1000);
PORTB=data;
delay_ms(1000);
id=2;
CAN1Write(id,data,1,aa1);
IFS1bits.INT2IF = 0; //Desahabilitar bandera de INT2
}
void main()
{
ADPCFG=0xFFFF; //Configurar E/S como digitales
TRISB=0; //Puert B como salida
TRISD=3; //RD1-RD0 como entradas
TRISE=0xFF; //RE como entrada
TRISF = 0;
aa = 0;
aa1 = 0;
aa2 = 0;
INTCON1bits.NSTDIS = 1; //Deshabilitar interrupciones anidadas
INTCON2bits.ALTIVT = 0; //Deshabilitar la AIVT
INTCON2bits.INT1EP = 1; //Activacion de INT1 por flanco de bajada
INTCON2bits.INT2EP = 1; //Activacion de INT2 por flanco de bajada
IEC1bits.INT1IE = 1; //Habilitar INT1
IFS1bits.INT1IF = 0; //Desactivar bandera de INT1
IEC1bits.INT2IE = 1; //Habilitar INT2
IFS1bits.INT2IF = 0; //Desactivar bandera de INT2
aa1 = CAN_TX_PRIORITY_0 & // Form value to be used
CAN_TX_XTD_FRAME & // with CANSendMessage
CAN_TX_NO_RTR_FRAME;
aa = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_MATCH_MSG_TYPE &
CAN_CONFIG_ALL_VALID_MSG &
CAN_CONFIG_LINE_FILTER_OFF;
data = 0;
CAN1Initialize(1,3,3,3,1,aa); // initialize CAN
CAN1SetOperationMode(CAN_MODE_CONFIG,0x00); // set CONFIGURATION mode
id = -1;
CAN1SetMask(CAN_MASK_B1,id,CAN_CONFIG_MATCH_MSG_TYPE & CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CAN1SetMask(CAN_MASK_B2,id,CAN_CONFIG_MATCH_MSG_TYPE & CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CAN1SetFilter(CAN_FILTER_B1_F1,1,CAN_CONFIG_XTD_MSG); // set id of filter B1_F1 to 3
CAN1SetOperationMode(CAN_MODE_NORMAL,0x00); // set NORMAL mode
while(1)
{
PORTB=0;
PORTF=0;
zr = CAN1Read(&id , data , &len, &aa2);
if ((id == 1) && zr) {
PORTB = data; // output data at portC
Delay_ms(8000);
}
}
}
unsigned int aa, aa1, len, aa2,data;
unsigned long id;
unsigned int zr;
void int_INT1 () org 0x34 //Funcion de INT1
{
PORTFbits.RF4=1;
delay_ms(3000);
data=PORTEbits.RE1;
delay_ms(1000);
PORTB=data;
delay_ms(1000);
id=1;
CAN1Write(id,data,1,aa1);
IFS1bits.INT1IF = 0; //Desahabilitar bandera de INT1
}
void int_INT2 () org 0x42 //Funcion de INT2
{
PORTFbits.RF5=1;
delay_ms(3000);
data=PORTEbits.RE2;
delay_ms(1000);
PORTB=data;
delay_ms(1000);
id=1;
CAN1Write(id,data,1,aa1);
IFS1bits.INT2IF = 0;
}
void main()
{
ADPCFG=0xFFFF; //Configurar E/S como digitales
TRISB=0; //Puert B como salida
TRISD=3; //RD1-RD0 como entradas
TRISE=0xFF; //RE como entrada
TRISF = 0;
aa = 0;
aa1 = 0;
aa2 = 0;
INTCON1bits.NSTDIS = 1; //Deshabilitar interrupciones anidadas
INTCON2bits.ALTIVT = 0; //Deshabilitar la AIVT
INTCON2bits.INT1EP = 1; //Activacion de INT1 por flanco de bajada
INTCON2bits.INT2EP = 1; //Activacion de INT2 por flanco de bajada
IEC1bits.INT1IE = 1; //Habilitar INT1
IFS1bits.INT1IF = 0; //Desactivar bandera de INT1
IEC1bits.INT2IE = 1; //Habilitar INT2
IFS1bits.INT2IF = 0; //Desactivar bandera de INT2
aa1 = CAN_TX_PRIORITY_0 & // Form value to be used
CAN_TX_XTD_FRAME & // with CANSendMessage
CAN_TX_NO_RTR_FRAME;
aa = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_MATCH_MSG_TYPE &
CAN_CONFIG_LINE_FILTER_OFF;
data = 0;
CAN1Initialize(1,3,3,3,1,aa); // initialize CAN
CAN1SetOperationMode(CAN_MODE_CONFIG,0x00); // set CONFIGURATION mode
id = -1;
CAN1SetMask(CAN_MASK_B1,id,CAN_CONFIG_MATCH_MSG_TYPE & CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CAN1SetMask(CAN_MASK_B2,id,CAN_CONFIG_MATCH_MSG_TYPE & CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CAN1SetFilter(CAN_FILTER_B2_F3,2,CAN_CONFIG_XTD_MSG); // set id of filter B1_F1 to 3
CAN1SetOperationMode(CAN_MODE_NORMAL,0x00); // set NORMAL mode
while(1)
{
PORTB=0;
PORTF=0;
zr = CAN1Read(&id , data , &len, &aa2);
if ((id == 2) && zr) {
PORTB = data; // output data at portC
Delay_ms(8000);
}
}
}
Les pido su ayuda escribi estos codigos para establecer una red de 2 nodos, cada nodo deberia enviar y recibir, y no tengo transceiver asi que conecte el TX de un DSPIC30f4011 con el RX del otro y viceversa. Pero no me funciona!!!!! no entiendo, que puedo hacer para saber si el pin Tx esta enviando algo ?? porque el mio siempre esta activado. Confused
Proteus NO simula CAN, no tiene libreria del MCP2551 ni algun otro Transceiver de CAN.
Como el transceiver resuelve una buena parte del protocolo, es imposible simularlo en Proteus.
Con razon.... gracias por la aclaratoria y no hacerme perder mas el tiempo sin el transceiver..... :D
unsigned char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len; // received data length in bytes
char RxTx_Data[8]; // can rx/tx data buffer
char Msg_Rcvd; // reception flag
const long ID_1st = 12111, ID_2nd = 3; // node IDs
long Rx_ID;
void main() {
PORTC = 0; // clear PORTC
TRISC = 0; // set PORTC as output
Can_Init_Flags = 0; //
Can_Send_Flags = 0; // clear flags
Can_Rcv_Flags = 0; //
Can_Send_Flags = _CAN_TX_PRIORITY_0 & // form value to be used
_CAN_TX_XTD_FRAME & // with CANWrite
_CAN_TX_NO_RTR_FRAME;
Can_Init_Flags = _CAN_CONFIG_SAMPLE_THRICE & // form value to be used
_CAN_CONFIG_PHSEG2_PRG_ON & // with CANInit
_CAN_CONFIG_XTD_MSG &
_CAN_CONFIG_DBL_BUFFER_ON &
_CAN_CONFIG_VALID_XTD_MSG;
CANInitialize(1,3,3,3,1,Can_Init_Flags); // Initialize CAN module
CANSetOperationMode(_CAN_MODE_CONFIG,0xFF); // set CONFIGURATION mode
CANSetMask(_CAN_MASK_B1,-1,_CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CANSetMask(_CAN_MASK_B2,-1,_CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CANSetFilter(_CAN_FILTER_B2_F4,ID_2nd,_CAN_CONFIG_XTD_MSG);// set id of filter B2_F4 to 2nd node ID
CANSetOperationMode(_CAN_MODE_NORMAL,0xFF); // set NORMAL mode
RxTx_Data[0] = 9; // set initial data to be sent
CANWrite(ID_1st, RxTx_Data, 1, Can_Send_Flags); // send initial message
while(1) { // endless loop
Msg_Rcvd = CANRead(&Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags); // receive message
if ((Rx_ID == ID_2nd) && Msg_Rcvd) { // if message received check id
PORTC = RxTx_Data[0]; // id correct, output data at PORTC
RxTx_Data[0]++; // increment received data
Delay_ms(10);
CANWrite(ID_1st, RxTx_Data, 1, Can_Send_Flags); // send incremented data back
}
}
}
Can_Send_Flags = _CAN_TX_PRIORITY_0 & // form value to be used
_CAN_TX_XTD_FRAME & // with CANWrite
_CAN_TX_NO_RTR_FRAME;
Hola buenos dias, aca te dejo un link de la pagina del colega Jim miembro de este foro, yo dispongo de uno m0odulo de la gente de mikroelektronika pero este al cual hago referencia lo mejor es que contamos con su creador en este mismo foro ladtima que no la vi antes para comprarlo y lo otro es que aun no no me dedico por completo al can bus tengo ya material y documentacion para empézar el tema pero simple poc¿r cuestiones de tiempo y ocupaciones laborales y personales no arranco de una ves en el tema pero te guste y nos comente tu opinion sobre este modulo can.
CAN BUS
« : 21 de Mayo de 2010, 03:04:47 »
Responder con cita Modificar mensaje
Hola a tods!!!
Quiero iniciarme en la comunicación serie entre dos pics, concretamente me ha llamado la atención la flexibilidad del CAN y mi primera gran duda es ¿que targeta de desarrollo puedo utilizar?, ya que iniciar realizando yo una propia resulta pesado. he
Ya he visto varios hilos sobre este bus, cuya información ha sido estupenda para un neofito en el tema, y veo que hablais del
MCP2515 CAN BusMonitor Demo Board Kit.
¿Os parece apropiado? ¿Es compatible con mi compilador de CCS?
He planteado este tema en el subforo general de programación en C y además de djarme un poko de código para saciar mi inquietud, me han remitido aqui.
Gracias de antemano, necesito una board para comenzar a probar programitas.
aa = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_MATCH_MSG_TYPE &
CAN_CONFIG_LINE_FILTER_OFF;
data[0] = 9;
CAN1Initialize(1,3,3,3,1,aa);
hola compañeros aparezco de nuevo, y de nuevo con nuevas dudas...Hola.
estoy trabajando con un cristal de 10Mhz, esto afectaria este codigo que saque de "mikroC for dspic"Código: [Seleccionar]aa = CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
CAN_CONFIG_PHSEG2_PRG_ON & // with CANInitialize
CAN_CONFIG_STD_MSG &
CAN_CONFIG_DBL_BUFFER_ON &
CAN_CONFIG_MATCH_MSG_TYPE &
CAN_CONFIG_LINE_FILTER_OFF;
data[0] = 9;
CAN1Initialize(1,3,3,3,1,aa);
en realidad no entiendo muy el significado de cada bit.... esos (1,3,3,3,1,aa)???? porque???
que significan??
tienen que ver con el cristal que uso???, como lo configuro para un cristal de 10Mhz???
les pido ayuda
Me han pasado una libreria de comunicaciones basada en CANOpen, y debo programar el controlador de una placa para controlar una serie de sensores. Estoy a la espera de que me den el PIC sobre el que se va a realizar el trabajo.
Dispongo de dos herramientas: el CAN Analyzer y el CAN Case XL.Que envidia!! :mrgreen: :mrgreen: :mrgreen:
No tengo experiencia en la programacion de PIC's, por lo que os pido consejo sobre cuales serian los primeros pasos que debo realizar y que documentacion debo ir mirando primero.En este hilo puedes aprender los conceptos de CAN, que va a ser la capa fisica de tu proyecto, sugiero que intentes guiarte con el Indice del primer Post, ya que leerlo completo te llevaria bastante y en el indice intente llevar la tematica mas importante sobre CAN Bus.
Segun he visto por Internet, es necesario usar el software CANOpen Design Tool y el CANOpen Device Manager...¿me equivoco?Seguramente esas herramientas te garantizaran hacer una aplicacion seria y sin olvidarte detalles importantes de diseño.
Otro aspecto que me gustaria aclarar, es si el compilador que debo usar es el CCS.
void can_set_baud(void){
#ifdef Set_125K_Baud {
BRGCON1 = 0x01;
BRGCON2 = 0xB8; //modificado 17/07/10 para usar CAN a 125 KBps
BRGCON3 = 0x05; //con reloj a 8 MHz
}
#endif
#ifdef Set_250K_Baud {
BRGCON1 = 0x00;
BRGCON2 = 0xB8; //modificado 17/07/10 para usar CAN a 250 KBps
BRGCON3 = 0x05; //con reloj a 8 MHz
}
#endif
#ifdef Set_500K_Baud {
BRGCON1 = 0x00;
BRGCON2 = 0x90; //modificado 17/07/10 para usar CAN a 500 KBps
BRGCON3 = 0x02; //con reloj a 8 MHz
}
#endif
}
//CANMASTER.C
#include "18F4550.h"
#include "can-mcp251x.c"
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,NOBROWNOUT,PLL2,CPUDIV1,VREGEN,PUT,MCLR
#use delay(clock=8000000)
#define ON output_high
#define BUTTON PIN_B2
#define OFF output_low
#define BUTTON_PRESSED !input(BUTTON)
#define LEDV pin_B0
#define LEDR pin_B1
#define CAN_DO_DEBUG TRUE
#define set_250k_Baud TRUE
// Variables send can bus
struct rx_stat rxstat;
int32 rx_id;
int8 rx_len;
// Variables reception can bus
int32 tx_id;
int1 tx_rtr=0;
int1 tx_ext=1;
int8 tx_len=8;
int8 tx_pri=3;
int32 id=0;
int32 rx_id_resp=0;
int8 datos_slave=0;
int8 datos = 1
// Other variables
//int1 flag_rcvtrama=0;
//int8 rcvchar=0;
int u;
int e;
void main()
{
disable_interrupts(GLOBAL);
disable_interrupts(INT_TIMER0);
setup_timer_0(RTCC_DIV_2);
enable_interrupts(GLOBAL);
rx_id_resp=3; //id del esclavo, del que quiero recibir datos (para el ejmplo el único que hay)
tx_id=1;//id del maestro
ON(LedR);
OFF(LedV);
delay_ms(1000);
can_init(); // Init can bus
ON(LedV);
OFF(LedR);
delay_ms(1000);
OFF(LedV);
OFF(LedR);
for(e=0;e<8;e++){
datos[e]=1;
}
for(u=0;u<8;u++){
datos_slave[i]=1;
}
///////////////////////////////////////main
while(TRUE)
{
if(can_kbhit())
{
can_getd(rx_id, &datos_slave[0], rx_len, rxstat); // read data can bus
if(rx_id_resp==rx_id)
{
disable interrupts(INT_TIMER0);
OFF (LedR);
ON (LedV);
delay_ms(2000);
OFF (LedV);
}
}
if(BUTTON_PRESSED)
{
while(BUTTON_PRESSED){}
delay_ms(200);
can_putd(tx_id,&datos[0],1,1,0,0);//send a byte=0xFF
}
}//while
}//main
#int_Timer0 // if after 10ms from the sending no data is received, indicate the failure of communications lighting the red LED
void timer0(void)
{
disable_interrupts(INT_TIMER0);
ON(LedR);
}
Hola MGLSOFT!!!!
Mis protoboards son de "Microingenia", fabulosas, por cierto.
No probe los ejemplos tal cual, ya que es para una comunicación usb-can.
Lo que pretendo es hacerla, can-can.
Más tarde, en cuanto el trabajo me lo permita, pongo el código del SLAVE y por supuesto desde aquí seguiré probando y probando.
Muchas gracias por tu interés.... Seré el ser más feliz del mundo cuando vea prender esos leds.
Atentamente, un saludo
hola; estoy probando, pero tengo algún que otro problemilla. En cuanto salga algo, lo comparto.Que tipo de problemitas??
Saludos y muchas gracias MGLSOFT
//CANMASTER.C
#include "config18F4550Trainer.c"
#include "usb/usb_cdc.h"
#include "usb/usb_bootloader.h"
#include "can/can-mcp251x.c"
#define BUTTON PIN_B2
#define BUTTON_PRESSED !input(BUTTON)
// Variables send can bus
struct rx_stat rxstat;
int32 rx_id;
int8 rx_len;
// Variables reception can bus
int32 tx_id;
int1 tx_rtr=0;
int1 tx_ext=1;
int8 tx_len=7;
int8 tx_pri=3;
int32 id=0;//del maestro
int32 rx_id_esclavo=1;
int8 datos=0;
int8 datos_slave=0;
void main()
{
tx_id=id;
disable_interrupts(GLOBAL);
disable_interrupts(INT_TIMER0);
setup_timer_0(RTCC_DIV_2);
enable_interrupts(GLOBAL);
datos=0xFF;
ON(LEDV);
OFF(LEDR);
delay_ms(800);
ON(LedR);
OFF(LedV);
delay_ms(800);
ON(LedV);
OFF(LedR);
can_init(); // Init can bus
while(TRUE)
{
if(can_kbhit())
{
can_getd(rx_id, &datos_slave, rx_len, rxstat); // read data can bus
if(rx_id_esclavo==rx_id)
{
disable_interrupts(INT_TIMER0);
ON (LedR);
ON (LedV);//verde&rojo=amarillo
delay_ms(2000);
OFF (LedR);
OFF (LedV);
}
}
if(BUTTON_PRESSED)
{
while(BUTTON_PRESSED){}
delay_ms(200);
can_putd(tx_id,&datos,tx_len,tx_pri,tx_ext,tx_rtr);//send a byte=0xFF
}
}//while
}//main
#int_Timer0 // if after 10ms from the sending no data is received, indicate the failure of communications lighting the red LED
void timer0(void)
{
disable_interrupts(INT_TIMER0);
ON(LedR);
}
//CANSLAVE
#include "config18F4550Trainer.c"
#include "usb/usb_cdc.h"
#include "usb/usb_bootloader.h"
#include "can/can-mcp251x.c"
//#use fast_io(D)
// Variables send can bus
struct rx_stat rxstat;
int32 rx_id;
int8 rx_len;
// Variables reception can bus
int32 tx_id;
int1 tx_rtr=0;
int1 tx_ext=1;
int8 tx_len=7;
int8 tx_pri=3;
int32 rx_id_maestro=0;
int32 id = 1;//del esclavo
int8 datos = 0;
int8 datos_slave=0;
void main()
{
tx_id=id;
datos_slave=0x01;
can_init(); // Init can bus
ON(LedV);
OFF(LedR);
while(TRUE)
{
if ( can_kbhit() ) // check for data on the can bus
{
can_getd(rx_id, &datos, rx_len, rxstat); // read data can bus
if (rx_id_maestro == rx_id)
{
OFF(LedV);
ON (LedR);
ON (pin_D0);
ON (pin_D1);
ON (pin_D2);
ON (pin_D3);
ON (pin_D4);
ON (pin_D5);
ON (pin_D6);
ON (pin_D7);
delay_ms(4000);
OFF (LedR);
OFF (pin_D0);
OFF (pin_D1);
OFF (pin_D2);
OFF(pin_D3);
OFF (pin_D4);
OFF (pin_D5);
OFF (pin_D6);
OFF (pin_D7);
}
can_putd(tx_id, &datos_slave, tx_len,tx_pri,tx_ext,tx_rtr); //acuse de recibo
}
}
}
output_D(datos);
PORTD=0XFF; // un ejemplo
PORTD=datos;//otro ejemplo que con output_D() si tiene efecto
#use standard_io(D)
#byte PORTD = 0x00
no se si es correcto;PORTD=datos[0]
, no va.SFR:name
Returns the address of the specified special file register. The output format can be used with the preprocessor command #bit. name must match SFR denomination of your target PIC (example: STATUS, INTCON, TXREG, RCREG, etc)
Hola a todos.
Trabajo en un departamento de investigacion, y estamos trabanjando con un robot con una serie de sensores controlados mediante bus CAN.
Me han encargado realizar el siguiente trabajo:
Me han pasado una libreria de comunicaciones basada en CANOpen, y debo programar el controlador de una placa para controlar una serie de sensores. Estoy a la espera de que me den el PIC sobre el que se va a realizar el trabajo.
Dispongo de dos herramientas: el CAN Analyzer y el CAN Case XL.
No tengo experiencia en la programacion de PIC's, por lo que os pido consejo sobre cuales serian los primeros pasos que debo realizar y que documentacion debo ir mirando primero.
Segun he visto por Internet, es necesario usar el software CANOpen Design Tool y el CANOpen Device Manager...¿me equivoco?
Otro aspecto que me gustaria aclarar, es si el compilador que debo usar es el CCS.
Un saludo, y espero vuestra ayuda en forma de comentarios.
Muchas gracias
Hola
Ante todo, muchas gracias por contestar, he buscado mucho por internet, y sin duda este es el mejor foro (y casi puedo decir unico) que trata Bus CAN que he encontrado.
Bien, en estos dias he progresado bastante sobre la programacion de PIC's en C. Buscando tutoriales sobre programacion en C de PIC's y practicas resueltas, he conseguido avanzar bastante sobre el uso de los puertos, transmision serie (USART), interrupciones, etc
Hablando con mi profesor, me recomendo usar el CCS, por lo que creo que ya es un poco tarde para cambiar de compilador :S, sin embargo, espero que esto no sea una gran trava para conseguir el objetivo!!
Todos las practicas que he hecho para familiarizarme con los PIC's las he realizado en CCS y usando el simulador PROTEUS.
Pero aun veo bastante lejos el poder programar un protocolo de comunicaciones basado en CAN sobre la placa.
Bien, empiezo a contarte:
La libreria que tengo es una que se ha comprado a la empresa alemana PORT, y me ha comentado que vale una pasta, por lo que aunque a mi no me importaria, comprenderas que me es imposible pasarla.
El objetivo global de nuestro proyecto, es controlar todos los sensores mediante CAN de un robot autonomo que realiza las funciones de un camion de bomberos.
Actualmente ya hay implementado un protocolo sobre J1939, por lo que lo primero que he hecho ha sido pedir dicho programa, para ver aspectos comunes que puedan ser reutilizados. Ya tengo este programa en mis manos.
Lo siguiente ha sido pedir el diseño de la placa sobre la que va a ir montado CANOpen, en formato electronico, para poder realizar simulaciones con el PROTEUS, ya que la placa, fisicamente hablando aun no esta terminada. Aun estoy a la espera de que me lo pasen. El pic que se va a utilizar es un PIC 18f2680, que cumple con los requisitos que me indicastes.
La norma CANOPen ya me la he leido, fue lo primero que hice.
Pues bien, voy a seguir tus indicaciones, y en los proximos dias voy a mirarme los post que considero que pueden ser mas interesantes. En cuanto a la nota que me dices de Microchip, he estado buscando, pero no se muy bien a cual te refieres...si pudieses pasarme el enlace...
Pero es que la comunicacion mediante CANOpen se basa en aspectos muy diferentes a los que se habla a lo largo de las 42 paginas de este foro.
El modelo de comunicaciones CANOpen define 4 tipos de mensajes (objetos de comunicacion):
- Objetos administrativos: mensajes para la configuracion de las distintas capas de la red asi como la inicializacion.
- Service Data Objetcts (SDO): leer o escribir cualquiera de las entradas del diccionario de objetos
- Process Data Object (PDO): para el intercambio de datos de proceso
- Mensajes predefinidos: de sincronizacion, de emergencia y de time stamp.
La placa de la que dispongo consta de un PIC18F2680, un transceiver MCP2551, la interfaz RS-232: MAX3232, un regulador de voltaje, etc
Tengo el diseño imprimido en una pagina, pero no en formato electronico...pero podria conseguirlo
Una pregunta...si mi placa es la que va a controlar los sensores y recoger la informacion que estos den, sera un master CANOpen, no un esclavo no?
Lo que quiero es empezar a programar algo ya, por lo tanto te pediria que me indicases por favor, que seria lo que haria falta para realizar una simple comunicacion CANOpen entre mi placa y el sensor, y entonces vemos las funciones de la libreria que serian necesarias.
Miguel Angel
Pero tengo una duda, el hardware que trae estas herramientas, tiene un conector con el mismo tipo de salida CANL y CANH que trae la placa. ¿Como lo conecto entonces para monitorizar las tramas que voy a estar mandando?
No te he entendido bien Marcos...el conector no me permite unir CANH con CANH y CANL con CANL. Debo quitar el conector del hardware que te mostre anteriormente y retorcer los cables en las salidas del conector CAN de la placa??
No se muy bien lo que quieres decir....
El archivo al que está intentando acceder está temporalmente desactivado.
Esta es la contestacion de Megaupload:CitarEl archivo al que está intentando acceder está temporalmente desactivado.
Bueno, simplemente habria que cambiar la configuracion de hardware, en la pestaña correspondiente, no? En vez de un freescale, habria que poner en CPU Settings la familia Microchip PIC...
¿Que te parecen los objetos que se crean para el diccionario? ¿Son suficientes para realizar una rutina CANOpen con un minimo de funcionalidad?
¿Has generado los archivos necesarios que habra que incluir en el codigo a realizar?
Tengo otra pregunta, que es necesaria para aclarar conceptos:
Yo anteriormente habia realizado una aplicacion que corre en el PC para monitorizar las tramas de un protocolo J1939 que ya estaba implementado por otra persona. Cuando termine de implementar el protocolo CANOpen, debere ampliar esa aplicacion para que tambien monitorice las tramas enviadas usando este protocolo. Esta aplicacion se comunica con los sensores y la placa donde estaba montado el j1939 por puerto serie, y de la misma forma lo hara con la placa sobre la que va a ir montada CANOpen.
Entonces, la pregunta es: ¿Quien es aqui el esclavo, y quien es el maestro?
Es una cuestion que no tengo clara totalmente y me gustaria conocer para evitar cualquier tipo de confusion.
Weno Marcos, espero tu respuestaaa!!
Un saludoo desde España
No uso C18 ni MPLAB, sino el compilador de CCS.Creo que malinterpretaste mi respuesta.
En el mi caso de mi proyecto, no hay apuro de tiempo. Simplemente, estoy trabajando en ello cada dia, y por eso contesto pronto, pero no exigo nada a los miembros de este foro, ni mucho menos.
Se que CANOpen es un protocolo complejo, y que no es trivial implementar algo que sea funcional. Si no te interesa continuar aportando tus consejos, lo entendere.
Un saludo
Miguel Angel
De acuerdo. Me bajado el IDE y el compilador de MPLAB C18. Lo voy a compilar y te cuento resultados.
¿Quieres que suba el main.c para que le eches un vistazo?
Bueno, pues muchas gracias por tus ganas y por no desesperarte conmigo :D
Buenas... Estoy queriendo empezar a hacer algunas maldades en CAN, simple, un maestro PC con uno o 2 esclavos por ahora, la interface con la pc la quiero hacer por USB, asi que voy a poner un 18F250, un mcp 2551 y un mcp 2515, les pongo un esquema de lo que pense hasta ahora, quiero que me sugieran, los que tienen mas experiencia en CAN, si falta algo, o como lo ven.La parte de CAN esta bien, solo me aseguraria de entrar con el pin de interrupcion del MCP2515 a algun pin con interrupcion del PIC, asi se te puede simplificar la tarea en vez de hacer poolling simplemente cada vez que interrumpe vas a leer.
Desde ya Gracias.
Alejandro
Debug build of project `C:\Documents and Settings\Administrador\Escritorio\otro\otro.mcp' started.
Language tool versions: mpasmwin.exe v5.37, mplink.exe v4.37, mcc18.exe v3.36, mplib.exe v4.37
Preprocessor symbol `__DEBUG' is defined.
Tue Sep 07 11:59:08 2010
----------------------------------------------------------------------
Clean: Deleting intermediary and output files.
Clean: Done.
Executing: "C:\MCC18\bin\mcc18.exe" -p=18F2680 /i"C:\Documents and Settings\Administrador\Escritorio\CANOPEN (Controller Area Network)\CD LIBRERIA CANOPEN\3_DPMicroChipPIC18F2680\drivers\pic18f" -I"C:\port\CANopenLibrary\canopen\include" "co_init.c" -fo="co_init.o" -D__DEBUG -Ou- -Ot- -Ob- -Op- -Or- -Od- -Opa-
MPLAB C18 v3.36 (evaluation)
Copyright 2000-2010 Microchip Technology Inc.
Days remaining until evaluation becomes feature limited: 60
Executing: "C:\MCC18\bin\mcc18.exe" -p=18F2680 /i"C:\Documents and Settings\Administrador\Escritorio\CANOPEN (Controller Area Network)\CD LIBRERIA CANOPEN\3_DPMicroChipPIC18F2680\drivers\pic18f" -I"C:\port\CANopenLibrary\canopen\include" "main.c" -fo="main.o" -D__DEBUG -Ou- -Ot- -Ob- -Op- -Or- -Od- -Opa-
MPLAB C18 v3.36 (evaluation)
Copyright 2000-2010 Microchip Technology Inc.
Days remaining until evaluation becomes feature limited: 60
C:\Documents and Settings\Administrador\Escritorio\otro\main.c:215:Warning [2103] default startup code expects main function declared as 'void main (void)'
C:\Documents and Settings\Administrador\Escritorio\otro\main.c:251:Warning [2066] type qualifier mismatch in assignment
C:\Documents and Settings\Administrador\Escritorio\otro\main.c:260:Warning [2058] call of function without prototype
C:\Documents and Settings\Administrador\Escritorio\otro\main.c:271:Warning [2066] type qualifier mismatch in assignment
C:\Documents and Settings\Administrador\Escritorio\otro\main.c:281:Warning [2066] type qualifier mismatch in assignment
C:\Documents and Settings\Administrador\Escritorio\otro\main.c:289:Warning [2058] call of function without prototype
Executing: "C:\MCC18\bin\mcc18.exe" -p=18F2680 /i"C:\Documents and Settings\Administrador\Escritorio\CANOPEN (Controller Area Network)\CD LIBRERIA CANOPEN\3_DPMicroChipPIC18F2680\drivers\pic18f" -I"C:\port\CANopenLibrary\canopen\include" "objects.c" -fo="objects.o" -D__DEBUG -Ou- -Ot- -Ob- -Op- -Or- -Od- -Opa-
MPLAB C18 v3.36 (evaluation)
Copyright 2000-2010 Microchip Technology Inc.
Days remaining until evaluation becomes feature limited: 60
Executing: "C:\MCC18\bin\mplink.exe" /p18F2680 /l"C:\MCC18\lib" /k"C:\MCC18\bin\LKR" "co_init.o" "main.o" "objects.o" /u_CRUNTIME /u_DEBUG /z__MPLAB_BUILD=1 /z__MPLAB_DEBUG=1 /o"otro.cof" /M"otro.map" /W
MPLINK 4.37, Linker
Copyright (c) 1998-2010 Microchip Technology Inc.
Error - could not find definition of symbol 'createNodeReq' in file './co_init.o'.
Errors : 1
Link step failed.
----------------------------------------------------------------------
Debug build of project `C:\Documents and Settings\Administrador\Escritorio\otro\otro.mcp' failed.
Language tool versions: mpasmwin.exe v5.37, mplink.exe v4.37, mcc18.exe v3.36, mplib.exe v4.37
Preprocessor symbol `__DEBUG' is defined.
Tue Sep 07 11:59:09 2010
----------------------------------------------------------------------
BUILD FAILED
/////////////////////////////////////////////////////////////////////////
//// can-18F4580.c ////
/////////////////////////////////////////////////////////////////////////
//// ////
//// Version History ////
//// ////
//// Jul 27 04 - can_init() uses CAN_USE_EXTENDED_ID instead of ////
//// setting all RX filters to extended. ////
//// ////
//// Feb 24 04 - can_get_id() fixed for EID<18:20>. ////
//// ////
/////////////////////////////////////////////////////////////////////////
#include <can-18F4580.h>
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
#if CAN_DO_DEBUG
#define can_debug printf
#else
#define can_debug
#endif
//macros
#define can_kbhit() (RXB0CON.rxful || RXB1CON.rxful || B0CONR.rxful || B1CONR.rxful || B2CONR.rxful || B3CONR.rxful || B4CONR.rxful || B5CONR.rxful)
#define can_tbe() (!TXB0CON.txreq || !TXB1CON.txreq || !TXB2CON.txreq || !B0CONT.txreq || !B1CONT.txreq || !B2CONT.txreq || !B3CONT.txreq || !B4CONT.txreq || !B5CONT.txreq)
#define can_abort() (CANCON.abat=1)
// current mode variable
// used by many of the device drivers to prevent damage from the mode
//
int curmode;
int curfunmode;
////////////////////////////////////////////////////////////////////////
//
// can_init()
//
//////////////////////////////////////////////////////////////////////////////
void can_init(void) {
can_set_mode(CAN_OP_CONFIG); //must be in config mode before params can be set
can_set_baud();
curfunmode=0;
RXB0CON=0;
RXB0CON.rxm=CAN_RX_VALID;
RXB0CON.rxb0dben=CAN_USE_RX_DOUBLE_BUFFER;
RXB1CON=RXB0CON;
CIOCON.endrhi=CAN_ENABLE_DRIVE_HIGH;
CIOCON.cancap=CAN_ENABLE_CAN_CAPTURE;
can_set_id(RX0MASK, CAN_MASK_ACCEPT_ALL, CAN_USE_EXTENDED_ID); //set mask 0
can_set_id(RXFILTER0, 0, CAN_USE_EXTENDED_ID); //set filter 0 of mask 0
can_set_id(RXFILTER1, 0, CAN_USE_EXTENDED_ID); //set filter 1 of mask 0
can_set_id(RX1MASK, CAN_MASK_ACCEPT_ALL, CAN_USE_EXTENDED_ID); //set mask 1
can_set_id(RXFILTER2, 0, CAN_USE_EXTENDED_ID); //set filter 0 of mask 1
can_set_id(RXFILTER3, 0, CAN_USE_EXTENDED_ID); //set filter 1 of mask 1
can_set_id(RXFILTER4, 0, CAN_USE_EXTENDED_ID); //set filter 2 of mask 1
can_set_id(RXFILTER5, 0, CAN_USE_EXTENDED_ID); //set filter 3 of mask 1
// set dynamic filters
can_set_id(RXFILTER6, 0, CAN_USE_EXTENDED_ID);
can_set_id(RXFILTER7, 0, CAN_USE_EXTENDED_ID);
can_set_id(RXFILTER8, 0, CAN_USE_EXTENDED_ID);
can_set_id(RXFILTER9, 0, CAN_USE_EXTENDED_ID);
can_set_id(RXFILTER10, 0, CAN_USE_EXTENDED_ID);
can_set_id(RXFILTER11, 0, CAN_USE_EXTENDED_ID);
can_set_id(RXFILTER12, 0, CAN_USE_EXTENDED_ID);
can_set_id(RXFILTER13, 0, CAN_USE_EXTENDED_ID);
can_set_id(RXFILTER14, 0, CAN_USE_EXTENDED_ID);
can_set_id(RXFILTER15, 0, CAN_USE_EXTENDED_ID);
set_tris_b((*0xF93 & 0xFB ) | 0x08); //b3 is out, b2 is in
can_set_mode(CAN_OP_NORMAL);
}
////////////////////////////////////////////////////////////////////////
//
// can_set_baud()
////////////////////////////////////////////////////////////////////////
void can_set_baud(void) {
# ifdef Set_125K_Baud {
BRGCON1 = 0x01;
BRGCON2 = 0xBA; //modificado 5/11/07 para usar CAN a 125 KBps
BRGCON3 = 0x07; //con reloj a 10 MHz
}
#endif
#ifdef Set_250K_Baud {
BRGCON1 = 0x00;
BRGCON2 = 0xBA; //modificado 5/11/07 para usar CAN a 250 KBps
BRGCON3 = 0x07; //con reloj a 10 MHz
}
#endif
#ifdef Set_500K_Baud {
BRGCON1 = 0x00;
BRGCON2 = 0x92; //modificado 5/11/07 para usar CAN a 500 KBps
BRGCON3 = 0x02; //con reloj a 10 MHz
}
#endif
}
////////////////////////////////////////////////////////////////////////
//
// can_set_mode
////////////////////////////////////////////////////////////////////////
void can_set_mode(CAN_OP_MODE mode) {
CANCON.reqop=mode;
while( (CANSTAT.opmode) != mode );
}
////////////////////////////////////////////////////////////////////////
//
// can_set_functional_mode
////////////////////////////////////////////////////////////////////////////////
void can_set_functional_mode(CAN_FUN_OP_MODE mode)
{
can_set_mode(CAN_OP_CONFIG); //must be in config mode before params can be set
ECANCON.mdsel=mode;
curfunmode=mode;
can_set_mode(CAN_OP_NORMAL);
}
////////////////////////////////////////////////////////////////////////
//
// can_set_id()
////////////////////////////////////////////////////////////////////////
void can_set_id(int* addr, int32 id, int1 ext) {
//int *ptr;
//ptr=addr;
if (ext) { //extended
//eidl
*addr=make8(id,0); //0:7
//eidh
addr--;
*addr=make8(id,1); //8:15
//sidl
addr--;
*addr=make8(id,2) & 0x03; //16:17
*addr|=(make8(id,2) << 3) & 0xE0; //18:20
*addr|=0x08;
//sidh
addr--;
*addr=((make8(id,2) >> 5) & 0x07 ); //21:23
*addr|=((make8(id,3) << 3) & 0xF8);//24:28
}
else { //standard
//eidl
*addr=0;
//eidh
addr--;
*addr=0;
//sidl
addr--;
*addr=(make8(id,0) << 5) & 0xE0;
//sidh
addr--;
*addr=(make8(id,0) >> 3) & 0x1F;
*addr|=(make8(id,1) << 5) & 0xE0;
}
}
////////////////////////////////////////////////////////////////////////////////
//
// can_set_standard_id
////////////////////////////////////////////////////////////////////////////////
void can_set_standard_id(int * addr, int32 id)
{
//eidl
*addr=0;
//eidh
addr--;
*addr=0;
//sidl
addr--;
*addr=(make8(id,0) << 5) & 0xE0;
//sidh
addr--;
*addr=(make8(id,0) >> 3) & 0x1F;
*addr|=(make8(id,1) << 5) & 0xE0;
}
////////////////////////////////////////////////////////////////////////////////
//
// can_set_extended_id
////////////////////////////////////////////////////////////////////////////////
void can_set_extended_id(int * addr, int32 id)
{
//eidl
*addr=make8(id,0); //0:7
//eidh
addr--;
*addr=make8(id,1); //8:15
//sidl
addr--;
*addr=make8(id,2) & 0x03; //16:17
*addr|=(make8(id,2) << 3) & 0xE0; //18:20
*addr|=0x08;
//sidh
addr--;
*addr=((make8(id,2) >> 5) & 0x07 ); //21:23
*addr|=((make8(id,3) << 3) & 0xF8);//24:28
}
Hola a todos.
Despues de 2 dias, al final he terminado de leer las 44 pagina de este post :-/ .
Mi intencion es montar el esquema que MGLSOFT ha puesto en el mensaje 716 ya que se ve mas sencillo que el de microchip, pero tengo algunas dudas.
MGLSOFT comentas que con este esquema el software y firmware de microchip es completamente compatible, pero con las diferencias que he visto en tu esquema y el de microchip, ¿has tendo que modificar el codigo de microchip para adaptarlo?.
Voy a poner un ejemplo, he visto que usas un dip switch en los pines rc0, rc1 y rc2 del pic, y en el esquema de microchip he visto que rc0 se utiliza para seleccionar la resistencia de fin de linea del can bus(en tu esquema se selecciona con un jumper).
Otra cosa que no entiendo son las dos resistencias que hay colocadas en los pines d+ y d- del usb(r3 y r4) y que no tienen ningun valor colocado, en el esquema de microchip estan marcadas como "DO NOT POPULATE", pero no se que significa.
recapitulando para aceptar identificadores de mensaje del 7F0 al 7FF, el regisro mascara y filtro queda asi...
mascara= 111 1111 0000
filtro = 111 1111 XXXX
suponiendo el caso de que el rango identificador sea distinto al anterior por ejemplo del 6F0 al 6F0 la cosa quedaria asi...
mascara= 111 1111 0000
filtro = 101 1111 XXXX
Astrocar no funciona el enlace.
Hola a todos,
Después de leer todos los mensajes, veo que tenis mus experiencia y sabiduría sobre el bus CAN y espero que me echéis una mano.
Estoy realizando una interfase entre varios sistemas de comunicaciones y uno de ellos es el CAN. Estoy diseñando el hardware, la verdad que no es muy complicado ya que con un simple trasceiber y una opción de introducir resistencia de terminación es suficiente. Mis preguntas son:
1- No hay que añadir algún sistema de protección contra emisiones ESD y EMI? por ejemplo estabilizadores o algo parecido?
2- He visto dos formas de poner la resistencia de terminación: una simple resistencia o con dos resistencias y enganchando en el medio con un condensador a tierra. Cual me recomendáis? yo voy a usar el rango de 10Kbs asta 1Mbs, esto influye en la decisión?
3- Dependiendo de la velocidad de trasmisión se necesita alguna protección mas?
4- Me aconsejaríais introducir octocopladores como he visto en alguna hoja de características?
Personar por tantas preguntas pero tengo algunas dudillas.
En un principio voy añadir un TVS (NUP2105L) y puede ser que los octocopladores, que os parece?.
Muchas gracias y un saludo
Hola! les hago una pregunta ya que saben mucho de CAN BUS.Hola agustina, muy interezantes lo que planteas sobre la comunicacion via can con un honda civic, lo primero es saber los ID que le vas enviar al carro para obtener tus respuestas y para eso tienes que tener contacto directo con el fabricante honda si son parametros generales si hay nomas para eso y puede obtener el ID ejemplo ver las revolucion del motor y esas cosa pero si le vas a solicitar al vehiculos cosas mas restringidas como el VIN del vehiciulo que no es mas que el serial o parametros de seguridad para la programacion de llaves y cosas asi no es muy comun tener los ID de can para esas cosas pero de igual forma es un proyecto muy bueno seria cuestion de ver tu alcance en teste proyecto y cualquier cosa me permites unirme a tu proyecto o por lo menos seguirte muy de cerca en los avances.
Esoty intentando conectarme con un vehiculo que tiene CAN supuestamente (honda civic si 2008), la pregunta concretamente es que protocolo utilizan para transmitir los datos.
He armado 2 placas, una envia datos permanentemente por el bus can y otra los recibe a 250kbps y 500kbps.
Entre estas dos placas anda todo perfecto. Pero la pregunta es, si conecto este "logger" al puerto CAN del automovil, deberia ver cuales son los datos que estan en el bus en ese momento a 500 kbps?
Tambien debo hacerlo para vehiculos de carga pesada, donde el protocolo es J1939, que es a 250 kbps.
gracias!!!
Gracias por la respuesta! logre conectarme, obtuve algunos datos... ni idea que significan... pero parecen ser validos! Lo que necesito terminar antes es una aplicacion donde pueda leer los datos de un camion en protocolo j1939 (tambien CAN).oye que interfaces estas usando porque dices que si te conectastes y que le estas solicitando al carro explicate un poco mejor.
gracias!!
por que no checan este proyecto con arduino
http://code.google.com/p/opengauge/wiki/OBDuinoInterface (http://code.google.com/p/opengauge/wiki/OBDuinoInterface)
yo lo estoy haciendo con un mbed, ya existen proyectos de este tipo, del protocolo que menciona agustina, ni idea, es protocolo cerrado? de ser asi, creo que tendras que pagar para que te den los documentos acerca de como comunicarte, todos los camiones usan este protocolo? saludos
Hola amigos, me ha ido super bien con la implementacion del modulo BusCan en el dsPIC30f4011, en mi proximo mensaje le es estare enviando el codigo y mis experiencias con este dsPIC. les escribo porque quiero colocarle uin tercer nodo a mi red y no tengo la posibilidad de un transceiver mcp2551 mas. si hay alguno que tenga un transceiver de estos por favor estaria muy agradecido si me lo vende o me lo aporta, yo lo recibo con agradecimiento igual. estoy residenciado en Puerto ordaz,Estado Bolivar,Venezuela. GRACIAS MUCHACHOS ... FELIZ DIA DE EL AMOR Y LA AMISTAD
hola estoy haciendo un pryecto con el can bus de peugeot 206 año 2003 motor 1.4 y necesito saber que protocolo de multiplexacion( CAN, KWP, ISO) usa este modelo lo he buscado y o encuentro :(.
Fisicamente el conector debajo del tablero es un tipo OBDII 16 pines color verde con negro y tiene la siguiente pineria en uso: pin 1,4,5,7,10,11,15,16. Espero su ayuda . Gracias y excelente tema :)
El link ya no existe, debe haber algún problema...
hermano como te comente yo tengo otro mas y te lo puedo hacer llevar asi como te hice llegar los dos primeros pero estoy un poco delicado de salud en lo que tenga las posibilidades me comunico contigo
hermano como te comente yo tengo otro mas y te lo puedo hacer llevar asi como te hice llegar los dos primeros pero estoy un poco delicado de salud en lo que tenga las posibilidades me comunico contigo
Ok mi hermano... Gracias por la ayuda... Y que te mejores pronto !!!! estamos hablando
Yo utilizo el cable UTP, el de redes de cómputos, que tiene 4 pares balanceados con características parecidas al estándar de CAN.
Por uno de los pares transmito y por otros dos llevo tensión para alimentar placas.
Por el cable llevo 12VCC, en cada placa regulo a 5 VCC, por la caída de tensión.
En síntesis, no es mas que lo que se hace en un automóvil, para lo que fue diseñado el BUS CAN en su origen.
Como "transciver" utilizo el MCP2551 y entiendo q los únicos cambios q tengo q hacer al código del ejemplo es cambiar #include por mi modelo de PIC y la libreria de comunicación por la can-mcp251x.c.
Hola a todos!
Ahora estoy empezando a trabajar con la red CAN y tieno la necesidad de elegir un cable de 100 metros a una red CAN en una fábrica. ¿Qué me aconseja? Hice una investigación de largo y que se encuentran estos cables:
1. http://pt.farnell.com/pro-power/pd1002/cable-scrn-2pair-7-0-203mm-100m/dp/1219358
2. http://pt.farnell.com/pro-power/tem0038-2009/cable-cw1311-6core-100m/dp/1202605
3. http://www.hitechcontrols.com/cables/data_network_bus/helukabel_bus_cables/fieldbus_without_ground.html
4. http://pt.farnell.com/pro-power/2192-0-5mmblk100m/cable-flex-2192-black-0-5mm-100m/dp/1333036?crosssellid=1333036&crosssell=true&in_merch=true y
Le agradecería su ayuda, es muy importante para mí.
Saludos,
João Costa
Linda herramienta!!
Ya les has entrado?? :mrgreen:
Es que deberias usar un solo scanner por vez, ya que es posible que tengan el mismo ID y no reciban los mensajes juntos...No entendi esa parte y de hecho yo uso solo un scanner.
No tengo claro como se programan los registros específicos del MCP2510, como los buffers de recepción, las mascaras o los filtros, con la librerías de CCS, si que vi como configurar el baud rate, pero veo que siempre se llama a "can_init();" y no se ver como se le pasan los parámetros a configurar.
También veo que se comenta que se tiene que programar el MCP2550, yo creía que solo se programaba el MCP2510 /MCP2515, si utilizo un MCP2515 y un MCP2550 debo de programar alguna cosa en el MCP2550?
Para configurar a 125KBs con un xt de 8Mhz creo que tendría que ser algo asi?
can_set_baud (???,1, 1, 8, 6); // no tengo claro que le tengo que pasar a config
Deberás tener el manual donde dice que son esos valores, ya que pueden ser solo bytes o words o flotantes los valores, y deberás saber que es cada uno...
Seguro que hay que restar el Offset a cada medida o ya viene hecho??
Por otro lado, no entiendo de donde obtienes el valor que dices en el byte 3 y 4, no encuentro forma de llegar al mismo valor.
Lo del byte 2 en FF, posiblemente lo hayas leído mal, aunque sospecho que es muy remota la posibilidad, yo me inclino a pensar que el sensor en cuestión se rompió y fue a sobrerrango la lectura.
El bit 3-4 es E025. Pasándolo a Decimal me sale 57381. Este valor lo multiplico por 0,03125 y me sale 1793,15. Le resto el Offset que es 273 y me sale 1520,16
Que aceite trabaja a esa temperatura?? :shock: :shock:
Ordena los bytes al revés y obtendrás un valor mas creíble.
Es normal transmitir el byte de mayor peso primero...
Tienes lectura real de las temperaturas esas??
Yo creo que no hay que restar el offset.
Me suena que ese motor esta parado, si tiene lecturas de 30 grados... :mrgreen: :mrgreen:
Tienes lectura real de las temperaturas esas??
Yo creo que no hay que restar el offset.
Me suena que ese motor esta parado, si tiene lecturas de 30 grados... :mrgreen: :mrgreen:
Lecturas reales no tengo. Sólo tengo los datos del mensaje que el analizador de tramas me muestra.
El motor estaba parado, es decir, sin encender. Por eso veo lógico que sean 30º. Si no le restariamos el Offset, nos saldría una tempreatura de 70º y eso si que no tiene sentido con un motor sin encender.
Hola buenos dias , una consulta con que analizador estas observando las tramas y discilpa.
Hola.
Tengo un sensor que tiene cuatro cables (rojo, negro, blanco, amarillo). Dos de ellos son GND y V (negro y rojo) y los otros dos son CAN-H y CAN-L.
Hemos alimentado a este sensor con 11V, y hemos medido la tensión en los otros dos cables, y se tienen 9.1V en el amarillo y 8.3V en el blanco. El de mayor tensión tendría que ser el CAN-H y el de menor tensión el CAN-L.
¿CAN-H y CAN-L pueden tener tanta tensión?
Saludos.
Esas tensiones referidas a que las tomas??
El bus es diferencial, deberias tomarlas entre los hilos del bus y a masa cada uno de ellos.
Por lo que se, esas tensiones no son normales, creo que en este hilo hace un tiempo puse una idea de las tensiones que deben ser las usuales.
Esas tensiones referidas a que las tomas??
El bus es diferencial, deberias tomarlas entre los hilos del bus y a masa cada uno de ellos.
Por lo que se, esas tensiones no son normales, creo que en este hilo hace un tiempo puse una idea de las tensiones que deben ser las usuales.
Buscando en el hilo, he visto una captura donde pone que en el nivel Dominante, la tensión diferencial (CAN_H - CAN_L) es del orden de 2.0 V con CAN_H = 3.5V y CAN_L = 1.5V (nominales), y en el nivel Recesivo, la tensión diferencial (CAN_H - CAN_L) es del orden de 0V con CAN_H = CAN_L = 2.5V (nominales).
¿Estas son las máximas y mínimas tensiones que pueden tomar el CAN-H y CAN-L?
Cuando dices que deberia de tomar las medidas "entre los hilos del bus y a masa cada uno de ellos", ¿a que te refieres? ¿medir por un lado del CAN-L a masa? y por el otro CAN-H a masa?
Saludos.
Haa ok gracias por el dato ¡he oido del software can Analyzer pero del hardware can case Xl no es una interface construida por usted o es paga de ser asi pude subir mas informacion al respecto yo por mi parte investigo al rato sobre la misma.Citar
Hola buenos dias , una consulta con que analizador estas observando las tramas y discilpa.
Para analizar las tramas uso el software CanAnalyzer y el hardware CanCase XL.
Saludos.
Hola a todos alguien podría ayudarme, por favor.
Soy mecánico y mi problema es este: adapte un motor ISBe de Cummins en una camioneta Ford 350 que tenia anteriormente un motor powerstroke navistar, ya arranca el motor con la llave del vehículo, pero no encuentro la manera de que la información de presiones, temperaturas y revoluciones del motor, sean desplegadas en el tablero de instrumentos.
El diagramado del motor anterior indica que el computador del motor enviaba la información a través del par trenzado can1 (can1H y can1L) ó J2284 y el diagramado del motor actual envía la información por el par trenzado J1939. ¿cómo podría hacer funcionar el tablero de instrumentos que utilizaba J2284, con el J1939?.
Gracias por su ayuda.
Haa ok gracias por el dato ¡he oido del software can Analyzer pero del hardware can case Xl no es una interface construida por usted o es paga de ser asi pude subir mas informacion al respecto yo por mi parte investigo al rato sobre la misma.Citar
Hola buenos dias , una consulta con que analizador estas observando las tramas y discilpa.
Para analizar las tramas uso el software CanAnalyzer y el hardware CanCase XL.
Saludos.
Saludos.
Hola a todos alguien podría ayudarme, por favor.
Soy mecánico y mi problema es este: adapte un motor ISBe de Cummins en una camioneta Ford 350 que tenia anteriormente un motor powerstroke navistar, ya arranca el motor con la llave del vehículo, pero no encuentro la manera de que la información de presiones, temperaturas y revoluciones del motor, sean desplegadas en el tablero de instrumentos.
El diagramado del motor anterior indica que el computador del motor enviaba la información a través del par trenzado can1 (can1H y can1L) ó J2284 y el diagramado del motor actual envía la información por el par trenzado J1939. ¿cómo podría hacer funcionar el tablero de instrumentos que utilizaba J2284, con el J1939?.
Gracias por su ayuda.
Busca en las paginas de los fabricantes, seguramente debe existir una electrónica que oficie de Gateway (traductor entre protocolos) que se programe para hacer el traslado de variables entre uno y otro.
No es un problema sencillo el tuyo, pero debe existir una solución, seguramente.
O.k gracias por el consejo, buscaré con el fabricante.
Hola buenos dias; una consulta que les tengo, estoy analizando can bus en un carro para un principio de seguridad que aplican en los nuevos reproductores de pantalla tactil. El cual consite en que cuando el carro este en pare(P) el video del reproductor se pueda ver sin problema y es logico porque asi el carro esta parado y el conductor si puede estar viendo la pantalla ahora cuando el carro entra en marcha es decir (D) el video se cancela y solo queda el audio con el fin de que el conductor no se distraiga y puedo causar accidentes. El tema de can bus en este sistema de segurida se maneja atreves de can bus es decir cuando ve ese cambios en la palanca de velocidades atraves de can bus le informa al reproductor que hacer si activar o desactivar el video y mi idea es estudiar todo ese principio y emular la señal de pare(P) y enviarla al reproductor via can bus por eso estoy analizando la trazas de can bus que pasan por eso nodo pero en el analizador que uso que es el de michochip (Can Bus Analyzer) cuando captura la trama me indica un DLC=24 y eso me resulta raro ya que el DLC indica es la cantidad de byte que va a tener la trama que es de 0 .. 8 byte.
Saludos y luego le subo una imagente de la captura de la trama con el analizador.
Creo que deberías consultar con Microchip, porque ademas es extraño que tanto en Hex como en decimal ponen el mismo numero, para mi es un error del software.
Un amigo me pidió que armaramos una interface can y me pareció buena idea, pero luego de leer las páginas de su foro quedé fasinado con CAN BUS. no me imaginaba cuan grande podía ser. Soy totalmente nuevo en este tema así que estoy muy entusiasmado con la lectura de este foro
#include <18F2580.h>
#device ICD=TRUE
#device adc=8
#FUSES NOWDT //No Watch Dog Timer
#FUSES WDT128 //Watch Dog Timer uses 1:128 Postscale
#FUSES HS //High speed Osc (> 4mhz)
#FUSES NOPROTECT //Code not protected from reading
#FUSES BROWNOUT //Reset when brownout detected
#FUSES BORV21 //Brownout reset at 2.1V
#FUSES PUT //Power Up Timer
#FUSES NOCPD //No EE protection
#FUSES STVREN //Stack full/underflow will cause reset
//#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOWRT //Program memory not write protected
#FUSES NOWRTD //Data EEPROM not write protected
#FUSES NOIESO //Internal External Switch Over mode enabled
#FUSES FCMEN //Fail-safe clock monitor enabled
#FUSES PBADEN //PORTB pins are configured as analog input channels on RESET
#FUSES BBSIZ1K //1K words Boot Block size
#FUSES NOWRTC //configuration not registers write protected
#FUSES NOWRTB //Boot block not write protected
#FUSES NOEBTR //Memory not protected from table reads
#FUSES NOEBTRB //Boot block not protected from table reads
#FUSES NOCPB //No Boot Block code protection
#FUSES NOLPT1OSC //Timer1 is not configured for low-power operation
#FUSES MCLR //Master Clear pin enabled
#FUSES NOXINST //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#use delay(clock=22110000)
#define CAN_DO_DEBUG TRUE
#define set_50k_baud
#include <can-18F4580.c>
void main()
{
struct rx_stat rxstat;
int32 rx_id;
int buffer[8];
int rx_len;
int i;
for(i=0;i<8;i++)
{
buffer[i]=0;
}
printf("\r\n\r\nCCS CAN EXAMPLE\r\n");
can_init();
while(TRUE)
{
if ( can_kbhit() )
{
printf("\n\rEntro al kbhit\n\r");
printf("\r\n");
if(can_getd(rx_id, &buffer[0], rx_len, rxstat))
{
printf("Byte 0: %X\r\n",buffer[0]);
}
}
}
}
#use delay(clock=22110000)
#define set_50k_baud
Es extraña la frecuencia del cristal que pones allí:Citar#use delay(clock=22110000)
No encuentro cristales de 22110000 hz, es raro...
Ademas estas seguro que la sentencia:Citar#define set_50k_baud
tiene bien hecha la configuración del baudrate para 10 Kb y ese cristal??
void can_set_baud(void)
{
#ifdef set_50k_baud
{
BRGCON1 = 0x09;
BRGCON2 = 0xBC; //CAN a 50 KBps
BRGCON3 = 0x07; //Reloj a 22,11MHz
}#endif
#ifdef set_250k_baud
{
BRGCON1 = 0x01;
BRGCON2 = 0xBC; //CAN a 250 KBps
BRGCON3 = 0x07; //Reloj a 22,11 MHz
}#endif
}
if ( can_kbhit() )
Pues va a tocar buscar optoacopladores muy rápidos, ya tuve problemas con un bus RS485 optoacoplado a 115Kbps.
Hay un problema, no le has puesto un Id al receptor, de todos modos deberia haber entrado en la lineaCitarif ( can_kbhit() )
Con que haces el debug??
Hola.Buenas...
Tengo un sensor que tiene cuatro cables (rojo, negro, blanco, amarillo). Dos de ellos son GND y V (negro y rojo) y los otros dos son CAN-H y CAN-L.
Hemos alimentado a este sensor con 11V, y hemos medido la tensión en los otros dos cables, y se tienen 9.1V en el amarillo y 8.3V en el blanco. El de mayor tensión tendría que ser el CAN-H y el de menor tensión el CAN-L.
¿CAN-H y CAN-L pueden tener tanta tensión?
Saludos.
Hay un problema, no le has puesto un Id al receptor, de todos modos deberia haber entrado en la lineaCitarif ( can_kbhit() )
Con que haces el debug??
Lo hago con un ICD3.
Me acabo de dar cuenta, el bus can no tiene 60 ohm... :?, solo tengo la terminación en una parte del bus :cry:. Ya hasta el lunes no puedo probarlo, pero en cuanto lo pruebe te comento que tal me ha ido.
Gracias de nuevo.
Es posible que hayas conectado algo mal, puedes poner el esquema de tu circuito a ver si vemos algo??
Es normal equivocar el pin tx y rx de can en la conexión al MCP2551.
Ahí no anda nada.
Ya terminé mi proyecto, al final he conseguido comunicarme con el bus CAN del coche. El PIC lee los datos de OBD y muestra los PIDS seleccionados por la pantalla LCD.Muy buenas a todos,
Tiene 2 modos de funcionamiento, uno conectado al ordenador por puerto serie, y se le envían comandos para transmitir al vehículo y configurar las opciones. El otro modo, es automático cuando no se le envia nada por el puerto serie, comienza a hacer peticiones de los datos del OBD, según el protocolo ISO 15765 (OBD sobre CAN).
Aquí está la normativa de comunicación con las centralitas del coche:Hola Teleko,
sae OBD (http://www.4shared.com/file/74089156/77de9073/SAE_OBDII_j1979_200204.html)
Y aquí se explica el funcionamiento del ELM, más o menos lo que yo quiero hacer, se entiende bastante bien cómo es el proceso de comunicación, enviando comandos y recibiendo las respuestas (pag 20):
(http://dc107.4shared.com/img/74089537/518aafbf/ELM327DS.pdf) (http://www.4shared.com/file/74089537/518aafbf/ELM327DS.html)
Si es otro lenguaje C, para que molestarse en cambiarlo??
Si es assembler, difícilmente puedas mejorarlo en C.
Si tuviera que portarlo a C, lo haría a un C que cumpla la norma ANSI C, como el C18 de Mchip.
void main()
{
struct rx_stat rxstat;
int32 rx_id;
int buffer[8];
int rx_len;
int i;
for(i=0;i<8;i++)
{
buffer[i]=0;
}
printf("\r\n\r\nCCS CAN EXAMPLE\r\n");
can_init();
can_putd(0x100, 0, 1, 1, TRUE, FALSE);
delay_ms(500);
enable_interrupts(GLOBAL);
while(TRUE)
{
if ( can_kbhit() )
{
printf("\n\rEntro al kbhit\n\r");
printf("\r\n");
if(can_getd(rx_id, &buffer[0], rx_len, rxstat))
{
printf("Byte 0: %X\r\n",buffer[0]);
}
}
delay_ms(500);
}
}
/*
Example 1
This example shows a very simple J1939 implementation. It uses polling
to check for a message to light an LED and to send a message if a
button is pressed.
Both Node 0 and Node 1 should be programmed with the same code, except
that OTHER_NODE should be defined as the other node’s J1939 Address.
Application Maestro should be run with the following options changed
from their default values (in addition to NAME, Address, and bit rate
values):
Interrupts or Polling - Polling
*/
#include <18f2580.h>
#include "j1939.h"
J1939_MESSAGE Msg;
// Define some arbitrary values. They must agree with the other node's
// values.
#define OTHER_NODE 129
#define TURN_ON_LED 92
#define TURN_OFF_LED 94
void main( void )
{
unsigned char LastSwitch = 1;
unsigned char CurrentSwitch;
TRISBbits.TRISB4 = 1; // Switch pin
TRISD = 0; // LED pins
LATD = 0; // Turn off LED
J1939_Initialization( TRUE );
// Wait for address contention to time out
while (J1939_Flags.WaitingForAddressClaimContention)
J1939_Poll(5);
// Now we know our address should be good, so start checking for
// messages and switches.
while (1)
{
CurrentSwitch = PORTBbits.RB4;
if (LastSwitch != CurrentSwitch)
{
Msg.DataPage = 0;
Msg.Priority = J1939_CONTROL_PRIORITY;
Msg.DestinationAddress = OTHER_NODE;
Msg.DataLength = 0;
if (CurrentSwitch == 0)
Msg.PDUFormat = TURN_ON_LED;
else
Msg.PDUFormat = TURN_OFF_LED;
while (J1939_EnqueueMessage( &Msg ) != RC_SUCCESS)
J1939_Poll(5);
LastSwitch = CurrentSwitch;
}
while (RXQueueCount > 0)
{
J1939_DequeueMessage( &Msg );
if (Msg.PDUFormat == TURN_ON_LED)
LATDbits.LATD0 = 1;
else if (Msg.PDUFormat == TURN_OFF_LED)
LATDbits.LATD0 = 0;
}
// Since we don’t accept the Commanded Address message,
// the value passed here doesn’t matter.
J1939_Poll(20);
}
}
Este código lo has probado usando otra placa en el bus??
Si lo has probado, Funciona ??
/*********************************************************************/
/*********************************************************************/
/*
Example 1
This example shows a very simple J1939 implementation. It uses polling
to check for a message to light an LED and to send a message if a
button is pressed.
Both Node 0 and Node 1 should be programmed with the same code, except
that OTHER_NODE should be defined as the other node’s J1939 Address.
Application Maestro should be run with the following options changed
from their default values (in addition to NAME, Address, and bit rate
values):
Interrupts or Polling – Polling
*/
#include <18F2580.h>
#fuses HS,NOPROTECT,NOLVP,NOWDT,NOMCLR
#include "regs_2580.h"
#use delay(clock=20000000)
#include <display.h>
#include "j1939_128.def" //esta el archivo donde el valor J1939_STARTING_ADDRESS está definido como 128
#include "j1939.c"
#include "j1939.h"
J1939_MESSAGE Msg;
// Define some arbitrary values. They must agree with the other node's
// values.
#define OTHER_NODE 129
#define TURN_ON_LED 92
#define TURN_OFF_LED 94
void main( void )
{
int1 LastSwitch = 1;
int1 CurrentSwitch;
// Switch pin
TRISA = 0; // LED pins
PORTA = 0; // Turn off LED
J1939_Initialization( TRUE );
TRISB = TRISB | 0b00010000;
// Wait for address contention to time out
while (J1939_Flags.WaitingForAddressClaimContention)
J1939_Poll(5);
// Now we know our address should be good, so start checking for
// messages and switches.
while (TRUE)
{
CurrentSwitch = RB4;
if (LastSwitch != CurrentSwitch)
{
Msg.DataPage = 0;
Msg.Priority = J1939_CONTROL_PRIORITY;
Msg.DestinationAddress = OTHER_NODE;
Msg.DataLength = 0;
if (CurrentSwitch == 0){
Msg.PDUFormat = TURN_ON_LED;
RA0=0;
}
else{
Msg.PDUFormat = TURN_OFF_LED;
RA0=1;
}
while (J1939_EnqueueMessage( &Msg ) != RC_SUCCESS){
delay_ms(200); RA0=~RA0; delay_ms(200); //esto he adicionado para verificar donde el software estaba parando.
}
J1939_Poll(5);
LastSwitch = CurrentSwitch;
}
while (RXQueueCount > 0)
{
J1939_DequeueMessage( &Msg );
if (Msg.PDUFormat == TURN_ON_LED)
RA0 = 1;
else if (Msg.PDUFormat == TURN_OFF_LED)
RA0 = 0;
}
// Since we don’t accept the Commanded Address message,
// the value passed here doesn’t matter.
}
}
#BYTE TRISA = 0xF92
#BYTE TRISB = 0xF93
#BYTE TRISC = 0xF94
#BYTE PORTA = 0xF80
#BIT RA0 = PORTA.0
#BIT RA1 = PORTA.1
#BIT RA2 = PORTA.2
#BIT RA3 = PORTA.3
#BIT RA4 = PORTA.4
#BIT RA5 = PORTA.5
#BIT RA6 = PORTA.6
#BIT RA7 = PORTA.7
#BYTE PORTB = 0xF81
#BIT RB0 = PORTB.0
#BIT RB1 = PORTB.1
#BIT RB2 = PORTB.2
#BIT RB3 = PORTB.3
#BIT RB4 = PORTB.4
#BIT RB5 = PORTB.5
#BIT RB6 = PORTB.6
#BIT RB7 = PORTB.7
#BYTE PORTC = 0xF82
#BIT RC0 = PORTC.0
#BIT RC1 = PORTC.1
#BIT RC2 = PORTC.2
#BIT RC3 = PORTC.3
#BIT RC4 = PORTC.4
#BIT RC5 = PORTC.5
#BIT RC6 = PORTC.6
#BIT RC7 = PORTC.7
#BYTE LATA = 0xF89
#BIT LA0 = LATA.0
#BIT LA1 = LATA.1
#BIT LA2 = LATA.2
#BIT LA3 = LATA.3
#BIT LA4 = LATA.4
#BIT LA5 = LATA.5
#BIT LA6 = LATA.6
#BIT LA7 = LATA.7
#BYTE LATB = 0xF8A
#BIT LB0 = LATB.0
#BIT LB1 = LATB.1
#BIT LB2 = LATB.2
#BIT LB3 = LATB.3
#BIT LB4 = LATB.4
#BIT LB5 = LATB.5
#BIT LB6 = LATB.6
#BIT LB7 = LATB.7
#BYTE LATC = 0xF8B
#BIT LC0 = LATC.0
#BIT LC1 = LATC.1
#BIT LC2 = LATC.2
#BIT LC3 = LATC.3
#BIT LC4 = LATC.4
#BIT LC5 = LATC.5
#BIT LC6 = LATC.6
#BIT LC7 = LATC.7
struct{
int1 RBPU;
int1 INTEDG0;
int1 ITEDG2;
int1 VOIDINTC2;
int1 TMR0IP;
int1 VOIDINTC2B;
int1 RBIP;
} INTCON2;
#BYTE INTCON2 = 0xFF1
#BYTE INTCON = 0xFF2
#BIT RBIF = INTCON.0
#BIT INT0IF = INTCON.1
#BIT TMR0IF = INTCON.2
#BIT RBIE = INTCON.3
#BIT INT0IE = INTCON.4
#BIT TMR0IE = INTCON.5
#BIT PEIE = INTCON.6
#BIT GIE = INTCON.7
#ifdef ECAN_IS_CAN_MODULE
struct {
int1 FILHIT0;
int1 JTOFF;
int1 RXBODBEN;
int1 RXRTRRO;
int1 voidrxb0con;
int1 RXM0;
int1 RXM1;
int1 RXFUL;
} RXB0CONbits;
#else
struct {
int1 FILHIT0;
int1 FILHIT1;
int1 FILHIT2;
int1 FILHIT3;
int1 FILHIT4;
int1 RTRRO;
int1 RXM1;
int1 RXFUL;
} RXB0CONbits;
#endif
#byte RXB0CONbits = 0xF60
#byte RXB0CON = 0xF60
struct{
int1 IRXIE;
int1 WAKIE;
int1 ERRIE;
int1 TXBnIE;
int1 TXB1IE;
int1 TXB0IE;
int1 RXB1IE;
int1 RXB0IE;
} PIE3bits;
#byte CANSTAT = 0xF6E
#byte CANCON = 0xF6F
#byte RXF3EIDH = 0xF0E
#byte RXB0SIDH = 0xF61
#byte ECANCON = 0xF77
#byte PIE3bits = 0xFA3
#byte PIE3 = 0xFA3
#byte BSEL0 = 0xDF8
#byte RXM0SIDH = 0xF18
#byte RXM0SIDL = 0xF19
#byte RXM0EIDH = 0xF1A
#byte RXM0EIDL = 0xF1B
#byte RXM1SIDH = 0xF1C
#byte RXM1SIDL = 0xF1D
#byte RXM1EIDH = 0xF1E
#byte RXM1EIDL = 0xF1F
#byte RXF0SIDH = 0xF00
#byte RXF0SIDL = 0xF01
#byte RXF0EIDH = 0xF02
#byte RXF0EIDL = 0xF03
#byte RXF1SIDH = 0xF04
#byte RXF1SIDL = 0xF05
#byte RXF1EIDH = 0xF06
#byte RXF1EIDL = 0xF07
#byte RXF2SIDH = 0xF08
#byte RXF2SIDL = 0xF09
#byte RXF2EIDH = 0xF0A
#byte RXF2EIDL = 0xF0B
#byte RXF3SIDH = 0xF0C
#byte RXF3SIDL = 0xF0D
#byte RXF3EIDH = 0xF0E
#byte RXF3EIDL = 0xF0F
#byte MSEL0 = 0xDF0
#byte RXFBCON0 = 0xDE0
#byte RXFBCON1 = 0xDE1
#byte RXFBCON2 = 0xDE2
#byte RXFCON0 = 0xDD4
#byte RXFCON1 = 0xDD5
#byte BRGCON1 = 0xF70
#byte BRGCON2 = 0xF71
#byte BRGCON3 = 0xF72
#byte COMSTAT = 0xF74
void J1939_Poll( unsigned long ElapsedTime )
{
unsigned int Temp;
// Update the Contention Wait Time. We have to do that before
// we call J1939_ReceiveMessages in case the time gets reset back
// to zero in that routine.
ContentionWaitTime += ElapsedTime;
#if J1939_POLL_ECAN == J1939_TRUE
J1939_ReceiveMessages();
J1939_TransmitMessages();
#endif
if (J1939_Flags.WaitingForAddressClaimContention &&
(ContentionWaitTime >= 25000l)) //el valor original era de 250000l, lo cambié porque el compiler dijo que la variável ContentionWaitTime jamás tenería este valor
{
J1939_Flags.CannotClaimAddress = 0;
J1939_Flags.WaitingForAddressClaimContention = 0;
J1939_Address = CommandedAddress;
// Set up filter to receive messages sent to this address.
// If we're using interrupts, make sure that interrupts are disabled
// around this section, since it will mess up what we're doing.
#if J1939_POLL_ECAN == J1939_FALSE
#if (J1939_PRIORITIZED_INT == J1939_FALSE) || (ECAN_RX_INTERRUPT_PRIORITY == 0x00) || (ECAN_TX_INTERRUPT_PRIORITY == 0x00)
INTCONbits.GIEL = 0;
#endif
#if (ECAN_RX_INTERRUPT_PRIORITY != 0x00) || (ECAN_TX_INTERRUPT_PRIORITY != 0x00)
INTCONbits.GIEH = 0;
#endif
#endif
SetAddressFilter( J1939_Address );
#if J1939_POLL_ECAN == J1939_FALSE
#if (J1939_PRIORITIZED_INT == J1939_FALSE) || (ECAN_RX_INTERRUPT_PRIORITY == 0x00) || (ECAN_TX_INTERRUPT_PRIORITY == 0x00)
INTCONbits.GIEL = 1;
#endif
#if (ECAN_RX_INTERRUPT_PRIORITY != 0x00) || (ECAN_TX_INTERRUPT_PRIORITY != 0x00)
INTCONbits.GIEH = 1;
#endif
#endif
}
}
En esta última función, cual es el significado del carácter "l" (ContentionWaitTime >= 25000l), en la línea que yo he cambiado?
TRISB = TRISB | 0b00010000;
Le sugiero que lea las siguientes observaciones al aire libre CAN2.0A / B spec en frente de usted, y una copia de la CAN dsPIC documento de referencia (de Microchip).
Dato importante 1: No creo que una identificación de la CAN es un "número". Se trata de un conjunto de bits que se utilizan para dar prioridad a un mensaje de CAN en un bus CAN.
Dato importante 2: No creo que una máscara de Rx es un "número", esto es sólo un conjunto de bits que activar o desactivar bits coincidentes en el filtro de Rx,
Hecho 3 Importante: No creo que un filtro de Rx es un "número", esto también es sólo un conjunto de bits que el motor pueda utilizará durante el proceso de recepción de mensajes.
(Ahora sería un buen momento para volver a leer los documentos CAN 2.0A / B y Microchip de Filtros y máscaras)
Para responder a tu pregunta (yo estoy usando ID ETS tratar de mantener las cosas simples) ...
tengo la confusión en la máscara de ajuste y filtro de Identificación values.My mensaje por 7 nodos 1,2,3 ... 7
En primer lugar aplicar lo que ahora entendemos por CAN ID (ID recordar son sólo un conjunto de bits).
Tome su primera CAN mensaje de ID (1). En realidad, esta identificación se llega a enviar en el bus CAN como una serie de bits "00000000001", la CAN ID de mensaje (2) sea enviado como "00000000010".
Ok, por un nodo CAN para recibir correctamente los mensajes, el mensaje tiene que "pasar" de la CAN nodo Rx filtro.
Ejemplo 1:
Cómo establecer un nodo CAN Rx máscara y filtro para recibir sólo ID CAN 1 y CAN no ID 2?
Recuerde, pensar en la identidad como un poco a presentar (que lo es), y convertir el ID en binario (que hace las cosas fáciles si lo hace).
ID: 1 = 00000000001
ID: 2 = 00000000010
Ok, ahora (a partir de su lectura de la especificación CAN2.0A / B) se sabe que la máscara es como un interruptor para activar / desactivar el filtro de bits de Rx. Ya que es el filtro que hace el trabajo, lo primero que debe hacer es establecer el ámbito del filtro. Así que para su nodo puede recibir sólo CAN ID 1, usted quiere que su filtro para que coincida con este requisito.
FilterA = 00000000001
Ahora ponga la máscara para permitir que los bits del filtro que desea comprobar el ID de la CAN en contra. En nuestro caso, vamos a configurar la máscara para asegurarse de que el filtro sólo pasarán los marcos de la CAN con un ID de 1.
Máscara = 11111111111 (Todos los 1 significa que cada bit de la filterA Rx se utiliza para comprobar la entrada CAN marco de ID en contra.
Ejemplo 2:
Si desea configurar el filtro para recibir un número de (secuencial) CAN marco de ID, y luego todo lo que necesita hacer es configurar algunos de los bits de la máscara y filtro a 0.
Deseo recibir puede enmarcar 1,2 ID y 3, pero no quiero recibir CAN marco ID 4
Una vez más, siempre es mas fácil de descomponer la tarea en binario (hasta que entienda el proceso).
ID1 = 00000000001
ID2 = 00000000010
ID3 = 00000000011
ID 4 = 00000000100
Esta vez, en primer lugar establecer el filtro Máscara de hacer caso omiso de los bits del ID que son comunes a todos los identificadores quería - en este ejemplo, establezca los bits de la máscara de 0,1 = 0. Esto hará que el filtro de hacer caso omiso de los dos bits LSB de la ID de la CAN.
Máscara = 11111111100
En segundo lugar, configurar el filtro para "igualar" los bits comunes de los identificadores CAN desea.
FilterA = 00000000000
Cuando se combina la máscara y filtro, verá que usted ha creado (lo que yo llamo) una "regla de Rx".
Máscara = 11111111100
FilterA = 00000000000
Identificaciones que se aceptan: 1,2,3
ID que será rechazada: 4-2047
Esperamos que algunas de ayuda
Artic
Si en el código deshabilitas Debug_printf la librería deja de enviar por el puerto cada vez que transmite o recibe, lo que pasa es que nadie le contesta nada, por lo tanto es imposible saber si esta o no transmitiendo. Yo lo dejaría así, porque si en algún momento recibes algo, al menos entiendes que paso o que salio mal o si salio bien, entenderás las tramas del CANBUS.
Si miras en la placa que yo puse en los primeros puntos de este hilo, veras que le puse leds a las lineas de transmicion y recepción de cada nodo, precisamente para enterarme que pasa cuando tengo problemas de transmision o recepción.
#include <18F2580.h>
#device ICD=TRUE
#device adc=8
#FUSES NOWDT //No Watch Dog Timer
#FUSES WDT128 //Watch Dog Timer uses 1:128 Postscale
#FUSES HS //High speed Osc (> 4mhz)
#FUSES NOPROTECT //Code not protected from reading
#FUSES BROWNOUT //Reset when brownout detected
#FUSES BORV21 //Brownout reset at 2.1V
#FUSES PUT //Power Up Timer
#FUSES NOCPD //No EE protection
#FUSES STVREN //Stack full/underflow will cause reset
//#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOWRT //Program memory not write protected
#FUSES NOWRTD //Data EEPROM not write protected
#FUSES NOIESO //Internal External Switch Over mode enabled
#FUSES FCMEN //Fail-safe clock monitor enabled
#FUSES PBADEN //PORTB pins are configured as analog input channels on RESET
#FUSES BBSIZ1K //1K words Boot Block size
#FUSES NOWRTC //configuration not registers write protected
#FUSES NOWRTB //Boot block not write protected
#FUSES NOEBTR //Memory not protected from table reads
#FUSES NOEBTRB //Boot block not protected from table reads
#FUSES NOCPB //No Boot Block code protection
#FUSES NOLPT1OSC //Timer1 is not configured for low-power operation
#FUSES MCLR //Master Clear pin enabled
#FUSES NOXINST //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#use delay(clock=22110000)
#define CAN_DO_DEBUG TRUE
#define set_50k_baud
#include <can-18F4580.c>
void main()
{
struct rx_stat rxstat;
int32 rx_id;
int buffer[8];
int rx_len;
int i;
for(i=0;i<8;i++)
{
buffer[i]=0;
}
printf("\r\n\r\nCCS CAN EXAMPLE\r\n");
can_init();
delay_ms(500);//**********************************************
while(TRUE)
{
if ( can_kbhit() )
{
printf("\n\rEntro al kbhit\n\r");
printf("\r\n");
if(can_getd(rx_id, &buffer[0], rx_len, rxstat))
{
printf("Byte 0: %X\r\n",buffer[0]);
for(i=0;i<rx_len;i++)
{
printf("Mensaje: %X\r\n",buffer[i]);
}
}
}
// delay_ms(500);
}
}
Del otro lado debe haber otro emitiendo mensajes, porque no pones el código de ese también??
#include <18F2580.h>
#device ICD=TRUE
#device adc=8
#FUSES NOWDT //No Watch Dog Timer
#FUSES WDT128 //Watch Dog Timer uses 1:128 Postscale
#FUSES HS //High speed Osc (> 4mhz)
#FUSES NOPROTECT //Code not protected from reading
#FUSES BROWNOUT //Reset when brownout detected
#FUSES BORV21 //Brownout reset at 2.1V
#FUSES PUT //Power Up Timer
#FUSES NOCPD //No EE protection
#FUSES STVREN //Stack full/underflow will cause reset
//#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOWRT //Program memory not write protected
#FUSES NOWRTD //Data EEPROM not write protected
#FUSES NOIESO //Internal External Switch Over mode enabled
#FUSES FCMEN //Fail-safe clock monitor enabled
#FUSES PBADEN //PORTB pins are configured as analog input channels on RESET
#FUSES BBSIZ1K //1K words Boot Block size
#FUSES NOWRTC //configuration not registers write protected
#FUSES NOWRTB //Boot block not write protected
#FUSES NOEBTR //Memory not protected from table reads
#FUSES NOEBTRB //Boot block not protected from table reads
#FUSES NOCPB //No Boot Block code protection
#FUSES NOLPT1OSC //Timer1 is not configured for low-power operation
#FUSES MCLR //Master Clear pin enabled
#FUSES NOXINST //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#use delay(clock=22110000)
//#use rs232(baud=115200, xmit=PIN_C6,rcv=PIN_C7)
#define CAN_DO_DEBUG TRUE
#define set_50k_baud
#include <can-18F4580.c>
void main()
{
int dato=0;
printf("\r\n\r\nCCS CAN TX EXAMPLE\r\n");
can_init();
while(TRUE)
{
can_putd(0, &dato, 1, 1, 0, 0);//****************
delay_ms(1000);//**********************************************
}
}
Si en el código deshabilitas Debug_printf la librería deja de enviar por el puerto cada vez que transmite o recibe, lo que pasa es que nadie le contesta nada, por lo tanto es imposible saber si esta o no transmitiendo. Yo lo dejaría así, porque si en algún momento recibes algo, al menos entiendes que paso o que salio mal o si salio bien, entenderás las tramas del CANBUS.
Si miras en la placa que yo puse en los primeros puntos de este hilo, veras que le puse leds a las lineas de transmicion y recepción de cada nodo, precisamente para enterarme que pasa cuando tengo problemas de transmision o recepción.
Hola MGLSOFT,
Después del verano vuelvo a carga por donde lo dejé.
Os situo, me he creado los LEDs de TX y RX y funciona correctamente, cada segundo parpadea el LED de RX, tal como debe ser. Pero con el debugger sigue sin entrarme al if ( can_kbhit() ), el código íntegro es el siguiente:Código: [Seleccionar]#include <18F2580.h>
#device ICD=TRUE
#device adc=8
#FUSES NOWDT //No Watch Dog Timer
#FUSES WDT128 //Watch Dog Timer uses 1:128 Postscale
#FUSES HS //High speed Osc (> 4mhz)
#FUSES NOPROTECT //Code not protected from reading
#FUSES BROWNOUT //Reset when brownout detected
#FUSES BORV21 //Brownout reset at 2.1V
#FUSES PUT //Power Up Timer
#FUSES NOCPD //No EE protection
#FUSES STVREN //Stack full/underflow will cause reset
//#FUSES NODEBUG //No Debug mode for ICD
#FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOWRT //Program memory not write protected
#FUSES NOWRTD //Data EEPROM not write protected
#FUSES NOIESO //Internal External Switch Over mode enabled
#FUSES FCMEN //Fail-safe clock monitor enabled
#FUSES PBADEN //PORTB pins are configured as analog input channels on RESET
#FUSES BBSIZ1K //1K words Boot Block size
#FUSES NOWRTC //configuration not registers write protected
#FUSES NOWRTB //Boot block not write protected
#FUSES NOEBTR //Memory not protected from table reads
#FUSES NOEBTRB //Boot block not protected from table reads
#FUSES NOCPB //No Boot Block code protection
#FUSES NOLPT1OSC //Timer1 is not configured for low-power operation
#FUSES MCLR //Master Clear pin enabled
#FUSES NOXINST //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#use delay(clock=22110000)
#define CAN_DO_DEBUG TRUE
#define set_50k_baud
#include <can-18F4580.c>
void main()
{
struct rx_stat rxstat;
int32 rx_id;
int buffer[8];
int rx_len;
int i;
for(i=0;i<8;i++)
{
buffer[i]=0;
}
printf("\r\n\r\nCCS CAN EXAMPLE\r\n");
can_init();
delay_ms(500);//**********************************************
while(TRUE)
{
if ( can_kbhit() )
{
printf("\n\rEntro al kbhit\n\r");
printf("\r\n");
if(can_getd(rx_id, &buffer[0], rx_len, rxstat))
{
printf("Byte 0: %X\r\n",buffer[0]);
for(i=0;i<rx_len;i++)
{
printf("Mensaje: %X\r\n",buffer[i]);
}
}
}
// delay_ms(500);
}
}
Se os ocurre algo??
Gracias!!!
can_putd(0, &dato, 1, 1, 0, 1);
can_putd(0, &dato, 1, 1, 0, 1);[/quote]
Que debugger usas ??
Yo pondria la orden de encender y apagar un led despues del Kbhit() a ver si realmente pasa por ahi o no.
Si el debug que esperas es por serial, podrias tener mal algo del port serial.
Por otro lado prueba activar el bit rtr en el emisor (ultimo valor de la funcion Can_Put() cen 1), esto obligara a que el esclavo responda cuando recibe un mensaje.
Quedaria asi:Citarcan_putd(0, &dato, 1, 1, 0, 1);
Las capas más superiores son definidas de acuerdo con la aplicación. Por ejemplo, yo estoy intentando leer datos de autobuses y camiones. He descubierto que las capas más superiores de la referencia OSI para autobuses y camiones son definidas por la norma SAE J1939, y los datos de algunos modelos dentro del J1939 siguen un standard llamado FMS Standard.
Procura informarte a respecto de que normas definen las capas más superiores para los autos de Peugeot, para poder interpretar los datos.
Para los filtros, creo que este trend, nel forum de Microchip te puede aclarar (en inglés).
http://www.microchip.com/forums/tm.aspx?m=456043&settheme=Mobile
Para los filtros, creo que este trend, nel forum de Microchip te puede aclarar (en inglés).
http://www.microchip.com/forums/tm.aspx?m=456043&settheme=Mobile
Una cosa que queria comentar que me ha sucedido, no se si es normal (yo diria que si) es que si unicamente conecto un pic y el otro lo dejo apagado (o con el modulo can off) el pic que esta enviando se pone a enviar mensajes (los mismos) reiteradamente como un loco. Y me refiero a que unicamente hago un send, y sigue mandando el mismo mensaje una y otra vez hasta que enciendo el pic2 y este activa el modulo can.
Otra cosa sobre lo anterior de que si ningun receptor indica que el mensaje ha sido recibido vuelve lo da como error y lo vuelve a enviar. Imaginemos que tenemos una red con 3 dispositivos, el dispositivo 1 envia un mensaje el cual el 2 lo acepta por el filtro/mascara, pero que pasaria si el 2 esta offline por cualquier razon? Seria un error, o ya el dispositivo 3 se encargaria de decir que el mensaje ha sido recibido, a pesar de que no entre en su filtro/mascara?
http://img26.imageshack.us/img26/2381/can2e.jpg
http://img838.imageshack.us/img838/1730/can3e.jpg
http://img15.imageshack.us/img15/7703/canej.jpg
ahi 3 imagenes, yo creo ke esta bien, porque lei por ahi que la señal de un canal tiene que restar la del otro y dar cerca de 0.
Otra cosa sobre lo anterior de que si ningun receptor indica que el mensaje ha sido recibido vuelve lo da como error y lo vuelve a enviar. Imaginemos que tenemos una red con 3 dispositivos, el dispositivo 1 envia un mensaje el cual el 2 lo acepta por el filtro/mascara, pero que pasaria si el 2 esta offline por cualquier razon? Seria un error, o ya el dispositivo 3 se encargaria de decir que el mensaje ha sido recibido, a pesar de que no entre en su filtro/mascara?
http://img26.imageshack.us/img26/2381/can2e.jpg
http://img838.imageshack.us/img838/1730/can3e.jpg
http://img15.imageshack.us/img15/7703/canej.jpg
ahi 3 imagenes, yo creo ke esta bien, porque lei por ahi que la señal de un canal tiene que restar la del otro y dar cerca de 0.
Otra cosa sobre lo anterior de que si ningun receptor indica que el mensaje ha sido recibido vuelve lo da como error y lo vuelve a enviar. Imaginemos que tenemos una red con 3 dispositivos, el dispositivo 1 envia un mensaje el cual el 2 lo acepta por el filtro/mascara, pero que pasaria si el 2 esta offline por cualquier razon? Seria un error, o ya el dispositivo 3 se encargaria de decir que el mensaje ha sido recibido, a pesar de que no entre en su filtro/mascara?
Es un osciloscopio DSO Nano el que usas??
Lindo equipo !
http://www.hantek.net/english/produce_list.asp?unid=63 (http://www.hantek.net/english/produce_list.asp?unid=63)
Que hora es por alli??
Las 4AM ??
Que debugger usas ??
Yo pondria la orden de encender y apagar un led despues del Kbhit() a ver si realmente pasa por ahi o no.
Si el debug que esperas es por serial, podrias tener mal algo del port serial.
Por otro lado prueba activar el bit rtr en el emisor (ultimo valor de la funcion Can_Put() cen 1), esto obligara a que el esclavo responda cuando recibe un mensaje.
Quedaria asi:Citarcan_putd(0, &dato, 1, 1, 0, 1);
Ahora ya si que me acabo de liar del todo... Resulta que en modo debugger el pintf de "CCS EXAMPLE" me lo hace correctamente, pero si lo grabo y lo arranco sin conectar el ICD no me lo hace :shock: :shock: No se que puedo estar haciendo mal.
He puesto a 1 el bit RTR del emisor, pero sigue igual. Para probarlo tengo el printf de "Entro al kbhit()", pero nunca lo hace.
El debugger lo estoy haciendo desde el MPLAB con un ICD3.
Gracias por tu ayuda!
Lo he puesto en el main justo debajo de la función can_init(); quedando así:
can_init();
can_set_mode(CAN_OP_LOOPBACK);
Está así bien? no creo, puesto que sigue sin entrar al kbhit()... (en una de estas me.... pfffff :5])
Buenas Tardes a todos, antes que nada mis Felicitaciones MGL SOFT por el tremendo post de bus CAN, les deseo hacer una consulta con respecto al bus, existe alguna limitacion en la cantidad de nodos que pueden ser colgados de bus?, les comento, me han ofrecido realizar un proyecto donde los nodos tienen que ser 19 con diferentes sensores, y que lleven los datos a un monitor..., por otro lado les deberia consultar, y pedir perdon si este no es el lugar apropiado, si me pueden brindar asesoramiento, informacion sobre la realizacion de un proyecto contemplando el costo del mismo, incluyendo investigacion, desarrollo, diseño, implementacion, pruebas y depuracion, etc.... les pediria si conoces algun link donde se hable de esto y los precios que se estan cobrando para realizar diferentes proyectos, si estan expresados en dolares mucho mejor para que cualquiera que necesite estos datos tenga una buena referencia, para ser concretos les tiro un ejemplo... viene un cliente y les pide que realicen un sistema donde el pueda abrir el garage de su casa mediante un sms de su celular, sacando los costos de componentes, de mano de obra cuanto cobrarian??????? GRACIAS A TODOS, les doy mi mail para estar comunicados.
firmwarer@hotmail.com.ar
Soy de Coria
uffs, asi que refrito, tendre que tomarme el riesgo, quiero implementar un protocolo de comunicacion sencillo en el bus can y presentarlo como tesis, ya estoy en un 90% convencido que sera mi tema.
Adelante con la explicación.
Se hizo alguna vez una pequeña introducción al tema, por lo tanto si lo explicas aquí, ademas de poder debatirlo, te servirá para tu trabajo final.
las resistencias se colocan entre canh y canl, en ambos finales, y son de 120ohm ya que al estar en paralelo son 60ohm. A que te refieres de derivadas a masa?
(http://www.scielo.org.ar/img/revistas/laar/v35n2/2a10g90.gif)
Hay configuraciones como las que dice astrocar, donde se conectan dos resistencias en serie de 60Ohm entre CanH y CanL, y el punto medio a masa, esto se hace para asegurarse que el par balanceado tenga la referencia de masa exactamente al centro de la señal diferencial, con este metodo se solucionan de antemano muchos problemas ocurridos cuando en un nodo en particular se eleva la tension de masa y luego no interpreta el modulo CAN los mensajes que llegan a el.
No tengo un lindo dibujito pero creo que pueden imaginarse el conexionado segun mi descripcion. :mrgreen:
Yo compro habitualmente en RS y Digikey. Esporádicamente también en Mouser o Farnell.
eso es para la configuracion de velocidad del CAN, muestreo...Podrias ser mas especifico por favor. Cual es la funcion de cada una de las banderas citadas en le mensaje anterior?
Hola a todos! Estuve leyendo el foro y esta muy bueno. Felicitaciones, se nota que saben mucho sobre el tema.
Estoy empezando con el CAN, estoy usando MikroC para programar el PIC 18F4680. No entiendo el tema de las banderas CAN_CONFIG_FLAGS . Si alguien podria explicarme por favor.
Por ejemplo en la seccion de ayuda de mikroC hay un ejemplo de utilizacion de las banderas CAN_CONFIG_FLAGS que lo utiliza con la libreria CANInitialize. Que hace ahi? Entiendo mas o menos los parametros SJW, BRP, PHSEG1,PHSEG2,PROPSEG pero no las banderas.
init = _CAN_CONFIG_SAMPLE_THRICE &
_CAN_CONFIG_PHSEG2_PRG_ON &
_CAN_CONFIG_STD_MSG &
_CAN_CONFIG_DBL_BUFFER_ON &
_CAN_CONFIG_VALID_XTD_MSG &
_CAN_CONFIG_LINE_FILTER_OFF;
CANInitialize(1, 1, 3, 3, 1, init); // initialize CAN
Agradeceria si alguien pudiese ayudarme.
Saludos a todos.
const char
_CAN_CONFIG_DEFAULT = 0xFF, // 11111111
_CAN_CONFIG_PHSEG2_PRG_BIT = 0x01,
_CAN_CONFIG_PHSEG2_PRG_ON = 0xFF, // XXXXXXX1
_CAN_CONFIG_PHSEG2_PRG_OFF = 0xFE, // XXXXXXX0
_CAN_CONFIG_LINE_FILTER_BIT = 0x02,
_CAN_CONFIG_LINE_FILTER_ON = 0xFF, // XXXXXX1X
_CAN_CONFIG_LINE_FILTER_OFF = 0xFD, // XXXXXX0X
_CAN_CONFIG_SAMPLE_BIT = 0x04,
_CAN_CONFIG_SAMPLE_ONCE = 0xFF, // XXXXX1XX
_CAN_CONFIG_SAMPLE_THRICE = 0xFB, // XXXXX0XX
_CAN_CONFIG_MSG_TYPE_BIT = 0x08,
_CAN_CONFIG_STD_MSG = 0xFF, // XXXX1XXX
_CAN_CONFIG_XTD_MSG = 0xF7, // XXXX0XXX
_CAN_CONFIG_DBL_BUFFER_BIT = 0x10,
_CAN_CONFIG_DBL_BUFFER_ON = 0xFF, // XXX1XXXX
_CAN_CONFIG_DBL_BUFFER_OFF = 0xEF, // XXX0XXXX
_CAN_CONFIG_MSG_BITS = 0x60,
_CAN_CONFIG_ALL_MSG = 0xFF, // X11XXXXX
_CAN_CONFIG_VALID_XTD_MSG = 0xDF, // X10XXXXX
_CAN_CONFIG_VALID_STD_MSG = 0xBF, // X01XXXXX
_CAN_CONFIG_ALL_VALID_MSG = 0x9F; // X00XXXXX
Ok, muchas gracias. El diseño ya lo tenía hecho a mano pero la verdad es que me vedría muy bien simularlo. Bueno, experimentaré en una board---
Que es la barra negra al borde de la placa , arriba??Hola MGLSOFT, se trata del icsp jjeje, lo que pasa que al ponerlo cerca de los elementos de la alimentacion, si que parece un rectificador.
Es un puente de diodos??
Para poder mostrar todas las tramas, al menos la velocidad del puerto serie deberia ser el doble que la del bus que estas leyendo.
En cambio estas leyendo a menos de 1/4 de esa velocidad, por lo tanto no es extraño que saltees tramas.
Respecto a las que lees por interrupcion, recuerda que si procesas toda la informacion dentro de la interrupcion, hasta que no sales no vuelve a activarse la misma, y segun que compilador utilizes, evitara la reentrada en la interrupcion hasta que salgas, ya que de otro modo seria un llamado recursivo que termina en un loop infinito y el pic resetearia antes por watchdog o se quedaria bobo si este no esta activo.
#include <18f46k80.h> //archivo de cabecera
#fuses HSH,MCLR,NOWDT,NOPROTECT,NODEBUG,NOPLLEN,NOFCMEN// fuses configurados
#use delay(clock=8M) // Clock en la entrada CPU,Cristal externo 12Mhz*pll4=48Mhz OJO PLL enabled
#include <stdlib.h>
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,bits=8)
#define CAN_USE_EXTENDED_ID FALSE
#include <can-18xxx8.c>
void main(){
int i;
int out_data[8];
int32 tx_id=24;
int1 tx_rtr=0;
int1 tx_ext=0;
int tx_len=8;
int tx_pri=3;
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED|T1_DIV_BY_1);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
//inicialización del buffer
for(i=0;i<8;i++) {
out_data[i]=1;
}
can_init();
while(1){
delay_ms(1000);
i=can_putd(tx_id,out_data, tx_len,tx_pri,tx_ext,tx_rtr); //put data on transmit buffer
if (i != 0xFF) { //success, a transmit buffer was open
printf("\r\nPUT %U: ID=%LU LEN=%U ", i, tx_id, tx_len);
printf("PRI=%U EXT=%U RTR=%U\r\n DATA = ", tx_pri, tx_ext, tx_rtr);
for (i=0;i<tx_len;i++) {printf("%X ",out_data[i]);}
printf("\r\n");
}
else {printf("\r\nFAIL on PUTD\r\n");}
}
}//fin main
set_tris_b((*0xF93 & 0xFB ) | 0x08); //b3 is out, b2 is in
#include <18f26k80.h> //archivo de cabecera
#fuses HSH,MCLR,NOWDT,NOPROTECT,NODEBUG,NOPLLEN,NOFCMEN// fuses configurados
#use delay(clock=8M) // Clock en la entrada CPU,Cristal externo 12Mhz*pll4=48Mhz OJO PLL enabled
#include <stdlib.h>
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,bits=8)
#define CAN_USE_EXTENDED_ID FALSE
#include <can-18xxx8.c>
void main(){
can_init();
can_set_mode(CAN_OP_CONFIG);
BRGCON1.brp=9;
BRGCON1.sjw=0;
BRGCON2.prseg=2;
BRGCON2.seg1ph=5;
BRGCON2.sam=FALSE;
BRGCON2.seg2phts=FALSE;
BRGCON3.seg2ph=5;
BRGCON3.wakfil=FALSE;
can_set_mode(CAN_OP_NORMAL);
int i,value=0;
int out_data[8];
int32 tx_id=0;
int1 tx_rtr=0;
int1 tx_ext=1;
int tx_len=8;
int tx_pri=3;
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED|T1_DIV_BY_1);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
//inicialización del buffer
for(i=0;i<8;i++) {
out_data[i]=0;
}
while(1){
for(i=0;i<8;i++) {
out_data[i]=value;
}
delay_ms(2000);
if(value>255){value=0;}else{value++;}
i=can_putd(tx_id,out_data, tx_len,tx_pri,tx_ext,tx_rtr); //put data on transmit buffer
if (i != 0xFF) { //success, a transmit buffer was open
printf("\r\nPUT %U: ID=%LU LEN=%U ", i, tx_id, tx_len);
printf("PRI=%U EXT=%U RTR=%U\r\n DATA = ", tx_pri, tx_ext, tx_rtr);
for (i=0;i<tx_len;i++) {printf("%X ",out_data[i]);}
printf("\r\n");
}
else {printf("\r\nFAIL on PUTD\r\n");}
}
}//fin main
#include <18f46k80.h> //archivo de cabecera
#fuses HSH,MCLR,NOWDT,NOPROTECT,NODEBUG,NOPLLEN,NOFCMEN// fuses configurados
#use delay(clock=8M) // Clock en la entrada CPU,Cristal externo 12Mhz*pll4=48Mhz OJO PLL enabled
#include <stdlib.h>
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,bits=8)
#define CAN_USE_EXTENDED_ID FALSE
#include <can-18xxx8.c>
void main(){
can_init();
can_set_mode(CAN_OP_CONFIG);
BRGCON1.brp=9;
BRGCON1.sjw=0;
BRGCON2.prseg=2;
BRGCON2.seg1ph=5;
BRGCON2.sam=FALSE;
BRGCON2.seg2phts=FALSE;
BRGCON3.seg2ph=5;
BRGCON3.wakfil=FALSE;
can_set_mode(CAN_OP_NORMAL);
int i,value=0;
//Emisor (aunque no lo uso ahora
int out_data[8];
int32 tx_id=0;
int1 tx_rtr=1;
int1 tx_ext=0;
int tx_len=8;
int tx_pri=3;
//Receptor
struct rx_stat rxstat;
int in_data[8];
int rx_len;
int32 rx_id;
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED|T1_DIV_BY_1);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
//inicialización del buffer
for(i=0;i<8;i++) {
in_data[i]=0;
}
printf("Nodo receptor a la escucha...\r\n");
while(1){
if ( can_kbhit() ) //if data is waiting in buffer...
{
if(can_getd(rx_id, &in_data[0], rx_len, rxstat)) { //...then get data from buffer
printf("\r\nGOT: BUFF=%U ID=%LU LEN=%U OVF=%U ", rxstat.buffer, rx_id, rx_len, rxstat.err_ovfl);
printf("FILT=%U RTR=%U EXT=%U INV=%U", rxstat.filthit, rxstat.rtr, rxstat.ext, rxstat.inv);
printf("\r\n DATA = ");
for (i=0;i<rx_len;i++) {
printf("%X ",in_data[i]);
}
printf("\r\n");
}
else {
printf("\r\nFAIL on GETD\r\n");
}
}
}
}//fin main
Hola MGLSOFT
Al final era una aparente tonteria. Digo aparente porque si bien los transceptores del USART por ejemplo envian niveles TTL al transceptor max232 por ejemplo) parece que en CAN no, y el transceptor mcp2551 juega un papel activo entre el modulo ECAN del pic y el propio transceptor (corregirme si me equivoco)
El caso es que ahora veo las tramas del bus CAN. He usado un pic18f26k80 para enviar continuamente un vector de 8bits que se incrementan cada 2 segundos. Puedo ver en el osciloscopio como las lineas CANL y CANH van funcionando, y se puede ver que envia correctamente puesto que los bits se van incrementando continuamente.
Por tanto ahora el problema esta en el nodo receptor. Un pic18f46k80+mcp2551 Voy a poner los codigos por si veis algo. Vuestro ojo esta mas entrenado que el mio con esto del CAN porque es la primera vez que lo uso jeje
Un saludo!1
Nodo Enviador: pic18f26k80+mcp2551. Pin23pic(cantx)->pin1mcp Pin24pic(canrx)->Pin4mcpCódigo: [Seleccionar]#include <18f26k80.h> //archivo de cabecera
#fuses HSH,MCLR,NOWDT,NOPROTECT,NODEBUG,NOPLLEN,NOFCMEN// fuses configurados
#use delay(clock=8M) // Clock en la entrada CPU,Cristal externo 12Mhz*pll4=48Mhz OJO PLL enabled
#include <stdlib.h>
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,bits=8)
#define CAN_USE_EXTENDED_ID FALSE
#include <can-18xxx8.c>
void main(){
can_init();
can_set_mode(CAN_OP_CONFIG);
BRGCON1.brp=9;
BRGCON1.sjw=0;
BRGCON2.prseg=2;
BRGCON2.seg1ph=5;
BRGCON2.sam=FALSE;
BRGCON2.seg2phts=FALSE;
BRGCON3.seg2ph=5;
BRGCON3.wakfil=FALSE;
can_set_mode(CAN_OP_NORMAL);
int i,value=0;
int out_data[8];
int32 tx_id=0;
int1 tx_rtr=0;
int1 tx_ext=1;
int tx_len=8;
int tx_pri=3;
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED|T1_DIV_BY_1);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
//inicialización del buffer
for(i=0;i<8;i++) {
out_data[i]=0;
}
while(1){
for(i=0;i<8;i++) {
out_data[i]=value;
}
delay_ms(2000);
if(value>255){value=0;}else{value++;}
i=can_putd(tx_id,out_data, tx_len,tx_pri,tx_ext,tx_rtr); //put data on transmit buffer
if (i != 0xFF) { //success, a transmit buffer was open
printf("\r\nPUT %U: ID=%LU LEN=%U ", i, tx_id, tx_len);
printf("PRI=%U EXT=%U RTR=%U\r\n DATA = ", tx_pri, tx_ext, tx_rtr);
for (i=0;i<tx_len;i++) {printf("%X ",out_data[i]);}
printf("\r\n");
}
else {printf("\r\nFAIL on PUTD\r\n");}
}
}//fin main
Nodo Recptor: Pic18f46k80+mcp2551. Pin35pic(cantx)->pin1mcp Pin36pic(canrx)->Pin4mcpCódigo: [Seleccionar]#include <18f46k80.h> //archivo de cabecera
#fuses HSH,MCLR,NOWDT,NOPROTECT,NODEBUG,NOPLLEN,NOFCMEN// fuses configurados
#use delay(clock=8M) // Clock en la entrada CPU,Cristal externo 12Mhz*pll4=48Mhz OJO PLL enabled
#include <stdlib.h>
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,bits=8)
#define CAN_USE_EXTENDED_ID FALSE
#include <can-18xxx8.c>
void main(){
can_init();
can_set_mode(CAN_OP_CONFIG);
BRGCON1.brp=9;
BRGCON1.sjw=0;
BRGCON2.prseg=2;
BRGCON2.seg1ph=5;
BRGCON2.sam=FALSE;
BRGCON2.seg2phts=FALSE;
BRGCON3.seg2ph=5;
BRGCON3.wakfil=FALSE;
can_set_mode(CAN_OP_NORMAL);
int i,value=0;
//Emisor (aunque no lo uso ahora
int out_data[8];
int32 tx_id=0;
int1 tx_rtr=1;
int1 tx_ext=0;
int tx_len=8;
int tx_pri=3;
//Receptor
struct rx_stat rxstat;
int in_data[8];
int rx_len;
int32 rx_id;
setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED|T1_DIV_BY_1);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
//inicialización del buffer
for(i=0;i<8;i++) {
in_data[i]=0;
}
printf("Nodo receptor a la escucha...\r\n");
while(1){
if ( can_kbhit() ) //if data is waiting in buffer...
{
if(can_getd(rx_id, &in_data[0], rx_len, rxstat)) { //...then get data from buffer
printf("\r\nGOT: BUFF=%U ID=%LU LEN=%U OVF=%U ", rxstat.buffer, rx_id, rx_len, rxstat.err_ovfl);
printf("FILT=%U RTR=%U EXT=%U INV=%U", rxstat.filthit, rxstat.rtr, rxstat.ext, rxstat.inv);
printf("\r\n DATA = ");
for (i=0;i<rx_len;i++) {
printf("%X ",in_data[i]);
}
printf("\r\n");
}
else {
printf("\r\nFAIL on GETD\r\n");
}
}
}
}//fin main
Gracias por la ayuda :P
Entonces no me cuadra, jejee en cada mensaje se manda el ID(int32), y un array de 8 bytes, (por lo que puedo enviar 8 datos de 8bit, es decir 8 int8), SIno es asi algo estoy haciendo algo raro , por que yo desde el pc envio una trama de 8 char(unsigned int 8) cuando llega al micro ,este le añade un ID y los envia todo este bloqque, y lo recibe otro pic con un lcd.Esta bien entonces, el ID no cuenta como dato, solo es para saber quien emite el mensaje, o en un protocolo de alto nivel quien lo emite, que tipo de dispositivo es y que dato es el que envía...
Ok ahora si! gracias!Entonces no me cuadra, jejee en cada mensaje se manda el ID(int32), y un array de 8 bytes, (por lo que puedo enviar 8 datos de 8bit, es decir 8 int8), SIno es asi algo estoy haciendo algo raro , por que yo desde el pc envio una trama de 8 char(unsigned int 8) cuando llega al micro ,este le añade un ID y los envia todo este bloqque, y lo recibe otro pic con un lcd.Esta bien entonces, el ID no cuenta como dato, solo es para saber quien emite el mensaje, o en un protocolo de alto nivel quien lo emite, que tipo de dispositivo es y que dato es el que envía...
No me he explicado bien.
La centralita de la que hablo es la del techo solar que es la que tiene el ID mas alto ya que es la menos importante, y no creo que ocurra nada malo con ella.
Esta centralita solo actua cuando el coche esta parado o casi parado, digamos menos de 3km/hora.
Lo que me propongo es capturar la pulsacion del boton de apertura y cierre del techo solar, aislar la centralita de la red CAN y enviarle una trama con la velocidad equivocada para que me deje abrir o cerrar el techo solar a una velocidad mayor de 3Km/Hora, cuando el techo se encuentre en la posicion deseada y suelte el boton, que la centralita vuelva a unirse a la red CAN del coche ya que el techo dispone de un display que refleja la hora, temperatura exterior y otras cosas que recoge del bus tambien y que todavia no he descifrado.
Ya he hecho las pruebas y funciona bien, pero si mando la trama con la velocidad modificada y la centralita esta unida a la red CAN, termina por leer la trama verdadera y no puedo abrir o cerrar el techo. En cambio si la aislo de la red, funciona perfectamente, pero el display se queda vacio.
Si solo aislo la centralita cuando abro o cierro el techo y vuelvo a unirla despues a la red funciona todo perfecto.
Mi duda es cual es la mejor forma de hacer esto, habia pensado con un pequeño rele de señal, pero como dice Merlinz es un poco rudo y chapucero y no se si afectaria al resto de la red CAN.
A ver si me podeis aconsejar sobre algun buffer o un sistema para hacer esto bien.
Conoces como funcionan los buffers triestado? Creo que te vendrian bien, conectas el canh y canl a las entradas y mediante el pin enable activas/desactivas la comunicacion entre la linea can y el modulo que dices. Al igual que un rele cuando se desactiva se pone en alta impedancia el buffer es lo mismo, sin embargo el buffer no mete ningun ruido como el rele y su conmutacion es digital no por contactos.
Buenas!Exactamente, para aclararlo aun mas, las resistencias van en los extremos del bus, y se llaman resistencias terminadoras de bus.
La resistencia se ponen para cerrar el bus quedaria asi
(http://www.inverter-china.com/blog-es/upload/CAN-bus.gif)
Hola,gracias por responder pronto,entonces reafirmando...No se puede simular CAN con el Proteus, y aunque consiguieras un simulador, te aconsejo que hagas tus experiencias directamente sobre circuitos, aunque esten armados en protoboard, ya que sino te perderas de miles de detalles que el simulador no te advertira. :? :?
Entiendo que mis dos uC´s no tienen el modulo CAN incorporado, es por eso que compré los modulos externos MCP2515 y MCP2551
1.-Asimilando que trabajaré a 125 Kbps, deberé de incluir tal cual la libreria "can-mcp251x.c" ya sin ninguna modificacion ??
2.-Y para la simulación ¿Que Software usaste ? acostumbro a usar Proteus, pero no tiene los dispositivos MCP2515 y MCP2551 :(
void ConfigCAN1 (void){
/*Ponemos el módulo CAN en modo configuración*/
C1CONbits.REQOP = 100;
/*Esperamos hasta que conmute a modo configuración*/
while(C1CONbits.OPMOD != 100);
/*Configuración FIFO1 como lectura*/
C1FIFOCON1bits.FSIZE = 2; /*Almacenara 3 mensajes del buffer*/
C1FIFOCON1CLR = 0x80; /*Se limpia el bit de TXEN*/
/*Configuración Filtro3 y máscara1 para recibir desde SID 1 a 3*/
C1FLTCON0bits.FSEL3 = 1; /*Almaceno mensajes en FIFO1*/
C1FLTCON0bits.MSEL3 = 1; /*Uso la máscara 1*/
C1RXF3bits.SID = 0x1; /*Filtro 1 SID*/
C1RXF3bits.EXID = 0; /*Filtramos Sólo SID*/
C1RXM1bits.SID = 0x7FC; /*Ignoramos los últimos 2 bits en compración*/
C1RXM1bits.MIDE = 1;
C1FLTCON0bits.FLTEN3 = 1; /*Habilitamos filtros*/
/************************************************************************/
/*Configuración del Bit Timing */
/*Fsys 80MHz, FBAUD = 250Kbps, N=20, Ftq=5Mbps */
/*Calculando BRP=(Fsys/(2*Ftq))-1*, BRP=7 */
/*Synchronization Segment = 1TQ */
/*Bit Time = Sync Segm + Propagation Segm + PH1 + PH2 */
/*Sync Segm = 1TQ; Propagation Segm = 6TQ; PH2 = 6TQ*; Bit Time = 20TQ */
/*PH1 = 7 TQ */
/*Basado en un sistema característico si el retraso de propagación */
/*es de 6TQ y el punto de muestra es del 70% del tiempo de bit nominal */
/*PH2 = 30% Del tiempo de bit nominal */
/************************************************************************/
C1CFGbits.SEG2PHTS = 1;
C1CFGbits.SEG2PH = 5; /*Seg Fase 2 es de 6TQ*/
C1CFGbits.SEG1PH = 6; /*Seg Fase 1 es de 7TQ*/
C1CFGbits.PRSEG = 5; /*Seg Propagación es de 6TQ*/
C1CFGbits.SAM = 1; /*'0' Muestrea el bit 1 vez, '1' tres veces*/
C1CFGbits.SJW = 2; /*Entre 1TQ - 4TQ*/
C1CFGbits.BRP = 7; /*Valor calculado*/
/*Se pone en modo normal*/
C1CONbits.REQOP = 0;
while (C1CONbits.OPMOD != 0);
}
Supongamos que yo quiero recibir mensajes de los SID 100 a 103, que mi placa tiene el SID 104.
Dicho SID tengo que configurarlo yo??Cómo sé que SID tiene mi placa??
Buenas éste es el código que he hecho para la configuración del CAN. ¿Ésta bien?¿Falta algo por configurar?
Soy todo. Casi todo dudas.
Yo ahora estoy intentando buscar información sobre como usar, y configurar el CAN con interrupciones. :5] así estoy, echando fuego. Me está costando el dichoso CAN.
Un saludo.
Y como se accede sin uso del cpu??
Pero que no tiene éste foro??Lo miraré
Gracias.
C1CONbits.ON = 1; /*Activo el módulo CAN1*/
C1INTbits.RBIE = 1; /*Activo Interrupción de Recepción en el Buffer*/
IPC11bits.CAN1IP = 1; /*Prioridad 1*/
IPC11bits.CAN1IS = 0; /*Subprioridad 0*/
IFS1bits.CAN1IF = 0; /*Limpio la bandera de interrupción*/
/*Tengo que borrar tambien RBIF??????????????????*/
INTEnableSystemSingleVectoredInt(); /*Activa el modo Single Vector*/
IEC1bits.CAN1IE = 1; /*Activa la interrupción de CAN1*/
while(1);
return 0;
}
//Rutina de Interrupción
void __ISR(0, ipl1) InterruptHandler(void){
/*Código*/
/*Tengo que borrar tambien RBIF??????????????????*/
/******************/
CANRxMessageBuffer *buffer;
buffer = (CANRxMessageBuffer*)(PA_TO_KVA1(C1FIFOUA1));
/*Comprobar si hay algún mensaje para leer*/
if (buffer->CMSGEID.DLC == 4)
{
/*if(message->data[0] == FALSE)
{
}
else
{
}*/
}
/******************/
IFS1bits.CAN1IF = 0; /*Limpio la bandera de interrupción*/
}
void __ISR(0, ipl1) InterruptHandler(void){
/*Código*/
/******************/
if (C1INTbits.RBIF){ /*Si ha sido interrupción de lectura*/
CANRxMessageBuffer *buffer;
if (C1VECbits.ICODE && '0000001'){ /*Verifico que la INT es en la FIFO1*/
C1FIFOCON1SET = 0x2000; /*Ya se ha leido la FIFO1*/
buffer = (CANRxMessageBuffer*)(PA_TO_KVA1(C1FIFOUA1));
/*Comprobar si hay algún mensaje para leer*/
if(buffer -> CMSGEID.DLC == 4){
/*if(message->data[0] == FALSE)
{
}
else
{
}*/
}
}
}
/******************/
IFS1bits.CAN1IF = 0; /*Limpio la bandera de interrupción*/
}
C1CONbits.ON = 1; /*Activo el módulo CAN1*/
C1INTbits.RBIE = 1; /*Activo Interrupción de Recepción en el Buffer*/
C1FIFOINT1bits.RXNEMPTYIE = 1; /*Activo bit interrupción FIFO no vacía*/
IPC11bits.CAN1IP = 1; /*Prioridad 1*/
IPC11bits.CAN1IS = 0; /*Subprioridad 0*/
IFS1bits.CAN1IF = 0; /*Limpio la bandera de interrupción*/
INTEnableSystemSingleVectoredInt(); /*Activa el modo Single Vector*/
IEC1bits.CAN1IE = 1; /*Activa la interrupción de CAN1*/
while(1);
return 0;
}
//Rutina de Interrupción
void __ISR(0, ipl1) InterruptHandler(void){
CANRxMessageBuffer buffer;
unsigned int * bufferToRead;
if (C1INTbits.RBIF){ /*Si ha sido interrupción de lectura*/
//if (C1VECbits.ICODE && '0000001'){ /*Verifico que la INT es en la FIFO1*/
/*Compruebo que hay un mensaje para leer*/
if (C1FIFOINT1bits.RXNEMPTYIF == 1){
/*Obtengo la dirección del buffer de lectura*/
bufferToRead = (CANRxMessageBuffer*)(PA_TO_KVA1(C1FIFOUA1));
bufferToRead[0] = buffer -> messageWord[0];
bufferToRead[1] = buffer -> messageWord[1];
bufferToRead[2] = buffer -> messageWord[2];
bufferToRead[3] = buffer -> messageWord[3];
//C1FIFOCON1SET = 0x2000; /*Ya se ha leido la FIFO1*/
/*Actualizo el puntero al buffer de mensajes*/
C1FIFOCON1bits.UINC = 1;
/*Comprobar si hay algún mensaje para leer*/
/*if(buffer -> CMSGEID.DLC == 4){*/
}
//}
}
}
/******************/
IFS1bits.CAN1IF = 0; /*Limpio la bandera de interrupción*/
}
/*Configuramos el reloj del módulo CAN*/
canBitConfig.phaseSeg2Tq = CAN_BIT_3TQ;
canBitConfig.phaseSeg1Tq = CAN_BIT_3TQ;
canBitConfig.propagationSegTq = CAN_BIT_3TQ; <-------------------<< Aqui esta tu problema !! Ponle solo uno
canBitConfig.phaseSeg2TimeSelect = TRUE;
canBitConfig.sample3Time = FALSE;
canBitConfig.syncJumpWidth = CAN_BIT_1TQ;
No, esa velocidad esta bien, pero tienes mal el segmento Propagation Delay, con un Time Quante de 3 cuando debiera ser de 1...Citar
/*Configuramos el reloj del módulo CAN*/
canBitConfig.phaseSeg2Tq = CAN_BIT_3TQ;
canBitConfig.phaseSeg1Tq = CAN_BIT_3TQ;
canBitConfig.propagationSegTq = CAN_BIT_3TQ; <-------------------<< Aqui esta tu problema !! Ponle solo uno
canBitConfig.phaseSeg2TimeSelect = TRUE;
canBitConfig.sample3Time = FALSE;
canBitConfig.syncJumpWidth = CAN_BIT_1TQ;
Como regla de oro:
La suma de Time Quanta de los cuatro valores debe dar igual al prescripto como Number of Time Quanta in one bit
canBitConfig.phaseSeg2Tq = CAN_BIT_3TQ;
canBitConfig.phaseSeg1Tq = CAN_BIT_5TQ;
canBitConfig.propagationSegTq = CAN_BIT_1TQ;
canBitConfig.phaseSeg2TimeSelect = TRUE;
canBitConfig.sample3Time = FALSE;
canBitConfig.syncJumpWidth = CAN_BIT_1TQ;
canBitConfig.phaseSeg2Tq = CAN_BIT_3TQ;
canBitConfig.phaseSeg1Tq = CAN_BIT_3TQ;
canBitConfig.propagationSegTq = CAN_BIT_1TQ;
canBitConfig.phaseSeg2TimeSelect = TRUE;
canBitConfig.sample3Time = FALSE;
canBitConfig.syncJumpWidth = CAN_BIT_1TQ;
/*Mensaje a enviar */
messageTx->messageWord[0] = 0;
messageTx->messageWord[1] = 0;
messageTx->messageWord[2] = 0;
messageTx->messageWord[3] = 0;
messageTx->msgSID.SID = 0x201;
messageTx->msgEID.IDE = 0;
messageTx->msgEID.RTR = 1;
messageTx->msgEID.DLC = 0;
while(1){ <------------------------<< abre nivel 1
if(prueba==0){ <--------------<< abre nivel IF 1
CAN1TxSendRTRMsg();
} >>-----------------------> cierra nivel IF 1
//CAN1TxSendRTRMsg();
//CAN1RxMsgProcess();
/*Verificamos si Tx = Rx*/
if ((messageRx->messageWord[2]==0)){ <-----------<< abre nivel IF 2
_LATF3 = 1;
} >>-----------------> cierra nivel IF 2
else <--------------------<< AQUI DEBIERAS ABRIR NIVEL ELSE 2
_LATF3 = 0;
} >>---------------------> Y AQUI CERRARLO, PERO TOMA ESTE COMO CIERRE DEL IF 2 O ALGO ASI, POR ESO SE VA DE VIAJE....
Hola que tal, soy nuevo en el foro, antes que nada pues felicidades por esta excelente liga sobre el bus "can" mi resumen para describirla es esta expresión "si no esta en esta pagina no esta en internet". Bueno esta pagina en general es mi enciclopedia del "pic", muchas gracias a todos por que aunque nunca había posteado he sido uno de los muchos beneficiados por tantas y tantas veces que me ha sacado de apuros. Volviendo al tema de esta liga tengo un problema con el bus can, apenas estoy comenzando a usarlo, he logrado hacer comunicación can muy simple con CCS pero el problema al que me enfrento es el siguiente, necesito comunicar una tarjeta programada con CCS (por mí) con otra que esta programada en mikroC (por otra persona), el código fuente de la tarjeta transmisora esta en mikroC y la receptora en CCS, cuando ambas tarjetas las programamos en mikroC o en CCS la comunicación siempre funciona pero cuando se pone una y una entonces la comunicación se queda colgada, la transmisión siempre es a 125kb. Imagino que el problema debe ir con los filtros o mascaras pero no entiendo bien como configurar eso. Les agradecería mucho su ayuda mientras tanto volveré a leer las 69 paginas que llevan sobre el modulo can.
#include <18F4580.h>
#include <stdlib.h>
#use delay (clock=20000000)
#use rs232(uart1, baud=9600,TIMEOUT=10)
#fuses HS,NOWDT,WDT256,NOPROTECT,NOPUT,BROWNOUT,NOLVP,NOCPD,NODEBUG,NOWRT
#byte port_c = 0xF82
#byte port_d = 0xF83
#define CAN_DO_DEBUG TRUE
#include "can-18F4580.c"
int16 ms;
const int word_size = 8;//TAMAÑO DE LAS PALABRAS
char XX[word_size];
#define TSE1 0x201
void main() {
struct rx_stat rxstat;
int32 rx_id;
char buffer[8];
int rx_len=8;
int i;
for(i=0;i<8;i++) {
buffer[i]=0;
}
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
can_init();
enable_interrupts(GLOBAL);
printf("INICIO");
SETUP_WDT(WDT_ON);//inicializa el wdt cada 2304 ms
while(true){
if ( can_kbhit() ) {
printf("\r\n");
if(can_getd(rx_id, &buffer, rx_len, rxstat)) {//ID,DATO,TAMAÑO,...
if (rx_id == TSE1) {
for (i=0;i<word_size;i++) XX[i] = buffer[i];
printf("RECIBE: %c%c%c%c%c%c%c%c\r\n",XX[0]XX[1]XX[2]XX[3]XX[4]XX[5]XX[6]XX[7]);
}//END IF IDENTIFICACION RX CAN
}//END IF CAPTURA CAN
}//end can kbhit
restart_wdt();
}//end while
}//end main
El código del transmisor (mikroC) es:unsigned char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len; // received data length in bytes
char RxTx_Data[8]; // can rx/tx data buffer
char Msg_Rcvd;
//const long transmisor = 102, receptor = 3; // node IDs
const long main_node = 0x201;
long Rx_ID;
unsigned int cnt;
unsigned int temp_res;
char envio1[]="ENVIO 01";
void main() {
PORTC = 0; // clear PORTC
TRISA = 0xFF; // PORTA is input
CMCON=7;
T2CON = 0x07; // Timer2 settings
TMR2IF_bit = 0; // clear TMR2IF
TMR2IE_bit = 1; // enable Timer2 interrupt
cnt = 0; // initialize cnt
INTCON = 0xC0; // Set GIE, PEIE
TRISC = 0; // set PORTC as output
LATD = 0 ;
TRISD = 0 ; // set PORTD as output
value = 0; // When program starts, DAC gives
// the output in the mid-range
PORTC.F7 = 1;
PORTC.F6 = 0;
Can_Init_Flags = 0; //
Can_Send_Flags = 0; // clear flags
Can_Rcv_Flags = 0; //
Can_Send_Flags = _CAN_TX_PRIORITY_0 & // form value to be used
_CAN_TX_XTD_FRAME & // with CANWrite
_CAN_TX_NO_RTR_FRAME;
Can_Init_Flags = _CAN_CONFIG_SAMPLE_THRICE & // form value to be used
_CAN_CONFIG_PHSEG2_PRG_ON & // with CANInit
_CAN_CONFIG_XTD_MSG &
_CAN_CONFIG_DBL_BUFFER_ON &
_CAN_CONFIG_VALID_XTD_MSG &
_CAN_CONFIG_LINE_FILTER_OFF;
CANInitialize(1,3,3,3,1,Can_Init_Flags); // initialize external CAN module
CANSetOperationMode(_CAN_MODE_CONFIG,0xFF); // set CONFIGURATION mode
CANSetBaudRate(1,1,8,8,3,_CAN_CONFIG_SAMPLE_ONCE & _CAN_CONFIG_PHSEG2_PRG_ON & _CAN_CONFIG_LINE_FILTER_OFF); //500
CANSetMask(_CAN_MASK_B1,-1,_CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CANSetMask(_CAN_MASK_B2,-1,_CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CANSetFilter(_CAN_FILTER_B2_F3,ID_1001,_CAN_CONFIG_XTD_MSG);// set id of filter B2_F3 to 1st node ID
CANSetOperationMode(_CAN_MODE_NORMAL,0xFF); // set NORMAL mode
while (1) {
CANWrite(main_node, envio1 , 8, Can_Send_Flags);
Delay_ms(1000);
}
}
Ambos códigos son para el pic 18F4580 con cristales de 20Mhz
CANSetOperationMode(_CAN_MODE_CONFIG,0xFF); // set CONFIGURATION mode
BRGCON1 = 0x03;
BRGCON2 = 0xBA;
BRGCON3 = 0x07;
CANSetOperationMode(_CAN_MODE_NORMAL,0xFF); // set NORMAL mode
Así por fin nos quedo configurada bien la velocidad para 125kbps. Te comento que estamos trabajando en un mando a distancia con un touch glcd razón por la cual utilizamos mikroc (en lo particular no me gusta jeje) ya que tiene una herramienta llamada visual glcd y ayuda mucho en la creación del código para el touch.unsigned int Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned int Rx_Data_Len; // received data length in bytes
char RxTx_Data[8]; // can rx/tx data buffer
char Msg_Rcvd; // reception flag
unsigned long Tx_ID, Rx_ID; // can rx and tx ID
void main() {
ADPCFG = 0xFFFF;
PORTB = 0;
TRISB = 0;
Can_Init_Flags = 0; //
Can_Send_Flags = 0; // clear flags
Can_Rcv_Flags = 0; //
Can_Send_Flags = _CAN_TX_PRIORITY_0 & // Form value to be used
_CAN_TX_XTD_FRAME & // with CAN2Write
_CAN_TX_NO_RTR_FRAME;
Can_Init_Flags = _CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
_CAN_CONFIG_PHSEG2_PRG_ON & // with CAN2Initialize
_CAN_CONFIG_XTD_MSG &
_CAN_CONFIG_DBL_BUFFER_ON &
_CAN_CONFIG_MATCH_MSG_TYPE &
_CAN_CONFIG_LINE_FILTER_OFF;
RxTx_Data[0] = 9; // set initial data to be sent
CAN2Initialize(1,3,3,3,1,Can_Init_Flags); // initialize CAN2
CAN2SetOperationMode(_CAN_MODE_CONFIG,0xFF); // set CONFIGURATION mode
CAN2SetMask(_CAN_MASK_B1,-1,_CAN_CONFIG_MATCH_MSG_TYPE & _CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CAN2SetMask(_CAN_MASK_B2,-1,_CAN_CONFIG_MATCH_MSG_TYPE & _CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CAN2SetFilter(_CAN_FILTER_B2_F3,3,_CAN_CONFIG_XTD_MSG); // set id of filter B1_F1 to 3
CAN2SetOperationMode(_CAN_MODE_NORMAL,0xFF); // set NORMAL mode
Tx_ID = 12111; // set transmit ID
CAN2Write(Tx_ID, RxTx_Data, 1, Can_Send_Flags); // send initial message
while(1) { // endless loop
Msg_Rcvd = CAN2Read(&Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags); // receive message
if ((Rx_ID == 3u) && Msg_Rcvd) { // if message received check id
PORTB = RxTx_Data[0]; // id correct, output data at PORTB
RxTx_Data[0]++; // increment received data
Delay_ms(10);
CAN2Write(Tx_ID, RxTx_Data, 1, Can_Send_Flags); // send incremented data back
}
}
}
unsigned int Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned int Rx_Data_Len; // received data length in bytes
char RxTx_Data[8]; // can rx/tx data buffer
char Msg_Rcvd; // reception flag
unsigned long Tx_ID, Rx_ID; // can rx and tx ID
void main() {
ADPCFG = 0xFFFF;
PORTB = 0;
TRISB = 0;
Can_Init_Flags = 0; //
Can_Send_Flags = 0; // clear flags
Can_Rcv_Flags = 0; //
Can_Send_Flags = _CAN_TX_PRIORITY_0 & // Form value to be used
_CAN_TX_XTD_FRAME & // with CAN2Write
_CAN_TX_NO_RTR_FRAME;
Can_Init_Flags = _CAN_CONFIG_SAMPLE_THRICE & // Form value to be used
_CAN_CONFIG_PHSEG2_PRG_ON & // with CAN2Initialize
_CAN_CONFIG_XTD_MSG &
_CAN_CONFIG_DBL_BUFFER_ON &
_CAN_CONFIG_MATCH_MSG_TYPE &
_CAN_CONFIG_LINE_FILTER_OFF;
CAN2Initialize(1,3,3,3,1,Can_Init_Flags); // initialize CAN2
CAN2SetOperationMode(_CAN_MODE_CONFIG,0xFF); // set CONFIGURATION mode
CAN2SetMask(_CAN_MASK_B1,-1,_CAN_CONFIG_MATCH_MSG_TYPE & _CAN_CONFIG_XTD_MSG); // set all mask1 bits to ones
CAN2SetMask(_CAN_MASK_B2,-1,_CAN_CONFIG_MATCH_MSG_TYPE & _CAN_CONFIG_XTD_MSG); // set all mask2 bits to ones
CAN2SetFilter(_CAN_FILTER_B1_F1,12111,_CAN_CONFIG_XTD_MSG); // set id of filter B1_F1 to 12111
CAN2SetOperationMode(_CAN_MODE_NORMAL,0xFF); // set NORMAL mode
Tx_ID = 3; // set tx ID
while(1) { // endless loop
Msg_Rcvd = CAN2Read(&Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags); // receive message
if ((Rx_ID == 12111u) && Msg_Rcvd) { // if message received check id
PORTB = RxTx_Data[0]; // id correct, output data at PORTB
RxTx_Data[0]++; // increment received data
CAN2Write(Tx_ID, RxTx_Data, 1, Can_Send_Flags); // send incremented data back
}
}
}
Estoy estudiando el CAN bus y he leido buena parte del hilo (es difícil porque ya lleva 70 páginas) y no he conseguido responder algunas dudas que tengo.
1º ¿Cómo se mantiene la tensión recesiva del bus de 2.5 voltios?
Imagino que se puede conectar la salida de tensión de referencia de uno de los transceivers MCP2551 al bus. ¿Como se hace? ¿Hay que poner un operacional entre medias? ¿Condensadores? ¿Se conectan 2 resistencias de 60 ohms desde la tensión de referencia a cada cable?
2º Recuerdo que el cable de Devicenet (que usa bus CAN en los niveles OSI 1 y 2) cuesta bastante dinero. Es un cable de 120 ohmios.
El cable ethernet (cat. 5) tiene 100 ohmios, por lo que las resistencias terminadoras de 120 ohmios no tienen la misma impedancia y no evitan reflexiones de la señal.
Para distancias cortas no dara problemas, pero para distancias largas ¿hay cables baratos de 120 ohmios? ¿Se puede poner una resistencia terminadora de 100 ohmios al cable ethernet?
Saludos.
Buenas tardes, estoy tratando de comunicar dos dspic30f4011 con el transceiver MCP2551, y no he tenido éxito. En los pines del dspic C1TX y C1RX midiendo el voltaje me dan el mismo voltaje de alimentación, y en las salidas del trasnceiver CANH y CANL una tension muy cercana a 3v fijos. Me gustaría saber que indican estos niveles de tensión a ver si por allí se identifica el error. Muchas gracias.
Muy buenas tardes espero me puedan ayudar con lo siguiente ..logre la comunicacion de dos dspic30f4013 mediante can bus.. envie un mensaje (mi nombre) de un pic para mostrarlo en un display lcd conectado a otro pic ...el problema es que solo me aparece la primer letra del nombre y nada mas . adjunto el codigo que tengo del pic receptor. muy buenas tardes y gracias
paso el programa del pic transmisor ..el que habia puesto era solo la parte receptora pongo la parte donde mando mensaje por medio de canMuy buenas tardes espero me puedan ayudar con lo siguiente ..logre la comunicacion de dos dspic30f4013 mediante can bus.. envie un mensaje (mi nombre) de un pic para mostrarlo en un display lcd conectado a otro pic ...el problema es que solo me aparece la primer letra del nombre y nada mas . adjunto el codigo que tengo del pic receptor. muy buenas tardes y gracias
No entiendo tu programa, cual es la parte donde transmite en CAN ??
int8 NBYTES; //0 Numero bytes adicionales
int8 MODO; //1 Modo
int8 PID; //2 PID
int8 DATA[5]; //3 Data
Muy buenas noches..estoy haciendo un proyecto de comunicacion can bus con un automovil ...pero alguien tiene idea de las configuracion de velocidad con las que se comunica el can bus del automovil...gracias.N
NODO 1
Hola buenas noches aca te subo un monitoreo de unas tramas que estoy analizando, son de un carro ford el scanne envia las trama con ID720 y el carro responde con las tramaa ID728:
(HEX),720,8,02,11,01,00,00,00,00,00
(HEX),728,8,03,7F,11,22,00,00,00,00
(HEX),720,8,02,10,85,00,00,00,00,00
(HEX),728,8,02,50,85,00,00,00,00,00
(HEX),720,8,02,27,01,00,00,00,00,00
(HEX),728,8,05,67,01,89,45,CC,00,00
(HEX),720,8,05,27,02,A1,18,CA,00,00
(HEX),728,8,03,7F,27,35,00,00,00,00
(HEX),720,8,02,27,01,00,00,00,00,00
(HEX),728,8,05,67,01,D9,8B,52,00,00
(HEX),720,8,05,27,02,16,17,B7,00,00
(HEX),728,8,03,7F,27,35,00,00,00,00
(HEX),720,8,02,27,01,00,00,00,00,00
(HEX),728,8,05,67,01,28,D2,FA,00,00
(HEX),720,8,05,27,02,4C,54,60,00,00
(HEX),728,8,03,7F,27,35,00,00,00,00
(HEX),720,8,02,27,01,00,00,00,00,00
(HEX),728,8,05,67,01,79,18,61,00,00
(HEX),720,8,05,27,02,37,C8,37,00,00
(HEX),728,8,02,67,02,00,00,00,00,00
saludos y si alguien tiene informacion de como analizar las respuesta que envia el carro y segun esas rspuesta lo que luego le envia el equipo. ese es mi proposito de analisis
Hola buenos días, tiempo sin tocar el tema de can bus y nada mejor que postear acá donde inicie hace mucho.
Mi tema es el siempre tengo Arduino y shield can bus de sparkfun. Que me funciona muy bien pero ahora quiero emprender un nuevo proyecto y quiero sus opciones y recomendaciones, he venido trabajando can bus operando todo en el Arduino es decir las trama y procesos de cálculo ahora pretendo crear las tramas y procesar las recibidas en una aplicación aparte específicamente Delphi. Mi consulta puntual es que me recomiendan para crear paquetes de tramas y enviarlos a la interface Arduino-shield can bus. Lo otro como fijar la frecuencia de trabajo y filtrado de tramas del can desde la aplicación y no desde el mismo Arduino como lo vengo haciendo.
Saludos y espero me halla hecho entender.
Hola, si quieres usar elementos ya desarrollados, puedes utilizar la interfase de Microchip, o la USB-CAN de Lawicel, por ejemplo.
Aqui te pongo links a ambas.
https://www.can232.com/ (https://www.can232.com/)
http://www.microchip.com/developmenttools/ProductDetails/PartNo/APGDT002 (http://www.microchip.com/developmenttools/ProductDetails/PartNo/APGDT002)
Hola, yo arme mis interfaces CAN con un PIC con USB, Controlador CAN MCP2515 y el correspondiente transceiver.Estaria encantado de compartirlo de hecho ya tengo mis idea pero quería ver si había algo ya más profesional ya que lo que tengo pensado es hacer mi código en mi interfaz ya sea hecha con Arduino o con Pic y que desde la aplicación que preferiblemente usaría Delphi envíe las tramas y la interfaz la ponga en el bus can y cuando reciba la envíe a mi aplicación ojo la comunicación entre interfaz y Delphi lo haría con rs232, es decir serial
El código del micro (que no puedo darte porque es comercial) tiene varias instrucciones que manejan el intercambio hacia el bus CAN, y ademas se encarga de intercambiar ordenes y respuestas con puerto USB conectado al software en PC, que se corresponde con el desarrollo hecho para esa aplicación comercial.
Puedo ayudarte a desarrollar lo tuyo, pero deberás escribir tu código tu mismo...
Y deberás compartirlo en este hilo.
Saludos
Te recomiendo usar lenguaje C de CCS o de MikroElectronika, ya que ambos tienen librerías C para CAN, de otro modo vas a tener que escribirlas y ademas testearlas tambien.ok hermano mil gracias por tus sabios consejos en tiempo pasado ambos IDE hice par de ejemplo seria cuestion de familiarizarme con ese lenguaje y trabajar en lo que quiero.
En mi caso uso el primero, estoy acostumbrado a el y me es mas comodo.
Saludos
Hola ASTROCAR, en Python tienes la libreria python-can (https://python-can.readthedocs.io/en/3.0.0/index.html) y la puedes instalar fácilmente usando pip (https://pypi.org/project/python-can/)
Hola hermano mil gracias voy a revisar y les aviso como me va con python
Saludos.