skoda rapid 2015 не видит статусы по can / Общение на любые темы / StarLine

Разработка панели приборов на основе raspberry pi и 7″ дисплея

В качестве аппаратной части я выбрал Raspberry Pi. Была идея использовать Android планшет, но показалось, что на Raspberry Pi будет проще и быстрее. В итоге докупил официальный 7″ дисплей, и сделал CAN шилд из модуля TJA1050 Niren.

OBD2 штекер использовал от старого ELM327 адаптера.

Используются контакты: CAN_L, CAN_H, 12, GND.

Тесты в машине прошли успешно и теперь нужно было все собрать. Плату дисплея, Raspberry Pi и блок питания разместил на куске черного пластика, очень удачно подобрал пластмассовые втулки, с ними ничего не болтается и надежно закреплено.

Местом установки выбрал бардачок на торпедо, которым я не пользуюсь. По примеркам в него как раз помещается весь бутерброд.

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

Описание стандарта [ править | править код ]

Непосредственно стандарт CAN компании Bosch определяет передачу в отрыве от физического уровня — он может быть каким угодно, например, радиоканалом или оптоволокном. Но на практике под CAN-сетью обычно подразумевается сеть топологии «шина» с физическим уровнем в виде дифференциальной пары, определённым в стандарте ISO 11898.

Can bus car radio skoda rapid на алиэкспресс — купить онлайн по выгодной цене

Can сниффер из arduino uno

Чтобы послушать, что отправляет VCDS в CAN шину я собрал сниффер на макетке из Arduino и модуля MCP2515 TJA1050 Niren.

Схема подключения следующая:

Skoda rapid 2021 не видит статусы по can / общение на любые темы / starline

Арбитраж доступа [ править | править код ]

При свободной шине любой узел может начинать передачу в любой момент. В случае одновременной передачи кадров двумя и более узлами проходит арбитраж доступа: передавая идентификатор, узел одновременно проверяет состояние шины. Если при передаче рецессивного бита принимается доминантный — считается, что другой узел передаёт сообщение с большим приоритетом, и передача откладывается до освобождения шины.

Базовый формат кадра данных [ править | править код ]

Первые 7 бит идентификатора не должны быть все рецессивными.

Видео работы цифровой панели приборов на базе raspberry pi

ОБНОВЛЕНО 24.06.2021

Виды кадров [ править | править код ]

• Кадр данных (data frame) — передаёт данные;
• Кадр удаленного запроса (remote frame) — служит для запроса на передачу кадра данных с тем же идентификатором;
• Кадр перегрузки (overload frame) — обеспечивает промежуток между кадрами данных или запроса;
• Кадр ошибки (error frame) — передаётся узлом, обнаружившим в сети ошибку.

Кадры данных и запроса отделяются от предыдущих кадров межкадровым промежутком.

Диапазон скоростей [ править | править код ]

Все узлы в сети должны работать с одной скоростью. Стандарт CAN не определяет скоростей работы, но большинство как отдельных, так и встроенных в микроконтроллеры адаптеров позволяют плавно менять скорость в диапазоне, по крайней мере, от 20 килобит в секунду до 1 мегабита в секунду. Существуют решения, выходящие далеко за рамки данного диапазона.

Как работает can-шина

Эти данные передаются последовательно. Вот пример.

Человек с лампой, передатчик, хочет отправить какую-то информацию человеку с телескопом, получателю (приемнику). Он хочет передать данные.

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

Это выглядит так:

Спустя 80 секунд:

Теперь 8 бит данных были переданы со скоростью 0,1 бит в секунду (т.е. 1 бит в 10 секунд). Это называется последовательной передачей данных.

Для использования этого подхода в автомобильном приложении интервал времени сокращается с 10 секунд до 0,000006 секунды. Для передачи информации посредством изменения уровня напряжения на шине данных.

Для измерения электрических сигналов шины КАН используется осциллограф. Две измерительных площадки на плате CANBASIC позволяют измерить этот сигнал.

Чтобы показать полное CAN-сообщение разрешение осциллографа уменьшается.

В результате одиночные CAN-биты больше не могут быть распознаны. Для решения этой проблемы CANBASIC-модуль оснащен цифровым запоминающим осциллографом.

Мы вставляем модуль CANBASIC в свободный разъем USB, после чего он будет автоматически обнаружен. Программное обеспечение CANBASIC можно запустить прямо сейчас.

Вы можете видеть вид программного осциллографа с прикрепленными значениями битов. Красным показаны данные, переданные в предыдущем примере.

Чтобы объяснить другие части CAN-сообщения мы раскрашиваем CAN-кадр и прикрепляем на него подписи с описанием.

Каждая раскрашенная часть CAN-сообщения соответствует полю ввода того же цвета. Область, отмеченная красным, содержит информацию о пользовательских данных, которая может быть задана в формате битов, полубайтов или шестнадцатиричном формате.

Желтая область определяет количество пользовательских данных. В зеленой зоне может быть установлен уникальный идентификатор.

Синяя область позволяет задать CAN-сообщение для удаленного запроса. Это означает, что будет ожидаться ответ от другого CAN-узла. (Разработчики системы сами рекомендуют не пользоваться удаленными запросами по ряду причин приводящих к глюкам системы, но об этом будет другая статья.)

Многие системы с шиной CAN защищены от помех вторым каналом CAN-LO для передачи данных, который является инвертированным относительно сигнала CAN-HI (т.е. идет тот же сигнал, только с обратным знаком).

Шесть последовательных битов с одинаковым уровнем определяют конец CAN-кадра.

Так совпало, что другие части CAN-кадра могут содержать более пяти последовательных битов с одинаковым уровнем.

Чтобы избежать этой битовой метки, если появляется пять последовательных битов с одинаковым уровнем, в конце CAN-кадра вставляется противоположный бит. Эти биты называют стафф-битами (мусорными битами). CAN-приемники (получатели сигнала) игнорируют эти биты.

С помощью полей ввода могут быть заданы все данные КАН-кадра и поэтому каждое КАН-сообщение может быть отправлено.

Вставленные данные немедленно обновляются в CAN-кадре, в данном примере длина данных будет изменена с одного байта на 8 байтов и сдвинута назад на один байт.

Текст описания показывает, что сигнал поворота будет управляться с помощью идентификатора «2С1» и бит данных 0 и 1. Все биты данных сбрасываются на 0.

Идентификатор установлен в значение «»2С1». Для активации сигнала поворотов бит данных должен быть установлен с 0 на 1.

В режиме «в салоне» вы можете управлять всем модулем с помощью простых щелчков мыши. Данные CAN устанавливаются автоматически в соответствии с желаемым действием.

Лампы поворотников могут быть установлены на ближний свет для работы в качестве ДХО. Яркостью будет управлять широтно-импульсная модуляция (ШИМ), в соответствии с возможностями современной диодной техники.

Теперь мы можем активировать фары ближнего света, противотуманные фары, стоп-сигналы и фары дальнего.

С отключением ближнего света противотуманные фары также отключаются. Логика управления световой системой CANBASIC соответствует автомобилям марки Volkswagen. Особенности зажигания и «возвращения домой» также включены.

С сигнальным узлом вы можете считывать сигнал датчика после инициирующего удаленного запроса.

В режиме удаленного запроса второй CAN-кадр будет принят и показан ниже отправленного CAN-кадра.

Байт данных CAN теперь содержит результат измерения датчика. С приближением к датчику пальца вы можете изменить измеренное значение.

Клавиша паузы замораживает текущий CAN-кадр и позволяет провести точный анализ.

Как уже было показано, различные части CAN-кадра могут быть скрыты.

Кроме того поддерживается скрытие каждого бита в КАН-кадре.

Это очень полезно, если вы хотите использовать представление CAN-кадра в ваших собственных документах, например в листе упражнений.

Появление цифровых шин в автомобилях произошло позднее, чем в них начали широко внедряться электронные блоки. В то время цифровой «выход» им был нужен только для «общения» с диагностическим оборудованием – для этого хватало низкоскоростных последовательных интерфейсов наподобие ISO 9141-2 (K-Line). Однако кажущееся усложнение бортовой электроники с переходом на CAN-архитектуру стало ее упрощением.

Действительно, зачем иметь отдельный датчик скорости, если блок АБС уже имеет информацию о скорости вращения каждого колеса? Достаточно передавать эту информацию на приборную панель и в блок управления двигателем. Для систем безопасности это ещё важнее: так, контроллер подушек безопасности уже становится способен самостоятельно заглушить мотор при столкновении, послав соответствующую команду на ЭБУ двигателя, и обесточить максимум бортовых цепей, передав команду на блок управления питанием.

Однако на старых принципах реализовать полноценное «общение» блоков управления было невозможно. На порядок выросли объем данных и их важность, то есть потребовалась шина, которая не только способна работать с высокой скоростью и защищена от помех, но и обеспечивает минимальные задержки при передаче.

Контроль ошибок [ править | править код ]

CAN имеет несколько механизмов контроля и предотвращения ошибок:

• Контроль передачи: при передаче битовые уровни в сети сравниваются с передаваемыми битами.
• Дополняющие биты (bit stuffing): после передачи пяти одинаковых битов подряд автоматически передаётся бит противоположного значения. Таким образом кодируются все поля кадров данных или запроса, кроме разграничителя контрольной суммы, промежутка подтверждения и EOF.
• Контрольная сумма: передатчик вычисляет её и добавляет в передаваемый кадр, приёмник считает контрольную сумму принимаемого кадра в реальном времени (одновременно с передатчиком), сравнивает с суммой в самом кадре и в случае совпадения передаёт доминантный бит в промежутке подтверждения.
• Контроль значений полей при приёме.

Разработчики оценивают вероятность невыявления ошибки передачи как 4,7×10 −11 .

Неисправности

Хотя интерфейс CAN и хорошо защищен от помех, электрические неисправности стали для него серьезной проблемой. Объединение блоков в единую сеть сделало ее уязвимой. КАН-интерфейс на автомобилях стал настоящим кошмаром малоквалифицированных автоэлектриков уже по одной своей особенности: сильные скачки напряжения (например, зимний запуск на сильно разряженном аккумуляторе) способны не только «повесить» ошибку CAN-шины, обнаруживаемую при диагностике, но и заполнить память контроллеров спорадическими ошибками, случайного характера.

В результате на приборной панели загорается целая «гирлянда» индикаторов. И, пока новичок в шоке будет чесать голову: «да что же это такое?», грамотный диагност первым делом поставит нормальный аккумулятор.

Чисто электрические проблемы – это обрывы проводов шины, их замыкания на «массу» или «плюс». Принцип дифференциальной передачи при обрыве любого из проводов или «неправильном» сигнале на нем становится нереализуем. Страшнее всего замыкание провода, поскольку оно «парализует» всю шину.

Представьте себе простую моторную шину в виде провода, на котором «сидят в ряд» несколько блоков – контроллер двигателя, контроллер АБС, приборная панель и диагностический разъем. Обрыв у разъема автомобилю не страшен – все блоки продолжат передавать информацию друг другу в штатном режиме, невозможной станет только диагностика.

А вот при обрыве между ЭБУ двигателя и АБС машина, скорее всего, уже не заведется: блок, не «видя» нужный ему контроллер (информация о скорости учитывается при расчете времени впрыска и угла опережения зажигания), уйдет в аварийный режим.

Если не резать провода, а просто постоянно подать на один из них «плюс» или «массу», автомобиль «уйдет в нокаут», поскольку ни один из блоков не сможет передавать данные другому. Поэтому золотое правило автоэлектрика в переводе на русский цензурный звучит как «не лезь кривыми руками в шину», а ряд автопроизводителей запрещает подключать к CAN-шине несертифицированные дополнительные устройства стороннего производства (например, сигнализации).

Благо подключение CAN-шины сигнализации не разъем в разъем, а врезаясь непосредственно в шину автомобиля, дают «криворукому» установщику возможность перепутать провода местами. Автомобиль после этого не то что откажется заводиться – при наличии контроллера управления бортовыми цепями, распределяющего питание, даже зажигание не факт что включится.

CAN (англ. Controller Area Network — сеть контроллеров) — стандарт промышленной сети, ориентированный, прежде всего, на объединение в единую сеть различных исполнительных устройств и датчиков. Режим передачи — последовательный, широковещательный, пакетный.

CAN разработан компанией Robert Bosch GmbH в середине 1980-х и в настоящее время широко распространён в промышленной автоматизации, технологиях «умного дома», автомобильной промышленности и многих других областях. Стандарт для автомобильной автоматики.

Общие сведения [ править | править код ]

CAN является синхронной шиной с типом доступа Collision Resolving (CR, разрешение коллизии), который, в отличие от Collision Detect (CD, обнаружение коллизии) сетей (Ethernet), детерминировано (приоритетно) обеспечивает доступ на передачу сообщения, что особо ценно для промышленных сетей управления (fieldbus).

Передача ведётся кадрами. Полезная информация в кадре состоит из идентификатора длиной 11 бит (стандартный формат) или 29 бит (расширенный формат, надмножество предыдущего) и поля данных длиной от 0 до 8 байт. Идентификатор говорит о содержимом пакета и служит для определения приоритета при попытке одновременной передачи несколькими сетевыми узлами.

Подслушиваем запросы с помощью диагностической системы vag-com (vcds)

Описание VCDS с официального сайта

Предельная длина сети [ править | править код ]

Приведённые выше методы контроля ошибок требуют, чтобы изменение бита при передаче успело распространиться по всей сети к моменту замера значения. Это ставит максимальную длину сети в обратную зависимость от скорости передачи: чем больше скорость, тем меньше длина. Например, для сети стандарта ISO 11898 предельные длины составляют приблизительно:

Использование оптопар для защиты устройств от высоковольтных помех в сети ещё больше сокращает предельную длину, тем больше чем больше задержка сигнала в оптопаре. Сильно разветвлённые сети (паутина) также снижают скорость из-за множества отражений сигнала и большей электрической ёмкости шины.

Приложение на телефон виртуальная панель приборов

Если есть желание поддержать проект, то вот ссылка на приложение, принимаю любые замечания и предложения!
VAG Virtual Cockpit

Применение can в автомобилестроении [ править | править код ]

Во всех высокотехнологичных системах современного автомобиля применяется CAN-протокол для связи ЭБУ с дополнительными устройствами и контроллерами исполнительных механизмов и различных систем безопасности. В некоторых автомобилях CAN связывает IMMO, приборные панели, SRS блоки и т. д.

Также протокол CAN ISO 15765-4 вошел в состав стандарта OBD-II.

Протоколы высокого уровня [ править | править код ]

Базовой спецификации CAN недостаёт многих возможностей, требуемых в реальных системах: передачи данных длиннее 8 байт, автоматического распределения идентификаторов между узлами, единообразного управления устройствами различных типов и производителей.

Расширенный формат кадра данных [ править | править код ]

Идентификатор получается объединением частей A и B.

Рецессивные и доминантные биты [ править | править код ]

Для абстрагирования от среды передачи спецификация CAN избегает описывать биты данных как «0» и «1». Вместо этого применяются термины «рецессивный» бит и «доминантный» бит, при этом подразумевается, что при передаче одним узлом сети рецессивного бита, а другим доминантного, принят будет доминантный бит.

Например, при реализации физического уровня на радиоканале отсутствие сигнала означает рецессивный бит, а наличие — доминантный; тогда как в типичной реализации проводной сети рецессив бывает при наличии сигнала, а доминант, соответственно, при отсутствии.

Стандарт сети требует от «физического уровня», фактически, единственного условия: чтобы доминантный бит мог подавить рецессивный, но не наоборот. Например, в оптическом волокне доминантному биту должен соответствовать «свет», а рецессивному — «темнота».

В электрическом проводе может быть так: рецессивное состояние — высокое напряжение на линии (от источника с большим внутренним сопротивлением), доминантное — низкое напряжение (доминантный узел сети «подтягивает» линию на землю). Если линия находится в рецессивном состоянии, перевести её в доминантное может любой узел сети (включив свет в оптоволокне или закоротив высокое напряжение). Наоборот — нельзя (включить темноту нельзя).

Софт панели приборов на python и kivy (ui framework)

Параллельно со сборкой самой панели приборов я вел разработку приложения для отображения информации с датчиков. В самом начале я не планировал какой либо дизайн.

Первая версия панели приборов

По мере разработки решил визуализировать данные более наглядно. Хотел гоночный дизайн, а получилось, что-то в стиле 80-х.

Вторая версия панели приборов

Продолжив поиски более современного дизайна я обратил внимание какие цифровые приборки делают автопроизводители и постарался сделать что-то похожее.

Третья версия панели приборов

Ранее, я никогда не разрабатывал графические приложения под Linux поэтому не знал с чего начать. Вариант на вебе простой в разработке, но слишком много лишних компонентов: иксы, браузер, nodejs, хотелось быстрой загрузки. Попробовав Qt PySide2 я понял, что это займет у меня много времени, т.к. мало опыта.

Kivy позволяет запускать приложение без Иксов, прямо из консоли, в качестве рендера используется OpenGL. Благодаря этому полная загрузка системы может происходить за 10 секунд.

import can
import os
import sys
from threading import Thread
import time

os.environ['KIVY_GL_BACKEND'] = 'gl'
os.environ['KIVY_WINDOW'] = 'egl_rpi'

from kivy.app import App
from kivy.properties import NumericProperty
from kivy.properties import BoundedNumericProperty
from kivy.properties import StringProperty
from kivy.uix.label import Label
from kivy.uix.image import Image
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.widget import Widget
from kivy.uix.scatter import Scatter
from kivy.animation import Animation

messageCommands = {
    'GET_DOORS_COMMAND': 0x220D,
    'GET_OIL_TEMPERATURE' : 0x202F,
    'GET_OUTDOOR_TEMPERATURE' : 0x220C,
    'GET_INDOOR_TEMPERATURE' : 0x2613,
    'GET_COOLANT_TEMPERATURE' : 0xF405,
    'GET_SPEED' : 0xF40D,
    'GET_RPM' : 0xF40C,
    'GET_KM_LEFT': 0x2294,
    'GET_FUEL_LEFT': 0x2206,
    'GET_TIME': 0x2216
}

bus = can.interface.Bus(channel='can0', bustype='socketcan')

# -*- coding: utf-8 -*-

import can
import os
import sys
from threading import Thread
import time

os.environ['KIVY_GL_BACKEND'] = 'gl'
os.environ['KIVY_WINDOW'] = 'egl_rpi'

from kivy.app import App
from kivy.properties import NumericProperty
from kivy.properties import BoundedNumericProperty
from kivy.properties import StringProperty
from kivy.uix.label import Label
from kivy.uix.image import Image
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.widget import Widget
from kivy.uix.scatter import Scatter
from kivy.animation import Animation

messageCommands = {
    'GET_DOORS_COMMAND': 0x220D,
    'GET_OIL_TEMPERATURE' : 0x202F,
    'GET_OUTDOOR_TEMPERATURE' : 0x220C,
    'GET_INDOOR_TEMPERATURE' : 0x2613,
    'GET_COOLANT_TEMPERATURE' : 0xF405,
    'GET_SPEED' : 0xF40D,
    'GET_RPM' : 0xF40C,
    'GET_KM_LEFT': 0x2294,
    'GET_FUEL_LEFT': 0x2206,
    'GET_TIME': 0x2216
}

bus = can.interface.Bus(channel='can0', bustype='socketcan')

class PropertyState:
    def __init__(self, last, current):
        self.last = last
        self.current = current

    def lastIsNotNow(self):
        return self.last is not self.current

class CanListener(can.Listener):
    def __init__(self, dashboard):
        self.dashboard = dashboard
        self.speedStates = PropertyState(None,None)
        self.rpmStates = PropertyState(None,None)
        self.kmLeftStates = PropertyState(None,None)
        self.coolantTemperatureStates = PropertyState(None,None)
        self.oilTempratureStates = PropertyState(None,None)
        self.timeStates = PropertyState(None,None)
        self.outDoorTemperatureStates = PropertyState(None,None)
        self.doorsStates = PropertyState(None,None)
        self.carMinimized = True

    def on_message_received(self, message):
	 messageCommand = message.data[3] | message.data[2] << 8

        if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_SPEED']:
            self.speedStates.current = message.data[4]
            if self.speedStates.lastIsNotNow():
                self.dashboard.speedometer.text = str(self.speedStates.current)
                self.speedStates.last = self.speedStates.current

        if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_RPM']:
            self.rpmStates.current = message.data[5] | message.data[4] << 8
            if self.rpmStates.lastIsNotNow():
                self.dashboard.rpm.value = self.rpmStates.current/4
                self.rpmStates.last = self.rpmStates.current
        if message.arbitration_id == 0x35B:
            self.rpmStates.current = message.data[2] | message.data[1] << 8
            if self.rpmStates.lastIsNotNow():
                self.dashboard.rpm.value = self.rpmStates.current/4
                self.rpmStates.last = self.rpmStates.current

        if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_KM_LEFT']:
            self.kmLeftStates.current = message.data[5] | message.data[4] << 8
            if self.kmLeftStates.lastIsNotNow():
                self.dashboard.kmLeftLabel.text = str(self.kmLeftStates.current)
                self.kmLeftStates.last = self.kmLeftStates.current

        if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_COOLANT_TEMPERATURE']:
            self.coolantTemperatureStates.current = message.data[4]
            if self.coolantTemperatureStates.lastIsNotNow():
                self.dashboard.coolantLabel.text = str(self.coolantTemperatureStates.current-81)
                self.coolantTemperatureStates.last = self.coolantTemperatureStates.current

        if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_OIL_TEMPERATURE']:
            self.oilTempratureStates.current = message.data[4]
            if self.oilTempratureStates.lastIsNotNow():
                self.dashboard.oilLabel.text = str(self.oilTempratureStates.current-58)
                self.oilTempratureStates.last = self.oilTempratureStates.current

        if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_TIME']:
            self.timeStates.current = message.data[5] | message.data[4] << 8
            if self.timeStates.lastIsNotNow():
                self.dashboard.clock.text = str(message.data[4])   ":"   str(message.data[5])
                self.timeStates.last = self.timeStates.current

        if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_OUTDOOR_TEMPERATURE']:
            self.outDoorTemperatureStates.current = float(message.data[4])
            if self.outDoorTemperatureStates.lastIsNotNow():
                self.dashboard.outDoorTemperatureLabel.text = str((self.outDoorTemperatureStates.current - 100)/2)
                self.outDoorTemperatureStates.last = self.outDoorTemperatureStates.current

        if message.arbitration_id == 0x77E and messageCommand == messageCommands['GET_DOORS_COMMAND']:
            self.doorsStates.current = message.data[4]
            if self.doorsStates.lastIsNotNow():
                self.doorsStates.last = self.doorsStates.current
                self.dashboard.car.doorsStates=message.data[4]

                # all doors closed -> minimize car
                if self.doorsStates.current == 0x55:
                    self.dashboard.minimizeCar()
                    self.carMinimized = True
                else:
                    if self.carMinimized:
                        self.dashboard.maximizeCar()
                        self.carMinimized = False
          
class Dashboard(FloatLayout):
    def __init__(self,**kwargs):
        super(Dashboard,self).__init__(**kwargs)

        # Background
        self.backgroundImage = Image(source='bg.png')
        self.add_widget(self.backgroundImage)

        # RPM
        self.rpm = Gauge(file_gauge = "gauge512.png", unit = 0.023, value=0, size_gauge=512, pos=(0,0))
        self.add_widget(self.rpm)
        self.rpm.value = -200

        # Speedometer
        self.speedometer = Label(text='0', font_size=80, font_name='hemi_head_bd_it.ttf', pos=(0,-15))
        self.add_widget(self.speedometer)

        # KM LEFT
        self.kmLeftLabel = Label(text='000', font_name='Avenir.ttc', halign="right", text_size=self.size, font_size=25, pos=(278,233))
        self.add_widget(self.kmLeftLabel)

        # COOLANT TEMPEARATURE
        self.coolantLabel = Label(text='00', font_name='hemi_head_bd_it.ttf', halign="right", text_size=self.size, font_size=27, pos=(295,-168))
        self.add_widget(self.coolantLabel)

        # OIL TEMPERATURE
        self.oilLabel = Label(text='00', font_name='hemi_head_bd_it.ttf', halign="right", text_size=self.size, font_size=27, pos=(-385,-168))
        self.add_widget(self.oilLabel)

        # CLOCK
        self.clock = Label(text='00:00', font_name='Avenir.ttc', font_size=27, pos=(-116,-202))
        self.add_widget(self.clock)

        # OUTDOOR TEMPERATURE
        self.outDoorTemperatureLabel = Label(text='00.0', font_name='Avenir.ttc', halign="right", text_size=self.size, font_size=27, pos=(76,-169))
        self.add_widget(self.outDoorTemperatureLabel)

        # CAR DOORS
        self.car = Car(pos=(257,84))
        self.add_widget(self.car)

    def minimizeCar(self, *args):
        print("min")
        anim = Animation(scale=0.5, opacity = 0, x = 400, y = 240, t='linear', duration=0.5)
        anim.start(self.car)

        animRpm = Animation(scale=1, opacity = 1, x = 80, y = -5, t='linear', duration=0.5)
        animRpm.start(self.rpm)

    def maximizeCar(self, *args):
        print("max")
        anim = Animation(scale=1, opacity = 1, x=257, y=84, t='linear', duration=0.5)
        anim.start(self.car)

        animRpm = Animation(scale=0.5, opacity = 0, x = 80, y = -5, t='linear', duration=0.5)
        animRpm.start(self.rpm)


class Car(Scatter):
    carImage = StringProperty("car362/car.png")

    driverDoorClosedImage = StringProperty("car362/driverClosedDoor.png")
    driverDoorOpenedImage = StringProperty("car362/driverOpenedDoor.png")

    passangerDoorClosedImage = StringProperty("car362/passangerClosedDoor.png")
    passangerDoorOpenedImage = StringProperty("car362/passangerOpenedDoor.png")

    leftDoorClosedImage = StringProperty("car362/leftClosedDoor.png")
    leftDoorOpenedImage = StringProperty("car362/leftOpenedDoor.png")

    rightDoorClosedImage = StringProperty("car362/rightClosedDoor.png")
    rightDoorOpenedImage = StringProperty("car362/rightOpenedDoor.png")

    doorsStates = NumericProperty(0)

    size = (286, 362)

    def __init__(self, **kwargs):
        super(Car, self).__init__(**kwargs)

        _car = Image(source=self.carImage, size=self.size)

        self.driverDoorOpened = Image(source=self.driverDoorOpenedImage, size=self.size)
        self.passangerDoorOpened = Image(source=self.passangerDoorOpenedImage, size=self.size)
        self.leftDoorOpened = Image(source=self.leftDoorOpenedImage, size=self.size)
        self.rightDoorOpened = Image(source=self.rightDoorOpenedImage, size=self.size)

        self.driverDoorClosed = Image(source=self.driverDoorClosedImage, size=self.size)
        self.passangerDoorClosed = Image(source=self.passangerDoorClosedImage, size=self.size)
        self.leftDoorClosed = Image(source=self.leftDoorClosedImage, size=self.size)
        self.rightDoorClosed = Image(source=self.rightDoorClosedImage, size=self.size)

        self.add_widget(_car)
        self.add_widget(self.driverDoorOpened)
        self.add_widget(self.passangerDoorOpened)
        self.add_widget(self.leftDoorOpened)
        self.add_widget(self.rightDoorOpened)

        self.bind(doorsStates=self._update)

    def _update(self, *args):
        driverDoorStates = self.doorsStates&1
        passangerDoorStates = self.doorsStates&4
        leftDoorStates = self.doorsStates&16
        rightDoorStates = self.doorsStates&64
        if driverDoorStates != 0:
            try:
                self.remove_widget(self.driverDoorOpened)
                self.add_widget(self.driverDoorClosed)
            except:
                pass
        else:
            try:
                self.remove_widget(self.driverDoorClosed)
                self.add_widget(self.driverDoorOpened)
            except:
                pass
        if passangerDoorStates != 0:
            try:
                self.remove_widget(self.passangerDoorOpened)
                self.add_widget(self.passangerDoorClosed)
            except:
                pass
        else:
            try:
                self.remove_widget(self.passangerDoorClosed)
                self.add_widget(self.passangerDoorOpened)
            except:
                pass
        if leftDoorStates != 0:
            try:
                self.remove_widget(self.leftDoorOpened)
                self.add_widget(self.leftDoorClosed)
            except:
                pass
        else:
            try:
                self.remove_widget(self.leftDoorClosed)
                self.add_widget(self.leftDoorOpened)
            except:
                pass
        if rightDoorStates != 0:
            try:
                self.remove_widget(self.rightDoorOpened)
                self.add_widget(self.rightDoorClosed)
            except:
                pass
        else:
            try:
                self.remove_widget(self.rightDoorClosed)
                self.add_widget(self.rightDoorOpened)
            except:
                pass

class Gauge(Scatter):
    unit = NumericProperty(1.125)
    zero = NumericProperty(116)
    value = NumericProperty(10) #BoundedNumericProperty(0, min=0, max=360, errorvalue=0)
    size_gauge = BoundedNumericProperty(512, min=128, max=512, errorvalue=128)
    size_text = NumericProperty(10)
    file_gauge = StringProperty("")

    def __init__(self, **kwargs):
        super(Gauge, self).__init__(**kwargs)

        self._gauge = Scatter(
            size=(self.size_gauge, self.size_gauge),
            do_rotation=False, 
            do_scale=False,
            do_translation=False
            )

        _img_gauge = Image(source=self.file_gauge, size=(self.size_gauge, self.size_gauge))

        self._needle = Scatter(
            size=(self.size_gauge, self.size_gauge),
            do_rotation=False,
            do_scale=False,
            do_translation=False
            )

        _img_needle = Image(source="arrow512.png", size=(self.size_gauge, self.size_gauge))


        self._gauge.add_widget(_img_gauge)
        self._needle.add_widget(_img_needle)

        self.add_widget(self._gauge)
        self.add_widget(self._needle)

        self.bind(pos=self._update)
        self.bind(size=self._update)
        self.bind(value=self._turn)

    def _update(self, *args):
        self._gauge.pos = self.pos
        self._needle.pos = (self.x, self.y)
        self._needle.center = self._gauge.center

    def _turn(self, *args):
        self._needle.center_x = self._gauge.center_x
        self._needle.center_y = self._gauge.center_y
        a = Animation(rotation=-self.value*self.unit   self.zero, t='in_out_quad',duration=0.05)
        a.start(self._needle)

class requestsLoop(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.daemon = True
        self.start()

    canCommands = [
        can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_DOORS_COMMAND'] >> 8, messageCommands['GET_DOORS_COMMAND'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
        can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_SPEED'] >> 8, messageCommands['GET_SPEED'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
        can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_KM_LEFT'] >> 8, messageCommands['GET_KM_LEFT'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
        can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_RPM'] >> 8, messageCommands['GET_RPM'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
        can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_OIL_TEMPERATURE'] >> 8, messageCommands['GET_OIL_TEMPERATURE'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
        can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_FUEL_LEFT'] >> 8, messageCommands['GET_FUEL_LEFT'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
        can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_OUTDOOR_TEMPERATURE'] >> 8, messageCommands['GET_OUTDOOR_TEMPERATURE'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
        can.Message(arbitration_id=0x746, data=[0x03, 0x22, messageCommands['GET_INDOOR_TEMPERATURE'] >> 8, messageCommands['GET_INDOOR_TEMPERATURE'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
        can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_COOLANT_TEMPERATURE'] >> 8, messageCommands['GET_COOLANT_TEMPERATURE'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False),
        can.Message(arbitration_id=0x714, data=[0x03, 0x22, messageCommands['GET_TIME'] >> 8, messageCommands['GET_TIME'] & 0xff, 0x55, 0x55, 0x55, 0x55], extended_id=False)
    ]

    def run(self):
        while True:
            for command in self.canCommands:
                bus.send(command)
                time.sleep(0.005)

class BoxApp(App):
    def build(self):
        dashboard = Dashboard();
        listener = CanListener(dashboard)
        can.Notifier(bus, [listener])

        return dashboard
        
if __name__ == "__main__":
    # Send requests
    requestsLoop()

    _old_excepthook = sys.excepthook
    def myexcepthook(exctype, value, traceback):
        if exctype == KeyboardInterrupt:
            print "Handler code goes here"
        else:
            _old_excepthook(exctype, value, traceback)
    sys.excepthook = myexcepthook

    # Show dashboard
    BoxApp().run()

Алгоритм работы следующий, используется 3 потока:

1. В главном потоке работаем с графическими элементы (спидометр, тахометр, часы, температуры и др) на экране
2. Во втором потоке каждые 5 мс делаем опрос следующего датчика
3. В третьем потоке слушаем CAN шину, получив ответ парсим его и обновляем соответствующий графический элемент

Работает стабильно, самый долгий процесс в разработке был связан с рисованием дизайна. На данный момент обкатываю решение и потихоньку пишу мобильное приложение для iOS, чтобы любой мог попробовать цифровую панель приборов.

Проект цифровой панель приборов открытый. Рад буду предложениям и комментариям!

Суть can-шины

Цифровая CAN-шина – это не конкретный физический протокол. Принцип работы CAN-шины, разработанный Bosch еще в восьмидесятых годах, позволяет реализовать ее с любым типом передачи – хоть по проводам, хоть по оптоволокну, хоть по радиоканалу. КАН-шина работает с аппаратной поддержкой приоритетов блоков и возможностью «более важному» перебивать передачу «менее важного».

Для этого введено понятие доминантного и рецессивного битов: упрощенно говоря, протокол CAN позволит любому блоку в нужный момент выйти на связь, остановив передачу данных от менее важных систем простой передачей доминантного бита во время наличия на шине рецессивного.

Представьте себе класс в начале урока. Ученики (контроллеры низкого приоритета) спокойно переговариваются между собой. Но, стоит учителю (контроллеру высокого приоритета) громко дать команду «Тишина в классе!», перекрывая шум в классе (доминантный бит подавил рецессивный), как передача данных между контроллерами-учениками прекращается. В отличие от школьного класса, в CAN-шине это правило работает на постоянной основе.

Для чего это нужно? Чтобы важные данные были переданы с минимумом задержек даже ценой того, что маловажные данные не будут переданы на шину (это отличает CAN шину от знакомого всем по компьютерам Ethernet). В случае аварии возможность ЭБУ впрыска получить информацию об этом от контроллера SRS несоизмеримо важнее, чем приборной панели получить очередной пакет данных о скорости движения.

В современных автомобилях уже стало нормой физическое разграничение низкого и высокого приоритетов. В них используются две и даже более физические шины низкой и высокой скорости – обычно это «моторная» CAN-шина и «кузовная», потоки данных между ними не пересекаются.

Например, техническая документация Volkswagen определяет три типа применяемых CAN-шин:

• «Быстрая» шина, работающая на скорости 500 килобит в секунду, объединяет блоки управления двигателем, ABS, SRS и трансмиссией.
• «Медленная» функционирует на скорости 100 кбит/с и объединяет блоки системы «Комфорт» (центральный замок, стеклоподъемники и так далее).
• Третья работает на той же скорости, но передает информацию только между навигацией, встроенным телефоном и так далее. На старых машинах (например, Golf IV) информационная шина и шина «комфорт» были объединены физически.

Интересный факт: на Renault Logan второго поколения и его «соплатформенниках» также физически две шины, но вторая соединяет исключительно мультимедийную систему с CAN-контроллером, на второй одновременно присутствуют и ЭБУ двигателя, и контроллер ABS, и подушки безопасности, и ЦЭКБС.

Физически же автомобили с CAN-шиной используют ее в виде витой дифференциальной пары: в ней оба провода служат для передачи единственного сигнала, который определяется как разница напряжений на обоих проводах. Это нужно для простой и надежной помехозащиты.

Но в витой паре на обоих проводах значение ЭДС помехи будет одинаковым, так что разница напряжений останется неизменной. Поэтому, чтобы найти CAN-шину в автомобиле, ищите витую пару проводов – главное не перепутать ее с проводкой датчиков ABS, которые так же для защиты от помех прокладываются внутри машины витой парой.

Диагностический разъем CAN-шины не стали придумывать заново: провода вывели на свободные пины уже стандартизированной в OBD-II колодки, в ней CAN-шина находится на контактах 6 (CAN-H) и 14 (CAN-L).

Поскольку CAN-шин на автомобиле может быть несколько, часто практикуется использование на каждой разных физических уровней сигналов. Вновь для примера обратимся к документации Volkswagen. Так выглядит передача данных в моторной шине:

Когда на шине не передаются данные или передается рецессивный бит, на обоих проводах витой пары вольтметр покажет по 2,5 В относительно «массы» (разница сигналов равна нулю). В момент передачи доминантного бита на проводе CAN-High напряжение поднимается до 3,5 В, в то время как на CAN-Low опускается до полутора. Разница в 2 вольта и означает «единицу».

На шине «Комфорт» все выглядит иначе:

Здесь «ноль» — это, наоборот, 5 вольт разницы, причем напряжение на проводе Low выше, чем на проводе High. «Единица» же – это изменение разности напряжений до 2,2 В.

Проверка CAN-шины на физическом уровне ведется с помощью осциллографа, позволяющего увидеть реальное прохождение сигналов по витой паре: обычным тестером, естественно, «разглядеть» чередование импульсов такой длины невозможно.

«Расшифровка» CAN-шины автомобиля также ведется специализированным прибором – анализатором. Он позволяет выводить пакеты данных с шины в том виде, как они передаются.

Сами понимаете, что диагностика шины CAN на «любительском» уровне без соответствующего оборудования и знаний не имеет смысла, да и банально невозможна. Максимум, что можно сделать «подручными» средствами, чтобы проверить кан-шину – это измерить напряжения и сопротивление на проводах, сравнив их с эталонными для конкретного автомобиля и конкретной шины.

Установка сигнализации skoda rapid мкпп, точки подключения шкода рапид мкпп- старлайн

Формат кадра удаленного запроса [ править | править код ]

Совпадает с кадрами данных стандартного или расширенного формата, за двумя исключениями:

• В поле RTR рецессив вместо доминанты.
• Отсутствует поле данных.