Персонализиран Arduino за запазване на бутоните на волана CAN с нов автомобилен стерео: 9 стъпки (със снимки)

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:54

Реших да заменя оригиналния стереосистема за кола във моя Volvo V70 -02 с нов стерео, за да мога да се наслаждавам на неща като mp3, bluetooth и хендсфри.

Колата ми има някои контроли на волана за стерео уредбата, които бих искал все още да мога да използвам. Не очаквах това да е проблем, защото на пазара има няколко адаптера, които би трябвало да са съвместими с моята кола. Скоро обаче разбрах, че не са! (Изглежда, че адаптерите за V70 може да имат проблеми с автомобили -02 поради малко по -различен CAN протокол.)

И така, какво да правим тогава? Запазване на старото стерео? Да живеете живот с неработещи бутони? Разбира се, че не! Ако няма работещ адаптер на пазара, тогава ще трябва да изградим такъв!

Тази инструкция може да се приложи (с някои адаптации) към автомобили, където бутоните на волана комуникират по CAN шината.

Стъпка 1: Научете как да изпращате команди към стерео

Първото нещо, което трябва да направите, е да разберете какъв тип дистанционен вход очаква стереото. Обикновено производителите няма да ви кажат това и вероятно нямате достъп и до работещи дистанционни управления за обратно инженерство.

Дистанционното входно устройство за новия ми стерео (Kenwood) се състои от един проводник и не успях да намеря никаква информация за това как работи. Той обаче има и 3,5 мм жак за отдалечен вход. И аз не успях да разбера нищо по въпроса. Но има известна информация за 3,5 мм жак за други марки, която предполага, че различни команди се идентифицират чрез прилагане на специфично съпротивление между върха и втулката (и по избор между пръстена и втулката). Напр. https://forum.arduino.cc/index.php?topic=230068.0. Затова реших да опитам, снабден с макет, куп резистори и 3.5 мм щепсел, включен към стереото и свързан към платката. Отначало нищо не беше разпознато, но стереото има меню "режим на обучение" и там командите могат да бъдат успешно настроени, като се прилага различна съпротива. Успех!

По -късно обаче разбрах, че направих грешка тук: Не всички команди, които стереоторът научи, всъщност ще работят. Напр. 30 kOhm беше намерено в режим на обучение, но не работи по -късно и за някои от командите, които настроих, разликата в съпротивлението беше толкова малка, че по -късно се задейства грешна команда.

Затова препоръчвам да използвате макет с резистори и бутони за превключване за всички отдалечени команди, с които искате да се справите, и всъщност да тествате дали всички те ще работят.

Ако стереосистемата на вашия автомобил не може да приема вход по същия начин, ще трябва да разберете как работи, за да можете да адаптирате това решение. Ако изобщо не можете да разберете, значи имате проблем.

Стъпка 2: Разберете къде да се свържете с CAN шината

Трябва да намерите добро място за свързване към CAN шината. Тъй като заменяте старо стерео, което комуникира по МОЖЕ, трябва да можете да откриете това зад стереото. CAN шината се състои от двойка усукани проводници (CAN-L и CAN_H). Консултирайте се с електрическа схема на вашия автомобил, за да сте сигурни.

Стъпка 3: Обратно инженерство на CAN съобщения

Освен ако Google не може да ви каже какви CAN съобщения трябва да слушате, тогава ще трябва да се свържете с CAN шината и да извършите обратен инженеринг. Използвах Arduino Uno и CAN щит. (Всъщност не се нуждаете от CAN щита, както ще видите по -късно, вместо това можете да използвате някои евтини компоненти на макета.)

Консултирайте се с Google, за да разберете каква скорост на предаване трябва да използвате, когато се свързвате с колата си. (Обикновено ще откриете, че има високоскоростна и нискоскоростна CAN мрежа. Свързвате се с мрежа с ниска скорост.)

Също така ще трябва да програмирате Arduino за регистриране на всички CAN съобщения през серийния интерфейс, за да можете да ги запишете в лог файл на вашия компютър. Стандартната IDE на Arduino няма да записва данни в лог файл, но можете да използвате напр. Вместо замазка.

Преди да започнете да пишете вашата програма, трябва да инсталирате библиотеката CAN_BUS_Shield.

Ето някои псевдо код, които да ви помогнат да започнете с вашата програма:

настройвам()

{init сериална връзка init CAN библиотека} loop () {ако CAN съобщението е получено {прочетете CAN съобщение във формат на съобщението запис в дневника запис в сериен}}

Съвети:

Ще използвате екземпляр от клас MCP_CAN за достъп до функционалността на CAN библиотеката:

MCP_CAN m_can;

Init CAN:

while (m_can.begin ()! = CAN_OK)

{забавяне (1000); }

Проверете и прочетете CAN съобщения:

докато (m_can.checkReceive () == CAN_MSGAVAIL)

{// Вземете CAN идентификатор, дължина на съобщението и данни за съобщението m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Направете нещо с данните за съобщението тук}

Ако имате нужда от допълнителна помощ, можете да намерите връзка към моята програма в по -късна стъпка. Библиотеката CAN shield също включва пример. Или проверете инструкциите на mviljoen2, които включват подобна стъпка.

Първо ще ви е необходим референтен файл, който да ви помогне да филтрирате данните. Превключете запалването в радио режим и запишете всичко за няколко минути, без да докосвате никакви бутони.

След това за всеки от бутоните започнете да регистрирате, натиснете бутона и спрете регистрацията.

Когато приключите, трябва да филтрирате всичко, което е във вашия справочен дневник, от регистрите на бутоните си, за да намерите вашите кандидати. Разбрах, че има още много съобщения, така че направих още регистрационни файлове и след това изисквах „кандидатите за команда А да бъдат във всички файлове с бутони А и в нито един от референтните файлове“. Това ми остави само няколко възможности да опитам.

Регистрационните файлове ще съдържат много съобщения, така че ще трябва да напишете някаква програма за това или евентуално да използвате Excel. (Използвах програма с много трудно кодирани условия за моите нужди, така че се страхувам, че не мога да предложа програма, която можете да използвате.)

Предупредителна дума: Не можете да сте сигурни, че бутонът винаги ще произвежда идентично съобщение. Някои от битовете може да съдържат нарастващи броячи и т.н. (Можете обаче освен идентификатора на съобщението да е същият.)

Ако случайно имате Volvo V70 -02, това е, което търсите:

• Идентификатор на съобщението: 0x0400066Byte0: 0x00, 0x40, 0x80 или 0xc0 (не ми пука)
• Байт1: 0x00 (не ми пука)
• Байт2: 0x00 (не ми пука)
• Байт3: 0x00-0x07 (не ми пука)
• Байт4: 0x1f (не ми пука)
• Байт5: 0x40 (не ми пука)
• Байт6: 0x40 (не ми пука)
• Байт7: Идентификатор на бутона: 0x77 = увеличаване на звука, 0x7b = намаляване на звука, 0x7d = следваща песен, 0x7e = предишна песен.

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

Стъпка 4: Хардуерен прототип

Вашият хардуер трябва да може:

1. Идентифицирайте команди, получени на CAN шината
2. Изпращайте команди в друг формат на стерео

Ако имате достатъчно място, можете да използвате Arduino и CAN щит за първата част и да прикачите допълнителен хардуер за втората. Има обаче някои недостатъци:

• Цената на CAN щита
• Размер
• Захранването на Arduino няма да бъде щастливо, ако е свързано директно към вашите автомобили 12V (вероятно ще работи, но животът му вероятно ще бъде съкратен).

Затова вместо това използвах следното:

• Atmega 328, "мозъкът на Arduino". (Има някои варианти, вземете този, който е равен на този на Arduino Uno. Можете да го купите със или без зареждащ механизъм на Arduino.)
• 16 MHz кристал + кондензатори за тактов сигнал.
• MCP2551 МОЖЕ трансивер.
• MCP2515 CAN контролер.
• TSR1-2450, преобразува 6.5-36V в 5V. (Не се използва в прототипа, защото софтуерът няма да се интересува от захранването.)
• CD4066B превключвател, който ще се използва при изпращане на команди към стерео.
• Няколко резистора. (Стойностите могат да бъдат намерени в схемите на Eagle в по -късна стъпка.)

Добро нещо с тази конфигурация е, че тя е напълно съвместима с Arduino и библиотеката CAN shield.

Ако искате да боравите с повече от четири бутона, може да помислите да използвате нещо различно от CD4066B. CD4066B може да бъде описан като четири превключвателя в един, всеки управляван от един от Atmegas GPIO щифтовете. Към всеки превключвател има свързан резистор, който може да се използва за управление на съпротивлението, използвано като вход за стерео. Така че това може лесно да се използва за изпращане на четири различни команди. Ако се комбинират, могат да се получат допълнителни стойности на съпротивлението. Тук идва грешката, която споменах по -рано. Имам четири бутона, но планирах да приложа два от тях като продължително и кратко натискане, за да ми дадете шест различни команди. Но в крайна сметка разбрах, че не мога да намеря комбинация от резистори, която да ми даде шест работни комбинации. Вероятно би било възможно вместо това да се свърже аналогов изходен сигнал към стерео (3,5 мм връх). (Имайте предвид, че Atmega няма истински аналогови изводи, така че ще е необходим допълнителен хардуер.)

За целите на тестването също така направих прост симулатор "кола и стерео", за да се свържа с моя прототип. Това улеснява отстраняването на грешки и освен ако не ви е приятно да седнете в колата си и да програмирате, мога да ви препоръчам това.

Прототипът е илюстриран от дъното на изображението. За захранване, програмиране и серийно регистриране той е прикрепен към Arduino Uno, където чипът Atmega е премахнат.

Горният макет е автомобил + стерео симулатор, който ще се използва за първоначално тестване на прототипа.

Прототипът + симулаторът е предназначен да работи по следния начин:

• Натиснете един от бутоните за превключване на дъската на симулатора. (Това са бутоните на волана ви.)
• Когато програмата на симулатора открие натискане на бутон, тя ще изпраща съответното CAN съобщение на всеки 70 ms, докато бутонът е натиснат. (Тъй като регистрационните файлове, които взех по -рано, показват, че така работи в колата ми.) Той също така ще изпраща много "боклуци" CAN съобщения, за да симулира друг трафик в автобуса.
• CAN съобщенията се изпращат по CAN шината.
• CAN съобщенията се получават от прототипа.
• MCP2515 изхвърля всички несвързани съобщения въз основа на идентификатора на съобщението.
• Когато MCP2515 получи съобщение, което трябва да бъде обработено, това ще покаже, че има съобщение в ред.
• Atmega ще прочете съобщението и ще реши кой бутон да се счита за активен.
• Atmega също ще следи кога е получено последното съобщение, след определено време бутонът ще се счита за освободен. (Съобщенията CAN показват само, че бутонът е натиснат, а не че е натиснат или освободен.)
• Ако даден бутон се счита за активен, тогава един или повече превключватели в CD4066B ще бъдат активирани.
• Симулаторът (сега действа като ваш стерео) ще открие, че е приложено съпротивление между върха и ръкава. (Накрайникът е свързан към 3.3V и през резистор към аналогов входен щифт. Когато няма активна команда, този щифт ще прочете 3.3V, когато дадена команда е активна, стойността ще стане по -ниска и ще идентифицира командата.
• Докато командата е активна, съответният светодиод също ще бъде активиран. (Има шест светодиода, защото планирах да използвам различно дълго / кратко натискане за два от бутоните ми.)

За повече подробности относно прототипа хардуер, вижте схемите на Eagle в по -късна стъпка.

Допълнителни подробности за хардуера на дъската за симулатор:

• 16 MHz кристал
• 22 pF кондензатори
• LED резисторите трябва да бъдат избрани въз основа на свойствата на LED
• Резистор, свързан към A7 и 3.3V, изберете напр. 2kOhm (не критично).
• Резисторите, свързани към MCP2551 и MCP2515, са изтеглящи / издърпващи. Изберете напр. 10 kOhm.

(Или можете да използвате CAN щита за „CAN частта“на симулатора, ако предпочитате.)

Важно е да знаете как щифтовете Atmega са картографирани към щифтовете на Arduino, когато проектирате хардуера.

(Не свързвайте никакви светодиоди директно към CD 4066B, той може да се справи само с нисък ток. Опитах това, когато за първи път тествах изхода и чипът стана безполезен. Хубавото е, че бях купил няколко от тях само защото те са толкова евтини.)

Стъпка 5: Програмиране на предпазители

Може би сте забелязали в предишната стъпка, че прототипът няма отделни компоненти за генериране на тактовия сигнал към MCP2515. Това е така, защото вече има 16 MHz кристал, използван като часовник Atmega сигнал, който можем да използваме. Но не можем просто да го свържем директно към MCP2515 и по подразбиране няма сигнал за часовник на Atmega.

(Ако предпочитате, можете да пропуснете тази стъпка и вместо това да добавите допълнителен хардуер за часовник.)

Въпреки това можем да използваме нещо, наречено "програмиране на предпазители", за да активираме часовник изходен сигнал на един от GPIO щифтовете.

Първо ще трябва да намерите файл, наречен "board.txt", използван от вашата Arduino IDE. Ще трябва да копирате записа за Arduino Uno, да му дадете ново име и да промените стойността за low_fuses.

Новата ми дъска изглежда така:

################################################# #############Въз основа на Arduino Uno#Промени:#low_fuses променени от 0xff на 0xbf за активиране на 16 MHz часовник#изход на Atmega PB0/пин 14 = Arduino D8

clkuno.name = Часовник (Arduino Uno)

clkuno.upload.protocol = arduino clkuno.upload.maximum_size = 32256 clkuno.upload.speed = 115200 clkuno.bootloader.low_fuses = 0xbf clkuno.bootloader.high_fuses = 0xde clkuno.bootloader.extended.bootloader.file = optiboot_atmega328.hex clkuno.bootloader.unlock_bits = 0xff clkuno.bootloader.lock_bits = 0xcf clkuno.build.mcu = atmega328p clkuno.build.f_cpu = 16000000L clkuno.build.kuri = ardukino.build.kuri = ardo

##############################################################

Обърнете внимание, че часовникът се активира чрез задаване на контролния му бит на 0.

Когато създадете новата платка в конфигурационния файл на дъските, ще трябва да запишете нов зареждащ механизъм в Atmega. Има различни начини да направите това, използвах метода, описан в

След като направите това, не забравяйте да изберете вашия нов тип платка, а не Arduino Uno, когато качвате програма в Atmega.

Стъпка 6: Софтуерът

Време е да направите тъпия хардуер умен, като добавите малко софтуер.

Ето някои псевдо код за прототипа:

lastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 setup () {enable watchdog configure pins D4-D7 as output pins init CAN setup CAN filter} loop () {нулиране на watchdog if (CAN съобщение е получено) {за всяка команда на бутона {ако CAN съобщението принадлежи командата на бутона {lastReceivedTime = сега lastReceivedCmd = cmd}}} if now> lastReceivedTime + cmdTimeout {lastReceivedCmd = none} за всяка команда на бутона {if lastReceivedCmd е команда на бутона {set command pin output = on} else {set command pin output = off }}}

cmdTimeout решава колко време трябва да изчакаме, преди да обмислим последния освободен активен бутон. Тъй като командите за съобщения CAN на бутон се изпращат приблизително на всеки 70 ms, тя трябва да бъде по -голяма от тази с известно поле. Но ако е твърде голям, ще има изоставане. Така че 100 ms изглежда като добър кандидат.

Но какво е пазач? Това е полезна малка хардуерна функция, която може да ни спаси в случай на срив. Представете си, че имаме грешка, която причинява срив на програмата, докато командата за увеличаване на звука е активна. Тогава щяхме да завършим със стерео на максимална сила на звука! Но ако пазачът не бъде нулиран за конкретното време, той ще реши, че се е случило нещо неочаквано и просто ще извърши нулиране.

void setup ()

{// позволяват максимум 250 ms за цикъла wdt_enable (WDTO_250MS); // други init неща} void loop () {wdt_reset (); // правим неща}

МОЖЕ ли филтър? Е, можете да конфигурирате CAN контролера да изхвърля всички съобщения, които не съответстват на филтъра, така че софтуерът да не губи време за съобщения, които не ни интересуват.

беззнакова дълга маска = 0x1fffffff; // Включва всички 29 бита на заглавието в маската

без подпис дълъг filterId = 0x0400066; // Ние се интересуваме само от това CAN съобщение id m_can.init_Mask (0, CAN_EXTID, маска); // Маска 0 се прилага за филтър 0-1 m_can.init_Mask (1, CAN_EXTID, маска); // Маска 1 се прилага за филтър 2-5 m_can.init_Filt (0, CAN_EXTID, filterId); m_can.init_Filt (1, CAN_EXTID, filterId); m_can.init_Filt (2, CAN_EXTID, filterId); m_can.init_Filt (3, CAN_EXTID, filterId); m_can.init_Filt (4, CAN_EXTID, filterId); m_can.init_Filt (5, CAN_EXTID, filterId);

Проверете кода на библиотеката CAN и документацията на CAN контролера за повече подробности относно това как да настроите филтър + маска.

Можете също така да настроите CAN контролера да повишава прекъсване, когато се получи съобщение (което не е филтрирано). (Не е включено в горния пример, но има някакъв код за него в моята програма.) В този случай той наистина не добавя никаква стойност и може да е объркващо, ако не сте свикнали да програмирате.

В крайна сметка това беше прототипният софтуер. Но имаме нужда и от код за симулаторната дъска:

lastSentTime = 0

minDelayTime = 70 setup () {конфигуриране на щифтове A0-A5 като изходни щифтове конфигуриране на щифтове D4-D7 като входни щифтове с вътрешно издърпване. init CAN} loop () {send "junk" can msg set activeButton = none за всеки бутон {ако бутонът е натиснат {set activeButton = button}} ако activeButton! = няма {if now> lastSentTime + minDelayTime {командата за изпращане на бутон може да изпрати съобщение } задайте lastSentTime = сега} inval = прочетете щифт A7 за всеки (cmd) {if (min <inval <max) {led on} else {led off}} изчакайте 1 ms}

Това непрекъснато ще изпраща "нежелани" CAN съобщения приблизително на всеки ms и докато бутонът се натиска съответната команда на всеки 70 ms.

Може да се наложи да регистрирате входа на щифт A7, докато натискате различните бутони, за да откриете подходящи стойности за променливите min и max, принадлежащи на всеки бутон. (Или можете да го изчислите, но всъщност четенето на входа ще ви даде по -точни стойности.)

Трябва да сте малко внимателни, когато програмирате режимите на щифтове. Ако случайно сте задали пиновете, предназначени да използват вътрешни издърпвания като изходни пинове, тогава ще създадете потенциален пряк път, който ще повреди вашия Arduino, когато настроите изхода високо.

Ако искате да проверите моите програми, те могат да бъдат изтеглени тук:

• CAN програма за регистриране на съобщения
• Програма за дъската за симулатор
• Програма за прототип / финална дъска

Трябва да сте наясно, че тези програми всъщност не съвпадат с псевдо кода тук, те съдържат много "допълнителни" неща, които всъщност не са необходими и ако не сте запознати с обектно -ориентираното програмиране, може да е малко трудно да се прочете.

Стъпка 7: Крайният хардуер

Когато сте доволни от програмата си (не забравяйте да тествате прототипа в колата след последното тестване със симулаторната платка) е време да изградите истински хардуер.

Тук имате три възможности:

• Бързо и мръсно - запоявайте нещата заедно върху прототипна платка на печатна платка.
• Хардкор DIY - гравирайте собствената си печатна платка.
• Мързеливият начин - поръчайте професионална платка за запояване на компонентите.

Ако не бързате, мога да препоръчам последната опция. Ако имате нужда само от малка платка като тази, е много евтино да я поръчате от Китай. (И тогава вероятно ще получите около десет парчета, за да можете да си позволите някои грешки при запояване.)

За да поръчате печатни платки, ще трябва да изпратите вашия дизайн във формат Gerber. Има различни софтуери за това. Използвах Eagle, който мога да препоръчам. Можете да очаквате няколко часа, за да го научите, но след това работи добре. За малки дъски като този можете да го използвате безплатно.

Бъдете внимателни, когато правите дизайна. Не искате да чакате четири седмици за доставка само за да разберете, че сте направили нещо нередно.

(Ако имате добри умения за запояване, можете да проектирате повърхностно монтирани компоненти и да получите наистина малък адаптер. Не го направих.)

След това поръчайте на напр. https://www.seeedstudio.com/fusion_pcb.html. Следвайте инструкциите как да генерирате файловете Gerber от вашия дизайн. Можете също така да получите визуализация на резултата, за да сте сигурни, че е наред.

(В крайна сметка трябваше да избера други резистори за R4-R7, освен изброените на схемата. Вместо това използвах 2k, 4.7k, 6.8k и 14.7k.)

И помнете - не бъркайте номерирането на щифтовете Atmega с номерирането на пиновете на Arduino!

Препоръчвам ви да не запоявате чипа Atmega директно, а да използвате гнездо. След това можете лесно да го премахнете в случай, че трябва да го препрограмирате.

Стъпка 8: Монтиране на автомобил

Сега към най -забавната част - монтирайте го в колата си и започнете да го използвате! (След като сте направили / купили калъф за него.)

Ако вече сте тествали напълно прототипа в колата си, всичко трябва да работи перфектно.

(Както споменах по -рано, не го направих, затова трябваше да сменя някои резистори и да направя някои промени в програмата си.)

Също така помислете дали трябва да го монтирате зад стерео уредбата или някъде другаде. Намерих добро място над кутията за ръкавици, където мога да го достигна от вътрешността на жабката, без да разглобявам нищо. Това може да е полезно, ако реша да го надстроя по -късно.

Най -накрая бутоните ми отново работят! Как бих могъл да оцелея два месеца без тях?

Стъпка 9: Бъдещи подобрения

Както бе споменато, ако направя версия 2.0 на това, ще заменя 4066B с нещо друго (вероятно цифров потенциометър) за по -голяма гъвкавост.

Има и много други неща, които можете да направите. Напр. добавете Bluetooth модул и направете приложение за дистанционно управление за вашия телефон. Или gps модул, тогава когато сте близо до дома си, можете автоматично да увеличите силата на звука и да изпратите съобщението „прозорците надолу“МОЖЕ, за да могат всичките ви съседи да се насладят на вашата прекрасна музика.