Многи су ову играчку имали у детињству; управљали смо је помоћу два окретна дугмета. Већ тада је било могуће прикључити два истосмјерна мотора са зупчаницима и управљати њима помоћу тастера. А сада је за то постало могуће прилагођавање џојстика. Што је аутор Института урадио под надимком миллерман4487.
Али два идентична дела су морала да се одштампају - то су адаптери за спајање зупчаника на дршке Магиц Сцреен-а. Изгледа као било који од адаптера:
И тако се повезује са мењачем (можда ће ово требати мало загревање адаптера са феном):
СТЛ датотека.
На њему се налази само једна неразумљива компонента - Л293Д чип. Садржи два такозвана Х-мостова, од којих сваки може да преокрене мотор спојен на њега. Испод плоче приказано је који закључци
Прикључите који од пинова Вии Нунцхуцк конектора за џојстик. Скица испод може се преправити за рад са било којим другим типовима џојстика, у свом тренутном облику биће потребна.
#инцлуде
#иф (АРДУИНО & гт; = 100)
#инцлуде
#елсе
#инцлуде
// # дефинирај Вире.врите (к) Вире.сенд (к)
// # дефинирај Вире.реад () Вире.рецеиве ()
#ендиф
статички уинт8_т нунцхуцк_буф [6]; // низ за чување нунцхуцк података,
// Користи игле прикључка Ц (аналогни ин) као напајање и земљу за Нунцхуцк
статиц воид нунцхуцк_сетповерпинс () {
#дефине пврпин ПОРТЦ3
#дефине гндпин ПОРТЦ2
ДДРЦ | = _БВ (пврпин) | _БВ (гндпин);
ПОРТЦ & = ~ _БВ (гндпин);
ПОРТЦ | = _БВ (пврпин);
кашњење (100); // чекати да се ствари стабилишу
}
// иницијализира И2Ц систем, придружи се И2Ц магистрали,
// и реците нунцхуцк-у да разговарамо са њим
статиц воид нунцхуцк_инит () {
Вире.бегин (); // придружи се и2ц бусу као мастеру
Вире.бегинТрансмиссион (0к52); // пренос на уређај 0к52
#иф (АРДУИНО & гт; = 100)
Вире.врите ((уинт8_т) 0к40); // шаље меморијску адресу
Вире.врите ((уинт8_т) 0к00); // шаље послано нулу.
#елсе
Вире.сенд ((уинт8_т) 0к40); // шаље меморијску адресу
Вире.сенд ((уинт8_т) 0к00); // шаље послано нулу.
#ендиф
Вире.ендТрансмиссион (); // зауставити преношење
}
// Пошаљите нунцхуцк захтјев за подацима
// био је "сенд_зеро ()"
статиц воид нунцхуцк_сенд_рекуест () {
Вире.бегинТрансмиссион (0к52); // пренос на уређај 0к52
#иф (АРДУИНО & гт; = 100)
Вире.врите ((уинт8_т) 0к00); // шаље један бајт
#елсе
Вире.сенд ((уинт8_т) 0к00); // шаље један бајт
#ендиф
Вире.ендТрансмиссион (); // зауставити преношење
}
// Кодирајте податке да би се обликовали они који нису највећи управљачки програми осим
// потребан је само ако користите једног од редовних управљачких програма за виимоте
статиц цхар нунцхук_децоде_бите (цхар к) {
к = (к ^ 0к17) + 0к17;
ретурн к;
}
// примање података из нунцхуцка,
// враћа 1 успешно завршено читање. враћа 0 на неуспех
статиц инт нунцхуцк_гет_дата () {
инт цнт = 0;
Вире.рекуестФром (0к52, 6); // затражите податке из нунцхуцка
док (Вире.аваилабле ()) {
// примити бајт као цијели број
#иф (АРДУИНО & гт; = 100)
нунцхуцк_буф [цнт] = нунцхук_децоде_бите (Вире.реад ());
#елсе
нунцхуцк_буф [цнт] = нунцхук_децоде_бите (Вире.рецеиве ());
#ендиф
цнт ++;
}
нунцхуцк_сенд_рекуест (); // послати захтев за наредни терет података
// Ако смо добили 6 бајтова, идите их штампати
ако је (цнт & гт; = 5) {
повратак 1; // успех
}
ретурн 0; // неуспех
}
// Испишите улазне податке које смо добили
// подаци за аццеле су дугачки 10 бита
// тако да читамо 8 бита, а затим морамо да додамо
// на последња 2 бита. Зато и ја
// помножи их са 2 * 2
статиц воид нунцхуцк_принт_дата () {
статички инт и = 0;
инт јои_к_акис = нунцхуцк_буф [0];
инт јои_и_акис = нунцхуцк_буф [1];
инт аццел_к_акис = нунцхуцк_буф [2]; // * 2 * 2;
инт аццел_и_акис = нунцхуцк_буф [3]; // * 2 * 2;
инт аццел_з_акис = нунцхуцк_буф [4]; // * 2 * 2;
инт з_буттон = 0;
инт ц_буттон = 0;
// бајт нунцхуцк_буф [5] садржи битове за дугмад з и ц
// такође садржи најмање значајне битове за податке акцелерометра
// тако да морамо проверити сваки залогај бајта [5]
иф ((нунцхуцк_буф [5] & гт; 0) и 1)
з_буттон = 1;
иф ((нунцхуцк_буф [5] & гт; 1) и 1)
ц_буттон = 1;
иф ((нунцхуцк_буф [5] & гт; 2) и 1)
аццел_к_акис + = 1;
иф ((нунцхуцк_буф [5] & гт; 3) и 1)
аццел_к_акис + = 2;
иф ((нунцхуцк_буф [5] & гт; 4) и 1)
аццел_и_акис + = 1;
иф ((нунцхуцк_буф [5] & гт; 5) и 1)
аццел_и_акис + = 2;
иф ((нунцхуцк_буф [5] & гт; 6) и 1)
аццел_з_акис + = 1;
иф ((нунцхуцк_буф [5] & гт; 7) и 1)
аццел_з_акис + = 2;
Серијски.принт (и, ДЕЦ);
Сериал.принт ("\ т");
Сериал.принт ("радост:");
Серијски.принт (јои_к_акис, ДЕЦ);
Сериал.принт (",");
Серијски.принт (јои_и_акис, ДЕЦ);
Сериал.принт ("\ т");
Сериал.принт ("ацц:");
Серијски.принт (аццел_к_акис, ДЕЦ);
Сериал.принт (",");
Серијски.принт (аццел_и_акис, ДЕЦ);
Сериал.принт (",");
Серијски.принт (аццел_з_акис, ДЕЦ);
Сериал.принт ("\ т");
Сериал.принт ("али:");
Серијски.принт (з_буттон, ДЕЦ);
Сериал.принт (",");
Серијски.принт (ц_буттон, ДЕЦ);
Сериал.принт ("\ р \ н"); // нови ред
и ++;
}
// враћа стање збуттон: 1 = притиснуто, 0 = није притиснуто
статиц инт нунцхуцк_збуттон () {
ретурн ((нунцхуцк_буф [5] & гт; 0) и 1)? 0-1 // вуду
}
// враћа стање збуттон: 1 = притиснуто, 0 = није притиснуто
статиц инт нунцхуцк_цбуттон () {
ретурн ((нунцхуцк_буф [5] & гт; 1) и 1)? 0-1 // вуду
}
// враћа вредност џојстика оси к
статиц инт нунцхуцк_јоик () {
ретурн нунцхуцк_буф [0];
}
// враћа вредност џојстика оси и
статиц инт нунцхуцк_јоии () {
ретурн нунцхуцк_буф [1];
}
// враћа вредност к-оси акцелерометра
статиц инт нунцхуцк_аццелк () {
ретурн нунцхуцк_буф [2]; // ФИКСМЕ: ово изоставља 2-бита података
}
// враћа вредност и-оси акцелерометра
статиц инт нунцхуцк_аццели () {
ретурн нунцхуцк_буф [3]; // ФИКСМЕ: ово изоставља 2-бита података
}
// враћа вредност акцелерометра з оси з
статиц инт нунцхуцк_аццелз () {
ретурн нунцхуцк_буф [4]; // ФИКСМЕ: ово изоставља 2-бита података
}
инт лооп_цнт = 0;
бите јоик, јоии, збут, цбут, аццк, ацци, аццз;
воид _принт () {
Сериал.принт ("\ тКс Јои:");
Сериал.принт (мапа (јоик, 15, 221, 0, 255));
Сериал.принт ("\ тИ радост:");
Сериал.принтлн (мапа (јоии, 29, 229, 0, 255));
}
инт јоик1 = 129; // 15 - 221
инт јоии1 = 124; // 29 - 229
воид сетуп () {
Сериал.бегин (9600);
нунцхуцк_сетповерпинс ();
нунцхуцк_инит (); // пошаљите иницијацијско руковање
Сериал.принтлн ("Спреман за Вии Нунцхуцк");
пинМоде (3, ИЗЛАЗ);
пинМоде (5, ИЗЛАЗ);
пинМоде (6, ИЗЛАЗ);
пинМоде (9, ИЗЛАЗ);
// типе ();
}
воид лооп () {
ако (лооп_цнт & гт; 10) {// сваких 100 мсец добије нове податке
лооп_цнт = 0;
нунцхуцк_гет_дата ();
збут = нунцхуцк_збуттон ();
јоик = нунцхуцк_јоик (); // 15 - 221
јоии = нунцхуцк_јоии (); // 29 - 229
_принт ();
}
лооп_цнт ++;
иф (збут == 1) {
типе ();
збут = 0;
}
елсе {
иф (јоик & гт; (јоик1 + 20)) {
инт спеед1 = мапа (јоик - јоик1, 0, 80, 40, 255);
спеед1 = ограничење (спеед1, 0, 255);
аналогВрите (6, 0);
аналогВрите (9, брзина1);
}
елсе иф (јоик <лт; (јоик1 - 20)) {
инт спеед2 = мапа (јоик1 - јоик, 0, 90, 40, 255);
спеед2 = ограничење (спеед2, 0, 255);
аналогВрите (6, брзина2);
аналогВрите (9, 0);
}
елсе {
аналогВрите (6, 0);
аналогВрите (9, 0);
}
ако (јои & гт; (јоии1 + 20)) {
инт спеед3 = мапа (јоии - јоии1, 0, 80, 40, 255);
спеед3 = ограничење (спеед3, 0, 255);
аналогВрите (3, 0);
аналогВрите (5, брзина3);
}
елсе иф (јоии <лт; (јоии1 - 20)) {
инт спеед4 = мапа (јоии1 - јоии, 0, 90, 40, 255);
спеед4 = ограничење (спеед4, 0, 255);
аналогВрите (3, брзина 4);
аналогВрите (5, 0);
}
елсе {
аналогВрите (3, 0);
аналогВрите (5, 0);
}
}
кашњење (1);
}
воид типе () {
инт рлтиме = 200;
// дигиталВрите (6, 1); // извор
// дигиталВрите (9, 0);
// дигиталВрите (3, 1);
// дигиталВрите (5, 0);
// кашњење (1000);
// Х ===============
// дигиталВрите (3, 0); // причекајте
// дигиталВрите (5, 0);
// дигиталВрите (6, 0);
// дигиталВрите (9, 0);
// кашњење (250);
// дигиталВрите (3, 0); // горе
дигиталВрите (5, 1);
кашњење (500);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
дигиталВрите (3, 1); // доле
// дигиталВрите (5, 0);
кашњење (250);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
// дигиталВрите (6, 0); // десно
дигиталВрите (9, 1);
кашњење (рлтиме);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
// дигиталВрите (3, 0); // горе
дигиталВрите (5, 1);
кашњење (250);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
дигиталВрите (3, 1); // доле
// дигиталВрите (5, 0);
кашњење (500);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
// дигиталВрите (6, 0); // десно
дигиталВрите (9, 1);
кашњење (рлтиме);
// И ==========================
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
дигиталВрите (3, 0); // горе
дигиталВрите (5, 1);
кашњење (500);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
дигиталВрите (6, 0); // десно
дигиталВрите (9, 1);
кашњење (100);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
дигиталВрите (6, 1); // лево
дигиталВрите (9, 0);
кашњење (рлтиме);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
дигиталВрите (6, 0); // десно
дигиталВрите (9, 1);
кашњење (100);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
дигиталВрите (3, 1); // доле
дигиталВрите (5, 0);
кашњење (500);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
дигиталВрите (6, 0); // десно
дигиталВрите (9, 1);
кашњење (100);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
дигиталВрите (6, 1); // лево
дигиталВрите (9, 0);
кашњење (рлтиме);
дигиталВрите (3, 0); // причекајте
дигиталВрите (5, 0);
дигиталВрите (6, 0);
дигиталВрите (9, 0);
кашњење (250);
}
Након укључивања, правилно састављен уређај одмах почиње да ради. Нунцхуцк је аналогни џојстик, тако да можете да контролишете не само правац, већ и брзину кретања. Ардуино преузима контролу брзине ПВМ. Ако се кретање по било којој оси одвија у супротном смеру, одговарајући мотор мора бити обрнут. Ако поставите курсор приближно на средину екрана и притиснете тастер З, можете да направите уређај да аутоматски напише реч ХИ.
