//diag_l0_elm_close : free pdl0d->dl0 (dev), call diag_tty_close. static int diag_l0_elm_close(struct diag_l0_device **pdl0d) { assert(pdl0d != NULL); assert(*pdl0d != NULL); uint8_t buf[]="ATPC\x0D"; elm_sendcmd(*pdl0d, buf, 5, 500, NULL); //close protocol. So clean ! if (pdl0d && *pdl0d) { struct diag_l0_device *dl0d = *pdl0d; struct diag_l0_elm_device *dev = (struct diag_l0_elm_device *)dl0d->l0_int; /* If debugging, print to stderr */ if (diag_l0_debug & DIAG_DEBUG_CLOSE) fprintf(stderr, FLFMT "link %p closing\n", FL, (void *) dl0d); if (dev) free(dev); (void) diag_tty_close(dl0d); diag_l0_del(*pdl0d); } return 0; }
/* * Open the diagnostic device, returns a file descriptor * records original state of term interface so we can restore later */ static struct diag_l0_device * diag_l0_muleng_open(const char *subinterface, int iProtocol) { int rv; struct diag_l0_device *dl0d; struct diag_l0_muleng_device *dev; struct diag_serial_settings set; if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "open subinterface %s protocol %d\n", FL, subinterface, iProtocol); } diag_l0_muleng_init(); if ((rv=diag_calloc(&dev, 1))) return diag_pseterr(rv); dev->protocol = iProtocol; dl0d = diag_l0_new(&diag_l0_me, (void *)dev); if (!dl0d) { free(dev); return diag_pseterr(rv); } /* try to open TTY */ if ((rv=diag_tty_open(dl0d, subinterface))) { diag_l0_del(dl0d); free(dev); return diag_pseterr(rv); } /* And set to 19200 baud , 8N1 */ set.speed = 19200; set.databits = diag_databits_8; set.stopbits = diag_stopbits_1; set.parflag = diag_par_n; if ((rv=diag_tty_setup(dl0d, &set))) { diag_l0_muleng_close(dl0d); return diag_pseterr(rv); } /* And set DTR high and RTS low to power the device */ if ((rv=diag_tty_control(dl0d, 1, 0))) { diag_l0_muleng_close(dl0d); return diag_pseterr(rv); } diag_tty_iflush(dl0d); /* Flush unread input */ return dl0d ; }
/* * Open the diagnostic device, returns a file descriptor * records original state of term interface so we can restore later */ static struct diag_l0_device * diag_l0_dumb_open(const char *subinterface, int iProtocol) { int rv; struct diag_l0_device *dl0d; struct diag_l0_dumb_device *dev; if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "open subinterface %s protocol %d\n", FL, subinterface, iProtocol); } diag_l0_dumb_init(); //make sure it is initted if ((rv=diag_calloc(&dev, 1))) return diag_pseterr(DIAG_ERR_NOMEM); dev->protocol = iProtocol; dl0d = diag_l0_new(&diag_l0_dumb, (void *)dev); if (!dl0d) { free(dev); return diag_pseterr(rv); } /* try to open TTY */ if ((rv=diag_tty_open(dl0d, subinterface))) { diag_l0_del(dl0d); free(dev); return diag_pseterr(rv); } /* * We set RTS to low, and DTR high, because this allows some * interfaces to work than need power from the DTR/RTS lines; * this is altered according to dumb_flags. */ if (diag_tty_control(dl0d, !(dumb_flags & CLEAR_DTR), (dumb_flags & SET_RTS)) < 0) { diag_l0_dumb_close(&dl0d); return diag_pseterr(DIAG_ERR_GENERAL); } if (dumb_flags & DUMBDEFAULTS) dumb_flags = DUMBDEFAULTS & MAN_BREAK; (void)diag_tty_iflush(dl0d); /* Flush unread input */ return dl0d; }
static int diag_l0_br_close(struct diag_l0_device **pdl0d) { if (pdl0d && *pdl0d) { struct diag_l0_device *dl0d = *pdl0d; struct diag_l0_br_device *dev = (struct diag_l0_br_device *)dl0d->l0_int; if (diag_l0_debug & DIAG_DEBUG_CLOSE) fprintf(stderr, FLFMT "link %p closing\n", FL, (void *)dl0d); if (dev) free(dev); (void) diag_tty_close(dl0d); diag_l0_del(dl0d); } return 0; }
static void diag_l0_muleng_close(struct diag_l0_device *dl0d) { if (!dl0d) return; struct diag_l0_muleng_device *dev = (struct diag_l0_muleng_device *)dl0d->l0_int; if (diag_l0_debug & DIAG_DEBUG_CLOSE) fprintf(stderr, FLFMT "link %p closing\n", FL, (void *)dl0d); if (dev) free(dev); diag_tty_close(dl0d); diag_l0_del(dl0d); return; }
/* * Open the diagnostic device, return a file descriptor, * record the original state of term interface so we can restore later */ static struct diag_l0_device * diag_l0_br_open(const char *subinterface, int iProtocol) { struct diag_l0_device *dl0d; struct diag_l0_br_device *dev; int rv; uint8_t buf[4]; /* Was MAXRBUF. We only use 1! */ struct diag_serial_settings set; diag_l0_br_init(); if ((rv=diag_calloc(&dev, 1))) return diag_pseterr(rv); dev->protocol = iProtocol; dev->dev_rdoffset = 0; dev->dev_txlen = 0; dev->dev_framenr = 0; dev->dev_state = BR_STATE_CLOSED; dev->dev_features = BR_FEATURE_SETADDR; /* Get an L0 link */ dl0d = diag_l0_new(&diag_l0_br, (void *)dev); if (!dl0d) { free(dev); return diag_pseterr(rv); } /* try to open TTY */ if ((rv=diag_tty_open(dl0d, subinterface))) { diag_l0_del(dl0d); free(dev); return diag_pseterr(rv); } if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "features 0x%X\n", FL, dev->dev_features); } /* Set serial line to 19200 baud , 8N1 */ set.speed = 19200; set.databits = diag_databits_8; set.stopbits = diag_stopbits_1; set.parflag = diag_par_n; if (diag_tty_setup(dl0d, &set)) { fprintf(stderr, FLFMT "open: TTY setup failed\n", FL); diag_l0_br_close(&dl0d); return diag_pseterr(rv); } diag_tty_iflush(dl0d); /* Flush unread input data */ /* * Initialise the BR1 interface by sending the CHIP CONNECT * (0x20h) command, we should get a 0xFF back */ buf[0] = 0x20; if (diag_l0_br_write(dl0d, buf, 1)) { if ((diag_l0_debug&DIAG_DEBUG_OPEN)) { fprintf(stderr, FLFMT "CHIP CONNECT write failed link %p\n", FL, (void *)dl0d); } diag_l0_br_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } /* And expect 0xff as a response */ if (diag_tty_read(dl0d, buf, 1, 100) != 1) { if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "CHIP CONNECT read failed link %p\n", FL, (void *)dl0d); } diag_l0_br_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } if (buf[0] != 0xff) { if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "CHIP CONNECT rcvd 0x%X != 0xff, link %p\n", FL, buf[0], (void *)dl0d); } diag_l0_br_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } /* If it's J1850, send initialisation string now */ rv = 0; switch (iProtocol) { case DIAG_L1_J1850_VPW: rv = diag_l0_br_initialise(dl0d, 0, 0); break; case DIAG_L1_J1850_PWM: rv = diag_l0_br_initialise(dl0d, 1, 0); break; case DIAG_L1_ISO9141: case DIAG_L1_ISO14230: /* This initialisation is done in the SLOWINIT code */ break; } if (rv) { diag_l0_br_close(&dl0d); return diag_pseterr(rv); } if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "open succeeded link %p features 0x%X\n", FL, (void *)dl0d, dev->dev_features); } return dl0d; }
/* * Open the diagnostic device * ELM settings used : no echo (E0), headers on (H1), linefeeds off (L0), mem off (M0) */ static struct diag_l0_device * diag_l0_elm_open(const char *subinterface, int iProtocol) { int i,rv; struct diag_l0_device *dl0d; struct diag_l0_elm_device *dev; struct diag_serial_settings sset; const uint8_t *buf; uint8_t rxbuf[ELM_BUFSIZE]; const char ** elm_official; const char ** elm_clones; //point to elm323_ or elm327_ clone and official version string lists if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "open subinterface %s protocol %d\n", FL, subinterface, iProtocol); } diag_l0_elm_init(); if ((rv=diag_calloc(&dev, 1))) return diag_pseterr(rv); dev->protocol = iProtocol; dl0d = diag_l0_new(&diag_l0_elm, (void *)dev); if (!dl0d) { free(dev); return diag_pseterr(rv); } /* try to open TTY */ if ((rv=diag_tty_open(dl0d, subinterface))) { diag_l0_del(dl0d); free(dev); return diag_pseterr(rv); } //set speed to 38400;8n1. sset.speed=38400; sset.databits = diag_databits_8; sset.stopbits = diag_stopbits_1; sset.parflag = diag_par_n; dev->serial = sset; if ((rv=diag_tty_setup(dl0d, &sset))) { fprintf(stderr, FLFMT "Error setting 38400;8N1 on %s\n", FL, subinterface); diag_l0_elm_close(&dl0d); return diag_pseterr(rv); } diag_tty_iflush(dl0d); /* Flush unread input */ //At this stage, the ELM has possibly been powered up for a while; //it may have an unfinished command / garbage in its input buffer. We //need to clear that before sending the real ATZ ==> ATI is quick and safe; elm_purge does this. dev->elmflags=0; //we know nothing yet rv=elm_purge(dl0d); //if rv=0, we got a prompt so we know speed is set properly. if (rv==0) { dev->elmflags |= ELM_38400; } else { fprintf(stderr, FLFMT "sending ATI @ 38400 failed; trying @ 9600...\n", FL); sset.speed=9600; dev->serial = sset; if ((rv=diag_tty_setup(dl0d, &sset))) { fprintf(stderr, FLFMT "Error setting 9600;8N1 on %s\n", FL, subinterface); diag_l0_elm_close(&dl0d); return diag_pseterr(rv); } diag_tty_iflush(dl0d); /* Flush unread input */ rv = elm_purge(dl0d); //try ATI\r again if (rv !=0) { fprintf(stderr, FLFMT "sending ATI @ 9600 failed. Verify connection to ELM\n", FL); diag_l0_elm_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } } if (diag_l0_debug&DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "elm_open : sending ATZ...\n", FL); } //the command "ATZ" causes a full reset and the ELM replies with //a string like "ELM32x vX.Xx\n>" buf=(uint8_t *)"ATZ\x0D"; rv=elm_sendcmd(dl0d, buf, 4, 2000, rxbuf); if (rv) { fprintf(stderr, FLFMT "elm_open : ATZ failed !\n", FL); diag_l0_elm_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } //Correct prompt received; try to identify device. // 1) guess 323 vs 327 if (strstr((char *)rxbuf, "ELM323")!=NULL) { dev->elmflags |= ELM_323_BASIC; elm_official=elm323_official; elm_clones=elm323_clones; } else if (strstr((char *)rxbuf, "ELM327")!=NULL) { dev->elmflags |= ELM_327_BASIC; elm_official=elm327_official; elm_clones=elm327_clones; } else { fprintf(stderr, FLFMT "no valid version string !! Report this !. Got:\n%s\n", FL, rxbuf); //no point in continuing... diag_l0_elm_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } // 2) identify valid VS clone devices. rv=0; // temp "device identified" flag for (i=0; elm_clones[i]; i++) { if (strstr((char *)rxbuf, elm_clones[i])) { printf("Clone ELM found, v%s\n", elm_clones[i]); dev->elmflags |= ELM_32x_CLONE; rv=1; break; } } if (rv==0) { for (i=0; elm_official[i]; i++) { if (strstr((char *)rxbuf, elm_official[i])) { printf("Official ELM found, v%s\n", elm_official[i]); rv=1; break; } } } if (rv==0) { //still not identified : assume clone. dev->elmflags |= ELM_32x_CLONE; printf("ELM version not recognized! Please report this ! Resp=%s\n", rxbuf); } if ((dev->elmflags & ELM_323_BASIC) && (dev->elmflags & ELM_32x_CLONE)) { printf("A 323 clone ? Report this !\n"); } if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "ELM reset success, elmflags=%#x\n", FL, dev->elmflags); } //now send "ATE0\n" command to disable echo. buf=(uint8_t *)"ATE0\x0D"; if (elm_sendcmd(dl0d, buf, 5, 500, NULL)) { if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "sending \"ATE0\" failed\n", FL); } diag_l0_elm_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } //ATL0 : disable linefeeds buf=(uint8_t *)"ATL0\x0D"; if (elm_sendcmd(dl0d, buf, 5, 500, NULL)) { if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "sending \"ATL0\" failed\n", FL); } diag_l0_elm_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } //ATH1 : always show header bytes buf=(uint8_t *)"ATH1\x0D"; if (elm_sendcmd(dl0d, buf, 5, 500, NULL)) { if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "sending \"ATH1\" failed\n", FL); } diag_l0_elm_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } //for elm327 only: disable memory if (dev->elmflags & ELM_327_BASIC) { buf=(uint8_t *)"ATM0\x0D"; if (elm_sendcmd(dl0d, buf, 5, 500, NULL)) { if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "sending \"ATM0\" failed\n", FL); } diag_l0_elm_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } } //check if proto is really supported (323 supports only 9141 and 14230) if ((dev->elmflags & ELM_323_BASIC) && ((iProtocol != DIAG_L1_ISO9141) && (iProtocol != DIAG_L1_ISO14230))) return diag_pseterr(DIAG_ERR_PROTO_NOTSUPP); //if 327, set proto when possible; we won't if 14230, because init type (fast vs slow) isn't decided yet // CAN is also not implemented here buf=NULL; if (dev->elmflags & ELM_327_BASIC) { switch (iProtocol) { case DIAG_L1_J1850_PWM: buf=(uint8_t *)"ATTP1\x0D"; break; case DIAG_L1_J1850_VPW: buf=(uint8_t *)"ATTP2\x0D"; break; case DIAG_L1_ISO9141: buf=(uint8_t *)"ATTP3\x0D"; break; default: buf=NULL; } } if (buf != NULL) { if (elm_sendcmd(dl0d, buf, 6, 500, NULL)) { if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "sending \"ATTPx\" failed\n", FL); } diag_l0_elm_close(&dl0d); return diag_pseterr(DIAG_ERR_BADIFADAPTER); } } //at this point : ELM is ready for further ops if (diag_l0_debug & DIAG_DEBUG_OPEN) { fprintf(stderr, FLFMT "ELM ready.\n", FL); } return dl0d; }