Autor Wątek: Kontrolery Arduino  (Przeczytany 53424 razy)

0 użytkowników i 1 Gość przegląda ten wątek.

Odp: Kontrolery Arduino
« Odpowiedź #150 dnia: Sierpnia 07, 2016, 18:33:39 »
Hehe, czyli we dwóch czekamy na soft gotowy :) Ja oprócz czekania próbuję dobrze osadzić czujnik w pedałach, ale dobrać odpowiednio magnes(y) i odległości :P masakra

Odp: Kontrolery Arduino
« Odpowiedź #151 dnia: Sierpnia 07, 2016, 20:26:00 »
Mógłbyś dokładniej opisać te problemy?
Zakładam, że celem jest uzyskanie takiego przełożenia kąta obrotu na napięcie, żeby pokryć pełny zakres wejścia przetwornika i do tego pracować w liniowym regionie charakterystyki czujnika.
Jeśli problem jest w tym, że pełne wychylenie drąga w obie strony nie powoduje, że na wyjściu czujnika pojawi się 0-5V, to możemy na to coś zaradzić elektronicznie, do tego analogowo, żeby nie tracić rodzielczości przetwornika.

Po tych paru, myślę, że udanych eksperymentach z cyfrowym filtrowaniem zacząłem się zastanawiać, czy 16bit będzie naprawdę niezbędne.
W tej chwili wejście jest 10 bitowe, ta wartość  jest przesuwana (mnożona) 6 bitów w lewo, tak aby otrzymać zmienną 16 bitową. Mimo to, wartość ciągle jest skwantowana jest 1024 poziomy. Ale - te schodki wpuszczamy na filtr cyfrowy operujący na 16 bitach. Schodki są wygładzane. Ciągle mamy 1024 dostępne poziomy, ale zmiany zachodzą łagodnie.
Może okaże się, że 12bitowy zewnętrzny przetwornik + porządne czyste zasilanie + kilka matematycznych operacji w rezultacie da całkiem niezłe rezultaty. 
Postaram się udostępnić prosty skrypt to czytania 4 osi (X,Y,Z,Zrot). Narazie z użyciem wewnętrznego ADC 32U4.

Odp: Kontrolery Arduino
« Odpowiedź #152 dnia: Sierpnia 07, 2016, 21:08:39 »
Ta pogoń za bitami też mnie zastanawia. Jest to oczywiście szeroko dyskutowane na forach. A zastanawia mnie, bo przecież do gry/symulatora i tak wszystko idzie przez directX? Czy gry faktycznie wykorzystują faktycznie te 16 bitów?

Odp: Kontrolery Arduino
« Odpowiedź #153 dnia: Sierpnia 07, 2016, 21:23:41 »
Na tyle, na ile się orientuję, to w deskryptorze HID podajemy zakres wartości dla analogowych osi. Możemy tam podać dowolny zakres, ograniczony pewnie do potęg 2. DirectX po odebraniu danej i tak rzutuje i przesuwa zmienną na 16bitowy int. Chyba tak to działa. VKB_JoyTester pokazuje wszystkie osie jako 0-65535 i obok wartość Step, która wskazuje jaka jest rodzielczość sygnału źródłowego. Raczej możemy założyć, że gry/simy dostają wartości 16 bitowe.

Odp: Kontrolery Arduino
« Odpowiedź #154 dnia: Sierpnia 07, 2016, 21:34:43 »
Cytuj
Ta pogoń za bitami też mnie zastanawia
Z tego co pamiętam z mojej dawnej pracy z kanałami stereo dla przesyłania muzyki przez sieć to rezygnowaliśmy z 2 ostatnich bitów przetwornika liniowego po to aby zyskać na przesyłanym cyfrowym paśmie. Stosowaliśmy tak jak wspomniałem kompresję dla małych sygnałów oraz tzw. przeplot, ale to było inne zagadnienie. Może także w naszym przypadku nie potrzeba tak dokładnych przetworników.

Odp: Kontrolery Arduino
« Odpowiedź #155 dnia: Sierpnia 08, 2016, 11:31:50 »
Analogowy przedwzmacniacz dla halotronów i innych źródeł sygnału, gdzie ważne jest centrowanie i identyczny zakres działania w górę i w dół trochę się rozrósł:



Jeden kanał wymaga jednego poczwórnego wzmacniacza operacyjnego, ale za to:
  • Posiada zabezpieczenia i filtry pierwotnej wersji.
  • Pozwala na ustawienie wzmocnienia osobno dla górnej i dolnej połówki. Potencjometry w moim ST290 posiadają niejednakowy zakres dla dodatnich i ujemnych wychyleń. Podejrzewam, że w przypadku halotronów też tak będzie. Przy pomocy trymerków (docelowo precyzyjne wieloobrotowe) można sobie dokładnie poustawiać zakresy tak, aby pokrywały pełne 0-VREF przetwornika i zapewniały maksymalne wykorzystanie rozdzielczości.
  • 3 potencjometr, niewidoczny na fotce, służył będzie do dokładnego ustawienia punktu zerowego.
W przypadku użycia halotronów, użyłbym magnesów takich, żeby wyjście dawało Pi*oko +/- 1/3 zakresu. Przetwornik będzie pracował na w miarę ładnym liniowym zakresie. Potem, przy pomocy powyższego układu, będzie można porozciągać górną i dolną połówkę tak, aby osiągały 0V i 5V, czy inne max napięcie przetwornika. No i oczywiście wycentrować dokładnie zero. To chyba załatwi sprawę z dobieraniem magnesów i odłegłości. Co ważniejsze, w domenie analogowej, bez utraty bitów.

Raczej nie ma sensu robić aż takich skomplikowanych operacji dla wszystkich osi. Myślę, że dodatkowa analogowa płytka z takimi układami dla 4 osi byłaby dobrym rozwiązaniem.

Czytałem właśnie, że ludzie chwalą

Odp: Kontrolery Arduino
« Odpowiedź #156 dnia: Sierpnia 08, 2016, 11:49:00 »
Hmm biorąc pod uwagę koszta dodatkowej płytki oraz elementów do niej, nie wiem, czy nie pokryły by się z kosztami ADS1115 - 16bitowy ADC - tak tylko mówię :) Dziś testuję ustawienie dwóch magnesów na łożysku tocznym 8x22x7 bo akurat zostało mi z projektu jedno.

Chodzi mniej więcej o takie umieszczenie, aby ruch osi zmieniał dokładnie pole magnetyczne - wtedy czujnik bipolarny jaki akurat mam zczyta te wartości imho całkiem precyzyjnie :)

Odp: Kontrolery Arduino
« Odpowiedź #157 dnia: Sierpnia 08, 2016, 12:02:05 »
... TLE 5010. Ma 16 bit, ale pytanie jest, czy przy zakresie wychylenia ok. 40% to 16 bit będzie w pełni wykorzystane? Dotyczy to też innych przetworników 16 bit wrzucanych na prosto na wyjście czujnika bez dodatkowego dopasowania sygnału.

Cały czas chodzi o mi to, czy da się łatwo i precyzyjnie ustawić magnesy i ich odległości od czujnika, żeby wychylenie drążka dawało na wyjściu np 0-5VDC. Jak to wygląda w praktyce?

Odp: Kontrolery Arduino
« Odpowiedź #158 dnia: Sierpnia 08, 2016, 13:49:59 »
Golas możesz przedstawić swoje rozwiązanie. Mam na myśli jak wygląda fizyczny model do testów i jakie są potrzebne elementy elektryczne. Coraz bardziej myślę o modzie dla mojej przepustnicy, może to jest ten moment. Mogę także włączyć się do testów, ale muszę zrobić jakiś model.

Odp: Kontrolery Arduino
« Odpowiedź #159 dnia: Sierpnia 08, 2016, 18:13:51 »
Zaprojektowałem płytkę jako mały moduł dla jednej osi. Może być wpięty pomiędzy potencjometr albo czujnik, a wejście ADC.
Zamówiłem kilka szt. w OSHPark. Przyjdą za parę tygodni i przetestuję układ. A wygląda to tak:



Ze względu na rozmiar zdecydowałem się na małe trymerki SMD. Powinny byc ok, zwłaszcza jeśli po wytrymowaniu moduł zabezpieczy sie np. rurką termokurczliwą.
Wejście PWR umożliwia zasilenie układu napięciem większym niż zakres ADC (czasem może się przydać). Można to ominąć przez zlutowanie zworki JP1.

Tak abstrahując od projektu joysticka, ten moduł mógłby znaleźć zastosowanie w naprawie innych joystików. Potencjometry w nich używane często są jakimiś specjalnymi seriami o mniejszym kącie działania (ST290 ma 45 stopniowe). Stosując ten moduł można użyć zwykłych, lub lepszej klasy standardowych potków o zakresie 300°. Będą działać tylko na krótkim odcinku, który możemy porozciągać do pełnego zakresu.

Odp: Kontrolery Arduino
« Odpowiedź #160 dnia: Sierpnia 08, 2016, 18:44:41 »
Zapraszam do przetestowania osi z filtrowaniem i zmienioną ch-ką., umownie będę ją nazywał "log".
Potrzebna będzie biblioteka AnalogScanner.
Podłączenia:
  • X = A0, log
  • Y = A1, log
  • Z = A2, lin
  • Zrot = A3, log

Program czyta też przyciski z jednego MCP23017. UART wyłączyłem. Na tym etapie właściwie nie jest już potrzebny. Do tego, wysyłanie całego pakietu danych zajmowało trochę czasu na czym cierpiała częstotliwość odświeżania parametrów joysticka.

Kod:
/*
  MegaJoystick library test
  for ATMEGA32U4 based Arduino boards
 
  copyright (c) 2016, Piotr Zapart
 
  128 buttons
  6 16bit axis
  17 16bit sliders
  4 HATs
 
  Connections:
 
  UART (Serial1) use VT100 terminal emulator like PuTTy
  D0-2k2-AdapterTX
  D1-2k2-AdapterRX
 
  I2C:
  MCP23017 SCL - Arduino SCL -2k2-|
                                  |-Vcc (pull ups)
  MCP23017 SDA - Arduino SDA -2k2-|
 
  D7 (INT6) - MCP23017 INTA+INTB (set to open collector) 
 
  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


#include <arduino.h>
#include <MegaJoystick.h>
#include <Wire.h>
#include <BasicTerm.h>
#include <AnalogScanner.h>
//#include "resp.h"

#define FILTER_ARRAY_SIZE 6
#define ADC_BITS 10

//#define DEBUG_UART

const int MCP1_SLAVE_ADDR = 0x20;
const int MCP2_SLAVE_ADDR = 0x27;

const int k_Ravg_size = 7; //ADC running average size (2^n -1)
const uint16_t k_LPfltFeedforward=10;

bool btnUpdateRequest = true;

static volatile uint16_t adcRawData[8];
static volatile uint16_t adcFilteredData[8];

uint16_t temp16;


// Creates an instance of the analog pin scanner.
AnalogScanner scanner;

// The order in which we should scan the analog pins.
int scanOrder[] = {A0, A1, A2, A3, A4, A5};
const int SCAN_COUNT = sizeof(scanOrder) / sizeof(scanOrder[0]);

// ### deklaracje funkcji ###
void initMCP23017(uint8_t slaveAddr);      //deklaracja funkcji inicjalizujacej
uint16_t readMCP23017(int8_t slaveAddr);   //deklaracja funkcji odczytywania stanu portow
void sendUARTreport(void); //funkcja wysylajaca raport na terminal typu VT100 (np putty)
void updateJoyButtons(void); //
void drawUARTstartup(void);
void drawUARTbargraph(uint8_t column, uint8_t row, uint16_t value);
void ADCLowPassFilter(void);


BasicTerm term(&Serial1);

// -------------------------------------------------------------------------------------
// semi log taper

uint16_t applyResponse16(uint16_t data)
{
int32_t temp32;
uint16_t output;
uint32_t t32;

int16_t data_int =(data-0x7FFF);

if (data &_BV(15))
{
data = data - 0x7FFF;
t32 = ((uint32_t)data) * data;
output = (t32>>15) + 0x7FFF;
}
else
{
t32 = ((uint32_t)data) * data;
output = (data<<1) - (t32>>15); //2*data - (data^2)
}
return output;
}

// -------------------------------------------------------------------------------------
/*
ADC lowpass filter
*/
void ADCLowPassFilter(void)
{
   
static volatile uint32_t filt[FILTER_ARRAY_SIZE];

    uint16_t temp16;
    uint8_t i;

for (i = 0; i <FILTER_ARRAY_SIZE; i++)
{
adcRawData[i] = scanner.getValue(scanOrder[i]);

temp16 = adcRawData[i];

if ((temp16 >(filt[i] + k_LPfltFeedforward)) ||
((filt[i]>k_LPfltFeedforward)&&(temp16 < (filt[i] - k_LPfltFeedforward))))
{
filt[i] = temp16;
}
else
{
filt[i] *= k_Ravg_size;
filt[i] += temp16;
filt[i] /= (k_Ravg_size+1);
}
adcFilteredData[i] = filt[i];
}
}


// -------------------------------------------------------------------------------------
/*
Funkcja inicjalizujaca uklad MCP23017
wszystkie piny jako input + pullup
argument: adres I2C
BANK0 = 0 - wykorzystamy sekwencyjny zapis,
adres jest automatycznie inkrementowany
po kazdej operacji zapisu bajtu
*/
void initMCP23017(uint8_t slaveAddr)
{
// IODIRA -> IODIRB
Wire.beginTransmission(slaveAddr);
Wire.write(0x00);       //IODIRA
Wire.write(0xFF);       //portA = wejscia, adres skacze do 0x01=IODIRB
Wire.write(0xFF);       //0x01 IODIRB = wejscia
Wire.write(0xFF);   //0x02 IPOLA = odwrotna polaryzacja, przycisk wcisniety = 1
Wire.write(0xFF); //0x03 IPOLB = jw.
Wire.endTransmission();

// Pull-ups
Wire.beginTransmission(slaveAddr);
Wire.write(0x0C);       //GPPUA
Wire.write(0xFF);       //podciagnij wejscia A do VCC,nowy adres = 0x0D=GPPUB
Wire.write(0xFF);       //podciagnij wejscia B do VCC
Wire.endTransmission();

//INTA & INTB - aktywne i otwarty kolektor
Wire.beginTransmission(slaveAddr);
Wire.write(0x04); //GPINTENA
Wire.write(0xFF);
Wire.write(0xFF);
Wire.endTransmission();

Wire.beginTransmission(slaveAddr);
Wire.write(0x0A);        //IOCON, dla BANK = 0
Wire.write(_BV(2)|_BV(6));  //ODR = 1, MIRROR = 1
Wire.endTransmission();
 
}
 
// -------------------------------------------------------------------------------------
// Funkcja odczytujaca stany portow GPIOA i GPIOB
// stan zwracany jest w postaci 16bitowego slowa,
// gdzie jeden bit odpowiada jednemu przyciskowi

uint16_t readMCP23017(int8_t slaveAddr)
{
  uint8_t output[2];
  uint8_t index = 0;
 
  Wire.beginTransmission(slaveAddr);    //I2C Start, wyslij adress
  Wire.write(0x12);              //ustaw wewnetrzny adres na GPIOA
  Wire.endTransmission();          //I2C stop
  Wire.beginTransmission(slaveAddr);    //I2C Start, wyslij adres
  Wire.requestFrom(slaveAddr,2,false);   //grzecznie popros o 2 bajty
//po odczytaniu GPIOA wewnetrzny adres
//automatycznie zostanie zwiekszony o 1.
//czyli wyladuje na GPIOB
//"true" na koncu generuje I2C stop i zwalnia
//magistrale, Wire.endTrasmission nie jest potrzebny
  while (Wire.available()) 
  {
    output[index] = Wire.read();    //wpisz GPIOA i B do tablicy
    index++;
  }
  Wire.endTransmission();
  return uint16_t(output[0] | ((output[1])<<8));  //zgrupuj oba bajty w 16 bitowe slowo
}
// -------------------------------------------------------------------------------------
/*
128 buttons, 16 buttons pro MCP23017 = 8 banks
*/

//3 rodzaje odczytywania stanu  przyciskow
// pojedynczo, w 8 bitowym bloku i 16 bitowym bloku
// odkomentowac jedna z ponizszych linii
//#define BUTTON_SINGLE_READ
//#define BUTTON_8BIT_READ
#define BUTTON_16BIT_READ



void updateJoyButtons(void)
{

// czytanie stanu przyciskow pojedynczo
#ifdef BUTTON_SINGLE_READ

uint8_t i;
uint16_t btnBank[8];

btnBank[0] = readMCP23017(MCP1_SLAVE_ADDR);
//btnBank[1] = readMCP23017(MCP2_SLAVE_ADDR);
// ...
// btnBank[7] = readMCP23017(MCP8_SLAVE_ADDR);

Joystick.setAutoSend(false); //wylaczamy autosend, bedzie wyslany jeden raz na koncu

for (i=0; i<16; i++)
{
if (btnBank[0] & (1<<i)) Joystick.setButton(i,1);
else Joystick.setButton(i,0);
if (btnBank[1] & (1<<i)) Joystick.setButton(i+16,1);
else Joystick.setButton(i+16,0);
//...
// if (btnBank[2] & (1<<i)) Joystick.setButton(i+32,1);
// else Joystick.setButton(i+32,0);
// if (btnBank[3] & (1<<i)) Joystick.setButton(i+48,1);
// else Joystick.setButton(i+48,0);
// if (btnBank[4] & (1<<i)) Joystick.setButton(i+64,1);
// else Joystick.setButton(i+64,0);
// if (btnBank[5] & (1<<i)) Joystick.setButton(i+80,1);
// else Joystick.setButton(i+80,0);
// if (btnBank[6] & (1<<i)) Joystick.setButton(i+96,1);
// else Joystick.setButton(i+96,0);
// if (btnBank[7] & (1<<i)) Joystick.setButton(i+112,1);
// else Joystick.setButton(i+112,0);
}
//Joystick.sendState();
//Joystick.setAutoSend(true);
#endif

// 8 bitowy blok, dla przykladu jeden z portow pierwszego MCO23017
#ifdef BUTTON_8BIT_READ
Joystick.setButtonBank8(0,readMCP23017(MCP1_SLAVE_ADDR)); //zapisuje bank 0
Joystick.setButtonBank8(1,(readMCP23017(MCP1_SLAVE_ADDR))>>8); //zapisuje bank 1
//setButtonBank8(2,readMCP23017(MCP2_SLAVE_ADDR)); //zapisuje bank 2
//setButtonBank8(3,(readMCP23017(MCP2_SLAVE_ADDR))>>8); //zapisuje bank 3
#endif

// 16 bitowy blok
#ifdef BUTTON_16BIT_READ
Joystick.setButtonBank16(0,readMCP23017(MCP1_SLAVE_ADDR)); //zapisuje bank 0 i 1
//setButtonBank16(0,readMCP23017(MCP2_SLAVE_ADDR)); //zapisuje bank 2 i 3
#endif

}
// -------------------------------------------------------------------------------------
void drawUARTbargraph(uint8_t row, uint8_t column, uint16_t value)
{
char bar[17];
uint8_t i;
term.position(row,column);
for (i=0;i<16;i++)
{
if ((value>>12)>i) bar[i] = '#';
else bar[i] = ' ';
}
bar[16] = '\0';
term.print(bar);
}


// -------------------------------------------------------------------------------------
void  sendUARTreport(void)
{
uint8_t i,j;

//Buttons
//j = bank number
for (j=0;j<8;j++)
{
term.position(j+3,0);
for (i=0;i<16;i++)
{
if (Joystick.getButton((j<<4)+i)) //j*16+i=button No
{
term.set_color(BT_RED, BT_BLACK);
term.write('1');
}
else
{
term.set_color(BT_CYAN, BT_BLACK);
term.write('0');
}
term.write(' ');
}
term.print("\t");
}

term.set_color(BT_WHITE, BT_BLACK);

drawUARTbargraph(13,9, Joystick.getXAxis());
drawUARTbargraph(14,9, Joystick.getYAxis());
drawUARTbargraph(15,9, Joystick.getZAxis());
drawUARTbargraph(16,9, Joystick.getXAxisRotation());
drawUARTbargraph(17,9, Joystick.getYAxisRotation());
drawUARTbargraph(18,9, Joystick.getZAxisRotation());
drawUARTbargraph(19,9, Joystick.getSlider(0));
drawUARTbargraph(20,9, Joystick.getSlider(1));
term.position(21,9); term.print(Joystick.getHatSwitch(0));term.print(F("   "));
term.position(22,9); term.print(Joystick.getHatSwitch(1));term.print(F("   "));
term.position(23,9); term.print(Joystick.getHatSwitch(2));term.print(F("   "));
term.position(24,9); term.print(Joystick.getHatSwitch(3));term.print(F("   "));


}
// -------------------------------------------------------------------------------------
void drawUARTstartup(void)
{
// puTTY terminal
term.init();
    term.cls();
    term.show_cursor(false);
term.position(0,0);
term.set_attribute(BT_NORMAL);
    term.set_attribute(BT_BOLD);
    term.print(F("Arduino Joystick Monitor\t"));
term.set_attribute(BT_NORMAL);
term.position(1,0);
term.print(F("Button status:\t"));
term.position(2,0);
term.print(F("0 1 2 3 4 5 6 7 8 9 A B C D E F\t"));

term.position(12,0);
term.println(F("Axis:\t"));
term.println(F("X=\t"));
term.println(F("Y=\t"));
term.println(F("Z=\t"));
term.println(F("Xrot=\t"));
term.println(F("Yrot=\t"));
term.println(F("Zrot=\t"));
term.println(F("Slider0=\t"));
term.println(F("Slider1=\t"));
term.println(F("HAT0=\t"));
term.println(F("HAT1=\t"));
term.println(F("HAT2=\t"));
term.println(F("HAT3=\t"));

}
// -------------------------------------------------------------------------------------
// INT6 interrupt, ktos cos wcisnal
ISR(INT6_vect)
{
  btnUpdateRequest = true;
  EIMSK &= ~(1<<INT6); // wylacz przerwanie
}
// -------------------------------------------------------------------------------------

void setup()
{
// INT6
pinMode(7,INPUT_PULLUP);
digitalWrite(7,HIGH);
EICRB |= (1<<ISC61);//|(1<<ISC60); // wyzwalane zboczem opadajacym
EIMSK |= (1<<INT6); // uruchom przerwanie
 
//Piny uzyte go testowania HAT bez uzycia MCP23017
pinMode(6,INPUT_PULLUP);
pinMode(5,INPUT_PULLUP);
pinMode(4,INPUT_PULLUP);
pinMode(3,INPUT_PULLUP);
 
Serial1.begin(115200);
while (!Serial1);
Joystick.begin();
Wire.begin();

scanner.setScanOrder(SCAN_COUNT, scanOrder);
scanner.beginScanning();


#ifdef DEBUG_UART
drawUARTstartup();
#endif
initMCP23017(MCP1_SLAVE_ADDR);
//initMCP23017(MCP2_SLAVE_ADDR);

Joystick.setAutoSend(false);
}

void loop()
{
//odczytaj przyciski jesli sa nowe dane

if (btnUpdateRequest == true)
{
updateJoyButtons();
btnUpdateRequest = false;
EIMSK |= (1<<INT6); // ponownie uruchom przerwanie INT6
}

//analog inputs
ADCLowPassFilter();

//os X - log
temp16 = applyResponse16(adcFilteredData[0]<<6);
Joystick.setXAxis(temp16);

//os Y - log
temp16 = applyResponse16(adcFilteredData[1]<<6);
Joystick.setYAxis(temp16);

//os Z - lin
Joystick.setZAxis(adcFilteredData[2]<<6);

// os Zrot - log
temp16 = applyResponse16(adcFilteredData[3]<<6);
Joystick.setZAxisRotation(temp16);

// ##########  HATs ###########
// 5 sposobow uaktualniania stanu HATow
// odkomentowac jedna z ponizszych deklaracji
//#define HAT_TEST_DEGREE
//#define HAT_TEST_BUTTON_LIST
//#define HAT_TEST_8BIT
//#define HAT_TEST_16BIT
//#define HAT_TEST_ANALOG

#ifdef HAT_TEST_DEGREE
//### Metoda 1 ###
//Jako parametr wejsciowy funkcja przyjmuje numer HATa (0-3) i kat w stopniach, (zakres 0-360, -1 odpowiada OFF)
//przyklad czyta analoghowa wartosc wejscia A0, mapuje ja na zakres -1 ... 360 i ustawia HATy
//int16_t angle = analogRead(0);
angle = map(angle,0,1023,0,360);
if (angle < 5) angle = -1;

Joystick.setHatSwitchDg(0,angle);

#endif
#ifdef HAT_TEST_BUTTON_LIST
//### Metoda 2 ###
// funkcja przyjmuje numer HATa i nuery pinow czterech przyciskow w kolejnowsci gora, prawo, dol, lewo
// pamietac o odpowiednim ustawieniu wejsc! input+pullup
// niezbyt efektywna w metoda, uzywac jesli nie ma innej opcji
Joystick.setHatSwitch(0,6,5,4,3);
Joystick.setHatSwitch(1,6,5,4,3);
Joystick.setHatSwitch(2,6,5,4,3);
Joystick.setHatSwitch(3,6,5,4,3);
#endif
#ifdef HAT_TEST_8BIT
//### Metoda 3 ###
// sluzy do jednoczesnego odcyztania dwoch HATow podlaczonych do 8bitowego portu
// np polowa MCP23017.
// Zakladamy, ze 2 HATy podlaczone sa do jednego MCP23017 w sposob opisany ponizej:
//(Right, Down, Left, Up, Hat0 Hat1)
// 7   6   5   4   3   2   1   0
// R1  D1  L1  U1  R0  D0  L0  U0
Joystick.set2HatSwitch(0,readMCP23017(MCP1_SLAVE_ADDR)); //wpisane beda HAT0 i HAT1
Joystick.set2HatSwitch(2,readMCP23017(MCP1_SLAVE_ADDR)>>8); // HAT2 i HAT3
#endif
#ifdef HAT_TEST_16BIT
//### Metoda 4 ###
//Zakladamy, ze 4 HATy podlaczone sa do jednego MCP23017 w sposob opisany ponizej:
//(Right, Down, Left, Up, Hat0 Hat1,Hat2,Hat3)
//F   E   D   C   B   A   9   8   7   6   5   4   3   2   1   0
//R3  D3  L3  U3  R2  D2  L2  U2  R1  D1  L1  U1  R0  D0  L0  U0
Joystick.set4HatSwitch(readMCP23017(MCP1_SLAVE_ADDR));
#endif
#ifdef HAT_TEST_ANALOG
//### Metoda 5 ###
//analogowy mini joystick uzyty jako HAT switch. Wymagane dwa wejscia analogowe
//argumenty:
//numer HATa, analogowy pin osi X (lewo/prawo), analogowy pin osi Y (gora/dol), prog zadzialania 0-10
Joystick.setHatSwitchAnalog(0,0,1,8); //HAT0, A0=x, A1=y, prog = 8


#endif

Joystick.sendState();

#ifdef DEBUG_UART
sendUARTreport();
#endif
}



Odp: Kontrolery Arduino
« Odpowiedź #161 dnia: Sierpnia 08, 2016, 18:49:12 »
Otóż zaopatrzywszy się w długopisy BICa :) robię coś na kształt tego:


Mocowaniem wyfrezowane/wycięte będzie jutro - dzisiaj jest 'sklejone' z plasteliny :P

Ogólnie wytłumaczone mocowanie poprawne czujnika/magnesu jest dostępne tutaj: LINK

Odp: Kontrolery Arduino
« Odpowiedź #162 dnia: Sierpnia 08, 2016, 19:32:08 »
Zniknął już przycisk modyfikacji posta ;/ ew mod/admin może scalić posty?



'Z ręki' kręcone bez stałej osi na 10bitowym przetworniku atmegi bez żadnej filtracji w mmjoy'u - jutro będę opracowywał system montażu na pojedyncze osie.
Użyte magnesy to neodymy z dysków twardych 5x5x1,5mm oraz HONEYWELL SS495A1

Odp: Kontrolery Arduino
« Odpowiedź #163 dnia: Sierpnia 08, 2016, 20:30:26 »
Dzięki golas za informację. 3.14ter na czym ma polegać test. Mam 4 pots oraz jeden joystick i 2 MC23017. Mogę podłączyć pots do wejść A0-A3 i obserwować programem VBK JT zmieniając zakresy i obserwując charakterystyki. Czy chodzi o sprawdzenie działania programu. Pots są połączone bezpośrednio do Arduino bez filtrów.

Odp: Kontrolery Arduino
« Odpowiedź #164 dnia: Sierpnia 08, 2016, 21:32:07 »
Zastanawiam się, czy nie warto byłoby użyć takich magnesów :)
http://www.magnesy.eu/mp-10-x-6-x-4--n38---magnes-neodymowy-t-2301.html