Тестер цифровых реле регуляторов

[меркул]

Пользую motorherz crt 2.0.
Хорошо успел в своё время купить за 25000р

Сейчас нашёл самый дешёвый https://gmgauto.ru/products/MOTORHERZ/CRT20.html

[AzarOF]

6 часов назад, OreXov сказал:

Приветствую, я так понял тема затихла пока, ни кто не знает где приобрести готовый девайс ?

TRG - 1100 не рассматривал в качестве готового девайса  ?

[OreXov]

4 минуты назад, AzarOF сказал:

TRG - 1100 не рассматривал в качестве готового девайса  ?

Не, не смотрел, С Сергеем созвонился. Попробую купить напрямую.

[AzarOF]

1 минуту назад, OreXov сказал:

Не, не смотрел, С Сергеем созвонился. Попробую купить напрямую.

ЧТо купить ?

3 минуты назад, AzarOF сказал:

ЧТо купить ?

О какой пристаке речь и какая цена ?

[OreXov]

ARC-311

[AzarOF]

Только что, OreXov сказал:

ARC-311

Понял, а каков на неё ценник ?

[OreXov]

40

[AzarOF]

Только что, OreXov сказал:

40

Спасибо, себе тоже ищу , остановился пока  TRG

 

[OreXov]

на авито  25 трг есть

[AzarOF]

1 минуту назад, OreXov сказал:

на авито  25 трг есть

Поэтому на ней и остановился

[CERGEY121]

1 час назад, OreXov сказал:

ARC-311

тоже такой пользуюсь,чень доволен 

[AzarOF]

40 минут назад, CERGEY121 сказал:

тоже такой пользуюсь,чень доволен 

Когда его приобрёл и по какой цене ?

[CERGEY121]

10 минут назад, AzarOF сказал:

Когда его приобрёл и по какой цене ?

год - полтора назад, точно не помню за 30 брал

[AzarOF]

13 минут назад, CERGEY121 сказал:

год - полтора назад, точно не помню за 30 брал

Сегодня цены увы больше (((((

[Евгений Ст]

Проект умер? Жаль..

[chuckha]

Привет Евгений Ст, Я дома балуюсь с LIN BUS на ардуинке, пытаюсь понять как оно работает и даже кое чего нарыл, так то оно дело не сложное но нет знаний в програмировании вот пришлось начать с того что леды на ардуинке зажигать. Есть несколько приборов для проверки регуляторов с которых можно снять сигнал а так же CAN LIN хакер

в нём всё чётко видно что шлёт что принимает, только пока нет знаний как это всё сделать.

Здесь подробно об LIN https://www.csselectronics.com/pages/lin-bus-protocol-intro-basics

Здесь канХакер которым пользуюсь https://canhacker.ru/шина-lin/что-такое-шина-lin/

Здесь брал LIN to TTL  https://www.aliexpress.com/item/1005006348310876.html

Есть ещё инфо если надо

[AzarOF]

В 22.02.2024 в 20:56, CERGEY121 сказал:

год - полтора назад, точно не помню за 30 брал

Вижу тему подняли.....всё таки взял TRG-1100

Нормальный инструмент, есть обновы....да, монохромный дисплей, но тут как бы и цена.

Корпус металл. Всё интуитивно понятно, свои функции выполняет.

Уже давно пользуюсь.....продавец всегда на связи, если возникают вопросы, отвечает сразу....

Был один момент с генератором FF3 valeo на LIN , прибор показывал ошибку T , оказалось это перрегрев реле регулятора, просто этого не было в мануале.

Я доволен.

[Евгений Ст]

В 14.06.2024 в 14:05, chuckha сказал:

Привет Евгений Ст, Я дома балуюсь с LIN BUS на ардуинке, пытаюсь понять как оно работает и даже кое чего нарыл, так то оно дело не сложное но нет знаний в програмировании вот пришлось начать с того что леды на ардуинке зажигать. Есть несколько приборов для проверки регуляторов с которых можно снять сигнал а так же CAN LIN хакер

в нём всё чётко видно что шлёт что принимает, только пока нет знаний как это всё сделать.

Здесь подробно об LIN https://www.csselectronics.com/pages/lin-bus-protocol-intro-basics

Здесь канХакер которым пользуюсь https://canhacker.ru/шина-lin/что-такое-шина-lin/

Здесь брал LIN to TTL  https://www.aliexpress.com/item/1005006348310876.html

Есть ещё инфо если надо

Да, знать бы программирование, можно было много чего реализовать. Я вот тоже пытался выездной инструмент собрать на ардуине, да так и валяется всё по углам.

[chuckha]

Привет Евгений Ст, здесь все расписано https://github.com/macchina/LIN, 

тестер регуляторов работает как LIN bomber, шлёт сначало 13 нулей(бит) потом 1(бит) еденицу после чего синхронизирует 010101(0х55 в HEX) потом шлёт заголовок от 0 до 3B тут точнее -  (

ЛИН ПАКЕТ:
 Он состоит из:
 ___________ __________ _______ ____________ _________
 | | | | | |
 |Разрыв синхронизации|Байт синхронизации|Байт идентификатора| Байты данных |Контрольная сумма |
 |___________|__________|_______|____________|_________|

 Каждый байт имеет стартовый и стоповый бит, и первым отправляется младший бит.
 Разрыв синхронизации — 13 бит доминантного состояния («0»), за которыми следует 1 бит рецессивного состояния («1»).
 Synch Byte — байт для синхронизации связанной скорости, всегда 0x55.
 Байт идентификатора — состоит из четности, длины и адреса; четность определяется стандартом LIN и зависит от адреса и длины сообщения.
 Байты данных – определяются пользователем; зависит от устройств на шине LIN
 Контрольная сумма – инвертированная контрольная сумма 256; байты данных суммируются, а затем инвертируются)

 

все регуляторы что у меня есть отвечают на заголовок "92", регулирование на "15" сейчас не помню но могу посмотреть.

Тут описание библиотеки я её сейчас изучаю

/*  Copyright (c) 2016 Macchina
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included
 *  in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 *  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 *  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 *  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 *  LIN STACK for TJA1021
 *  v2.0
 *
 *  Short description:
 *  Comunication stack for LIN and TJA1021 LIN transceiver.
 *  Can be modified for any Arduino board with UART available and any LIN slave.
 *  
 *  Author: Blaž Pongrac B.S., RoboSap, Institute of Technology, Ptuj (www.robosap-institut.eu)
 *  
 *  Arduino IDE 1.6.9
 *  RoboSap, Institute of Technology, September 2016
 */

#include <lin_stack.h>

/* LIN PACKET:
   It consist of:
    ___________ __________ _______ ____________ _________
   |           |          |       |            |         |
   |Synch Break|Synch Byte|ID byte| Data Bytes |Checksum |
   |___________|__________|_______|____________|_________|
   
   Every byte have start bit and stop bit and it is send LSB first.
   Synch Break - 13 bits of dominant state ("0"), followed by 1 bit recesive state ("1")
   Synch Byte - Byte for Bound rate syncronization, always 0x55
   ID Byte - consist of parity, length and address; parity is determined by LIN standard and depends from address and message length
   Data Bytes - user defined; depend on devices on LIN bus
   Checksum - inverted 256 checksum; data bytes are sumed up and then inverted
*/

// CONSTRUCTORS
lin_stack::lin_stack(byte Ch){
    sleep_config(Ch); // Configurating Sleep pin for transceiver
    ch = Ch;
}

lin_stack::lin_stack(byte Ch, byte ident){
    sleep_config(Ch); // Configuration of Sleep pin for transceiver
    identByte = ident; // saving idet to private variable
    sleep(1); // Transceiver is always in Normal Mode
}

// PUBLIC METHODS
// WRITE methods
// Creates a LIN packet and then send it via USART(Serial) interface.
int lin_stack::write(byte ident, byte data[], byte data_size){
    // Calculate checksum
    byte suma = 0;
    for(int i=0;i<data_size;i++)
        suma = suma + data[i];
    //suma = suma + 1;
    byte checksum = 255 - suma;
    // Start interface
    sleep(1); // Go to Normal mode
    // Synch Break
    serial_pause(13);
    // Send data via Serial interface
    if(ch==1){ // For LIN1 or Serial1
        Serial1.begin(bound_rate); // config Serial
        Serial1.write(0x55); // write Synch Byte to serial
        Serial1.write(ident); // write Identification Byte to serial
        for(int i=0;i<data_size;i++) Serial1.write(data[i]); // write data to serial
        Serial1.write(checksum); // write Checksum Byte to serial
        Serial1.end(); // clear Serial config
    }else if(ch==2){ // For LIN2 or Serial2
        Serial2.begin(bound_rate); // config Serial
        Serial2.write(0x55); // write Synch Byte to serial
        Serial2.write(ident); // write Identification Byte to serialv
        for(int i=0;i<data_size;i++) Serial2.write(data[i]); // write data to serial
        Serial2.write(checksum);// write Checksum Byte to serial
        Serial2.end(); // clear Serial config
    }
    sleep(0); // Go to Sleep mode
    return 1;
}

int lin_stack::writeRequest(byte ident){
    // Create Header
    byte identByte = (ident&0x3f) | calcIdentParity(ident);
    byte header[2]= {0x55, identByte};
    // Start interface
    sleep(1); // Go to Normal mode
    // Synch Break
    serial_pause(13);
    // Send data via Serial interface
    if(ch==1){ // For LIN1 or Serial1
        Serial1.begin(bound_rate); // config Serial
        Serial1.write(header,2); // write data to serial
        Serial1.end(); // clear Serial config
    }else if(ch==2){ // For LIN2 or Serial2
        Serial2.begin(bound_rate); // config Serial
        Serial2.write(header,2); // write data to serial
        Serial2.end(); // clear Serial config
    }
    sleep(0); // Go to Sleep mode
    return 1;
}

int lin_stack::writeResponse(byte data[], byte data_size){
    // Calculate checksum
    byte suma = 0;
    for(int i=0;i<data_size;i++) suma = suma + data[i];
    //suma = suma + 1;
    byte checksum = 255 - suma;
    // Start interface
    sleep(1); // Go to Normal mode
    // Send data via Serial interface
    if(ch==1){ // For LIN1 or Serial1
        Serial1.begin(bound_rate); // config Serial
        Serial1.write(data, data_size); // write data to serial
        Serial1.write(checksum); // write data to serial
        Serial1.end(); // clear Serial config
    }else if(ch==2){ // For LIN2 or Serial2
        Serial2.begin(bound_rate); // config Serial
        Serial2.write(data, data_size); // write data to serial
        Serial2.write(checksum); // write data to serial
        Serial2.end(); // clear Serial config
    }
    sleep(0); // Go to Sleep mode
    return 1;
}

int lin_stack::writeStream(byte data[], byte data_size){
    // Start interface
    sleep(1); // Go to Normal mode
    // Synch Break
    serial_pause(13);
    // Send data via Serial interface
    if(ch==1){ // For LIN1 or Serial1
        Serial1.begin(bound_rate); // config Serial
        for(int i=0;i<data_size;i++) Serial1.write(data[i]);
        Serial1.end(); // clear Serial config
    }else if(ch==2){ // For LIN2 or Serial2
        Serial2.begin(bound_rate); // config Serial
        for(int i=0;i<data_size;i++) Serial2.write(data[i]);
        Serial2.end(); // clear Serial config
    }
    sleep(0); // Go to Sleep mode
    return 1;
}

// READ methods
// Read LIN traffic and then proces it.
int lin_stack::setSerial(){ // Only needed when receiving signals
    if(ch==1){ // For LIN1 (Channel 1)
        Serial1.begin(bound_rate); // Configure Serial1
        PIOA->PIO_PUER = PIO_PA10; // We need software Pull-Up because there is no hardware Pull-Up resistor
    } else if(ch==2){ // For LIN2 (Channel 2)
        Serial2.begin(bound_rate); // Configure Serial1
        PIOA->PIO_PUER = PIO_PA12; // We need software Pull-Up because there is no hardware Pull-Up resistor
    }
}

int lin_stack::read(byte data[], byte data_size){
    byte rec[data_size+3];
    if(ch==1){ // For LIN1 or Serial1
        if(Serial1.read() != -1){ // Check if there is an event on LIN bus
            Serial1.readBytes(rec,data_size+3);
            if((validateParity(rec[1]))&(validateChecksum(rec,data_size+3))){
                for(int j=0;j<data_size;j++){
                data[j] = rec[j+2];
                }
                return 1;
            }else{
                return -1;
            }    
        }
    }else if(ch==2){ // For LIN2 or Serial2
        if(Serial2.read() != -1){ // Check if there is an event on LIN bus
            Serial2.readBytes(rec,data_size+3);
            if((validateParity(rec[1]))&(validateChecksum(rec,data_size+3))){
                for(int j=0;j<data_size;j++){
                data[j] = rec[j+2];
                }
                return 1;
            }else{
                return -1;
            }    
        }
    }
    return 0;
}

int lin_stack::readStream(byte data[],byte data_size){
    byte rec[data_size];
    if(ch==1){ // For LIN1 or Serial1
        if(Serial1.read() != -1){ // Check if there is an event on LIN bus
            Serial1.readBytes(rec,data_size);
            for(int j=0;j<data_size;j++){
                data[j] = rec[j];
            }
            return 1;
        }
    }else if(ch==2){ // For LIN2 or Serial2
        if(Serial2.read() != -1){ // Check if there is an event on LIN bus
            Serial2.readBytes(data,data_size);
            return 1;
        }
    }
    return 0;
}

// PRIVATE METHODS
int lin_stack::serial_pause(int no_bits){
    // Calculate delay needed for 13 bits, depends on bound rate
    unsigned int del = period*no_bits; // delay for number of bits (no-bits) in microseconds, depends on period
    if(ch==2){
        PIOA->PIO_PER = PIO_PA13; // enable PIO register
        PIOA->PIO_OER = PIO_PA13; // enable PA13 as output
        PIOA->PIO_CODR = PIO_PA13; // clear PA13
        delayMicroseconds(del); // delay
        PIOA->PIO_SODR = PIO_PA13; // set pin high
        PIOA->PIO_ODR = PIO_PA13; // enable PA13 as output
        PIOA->PIO_PDR = PIO_PA13; // clear configuration for PIO, needs to be done because Serial wont work with it
    }else if(ch==1){
        PIOA->PIO_PER = PIO_PA11; // enable PIO register
        PIOA->PIO_OER = PIO_PA11; // enable PA11 as output
        PIOA->PIO_CODR = PIO_PA11; // clear PA11
        delayMicroseconds(del); // delay
        PIOA->PIO_SODR = PIO_PA11; // set pin high
        PIOA->PIO_ODR = PIO_PA11; // enable PA13 as output
        PIOA->PIO_PDR = PIO_PA11; // clear configuration for PIO, needs to be done because Serial wont work with it
    }
    return 1;
}

int lin_stack::sleep(byte sleep_state){
    if(sleep_state==1){ // Go to Normal mode
        if(ch==1) PIOB->PIO_SODR = PIO_PB4; // Set PB4, high state, normal mode
        if(ch==2) PIOB->PIO_SODR = PIO_PB7; // Set PB7, high state, normal mode
    }else if(sleep_state==0){ // Go to Sleep mode
        if(ch==1) PIOB->PIO_CODR = PIO_PB4; // Clear PB4, low state, sleep mode
        if(ch==2) PIOB->PIO_CODR = PIO_PB7; // Clear PB7, low state, sleep mode
    }
    delayMicroseconds(20); // According to TJA1021 datasheet this is needed for proper working
    return 1;
}

int lin_stack::sleep_config(byte serial_No){
    if(serial_No==1){ // When using LIN1 channel - usign Serial1 and pin PB4 for Sleep
        PIOB->PIO_PER = PIO_PB4; // enable PIO register on pin PB4
        PIOB->PIO_OER = PIO_PB4; // set PB4 as output
        PIOB->PIO_PUDR = PIO_PB4; // disable pull-up
        ch=1; // saved as private variable, used for determening Serial port
    }else if(serial_No==2)
    { // When using LIN2 channel - usign Serial2 and pin PB7 for Sleep
        PIOB->PIO_PER = PIO_PB7; // enable PIO register on pin PB7
        PIOB->PIO_OER = PIO_PB7; // set PB7 as output
        PIOB->PIO_PUDR = PIO_PB7; // disable pull-up
        ch=2; // saved as private variable, used for determening Serial port
    }
    return 1;
}

boolean lin_stack::validateParity(byte ident) {
    if(ident == identByte)
        return true;
    else
        return false;
}

boolean lin_stack::validateChecksum(unsigned char data[], byte data_size){
    byte checksum = data[data_size-1];
    byte suma = 0;
    for(int i=2;i<data_size-1;i++)
        suma = suma + data[i];
    byte v_checksum = 255 - suma - 1;
    if(checksum==v_checksum)
        return true;
    else
        return false;
}

int lin_stack::busWakeUp()
{
  unsigned int del = period*10; // random delay for dominant signal, has to be in the timeframe from 250us ... 5ms
  if(ch==2)
  {
    PIOA->PIO_PER = PIO_PA13; // enable PIO register
    PIOA->PIO_OER = PIO_PA13; // enable PA13 as output
    PIOA->PIO_CODR = PIO_PA13; // clear PA13
    delayMicroseconds(del); // delay
    PIOA->PIO_SODR = PIO_PA13; // set pin high
    PIOA->PIO_PDR = PIO_PA13; // clear configuration for PIO, needs to be done because Serial wont work with it
  }
  else if(ch==1)
  {
    PIOA->PIO_PER = PIO_PA11; // enable PIO register
    PIOA->PIO_OER = PIO_PA11; // enable PA11 as output
    PIOA->PIO_CODR = PIO_PA11; // clear PA11
    delayMicroseconds(del); // delay
    PIOA->PIO_SODR = PIO_PA11; // set pin high
    PIOA->PIO_PDR = PIO_PA11; // clear configuration for PIO, needs to be done because Serial wont work with it
  }
  return 1;
}

/* Create the Lin ID parity */
#define BIT(data,shift) ((ident&(1<<shift))>>shift)
byte lin_stack::calcIdentParity(byte ident)
{
  byte p0 = BIT(ident,0) ^ BIT(ident,1) ^ BIT(ident,2) ^ BIT(ident,4);
  byte p1 = ~(BIT(ident,1) ^ BIT(ident,3) ^ BIT(ident,4) ^ BIT(ident,5));
  return (p0 | (p1<<1))<<6;
}