Synteza SPHM DDS

[SP3SWJ]

.. Myślę ile trzeba kodu by zrobić proste operacje na plikach.

... Może przygotować hardware i oprogramować w kolejnych wersjach ?

zapis do pliku w BASCOM to jest bardzo proste
Print #1 , "SP9FKP"
i już we wcześniej otwartym pliku jest zapisany odpowiedni tekst.

i odpowiednio INPUT PUT GET APPEND :-) Oczywiście działa to analogicznie w C i odpowiednimi komendami - Bascom nie jest ty jakimś cudem techniki...

Nie chodzi o to by na siłę od razu używać katować obsługą - ale by projekt był sprzętowo przygotowany na przyszłość...

Wiem że sam programujesz i dla Ciebie pewne sprawy są proste - ale przeciętny "klonujący" TRX oczekuje naprawdę prostych instrukcji

- nagraj plik na kartę
- wyłącz TRX
- włóż karte do TRX
- naciśnij PTT i trzymaj ( dłużej niż 10 sekund )
- włącz zasilanie TRX
- puśc PTT jak TRX przywita cię napisami ....

jeśli powstaną ( a objawi sie dużo programistów) 2-3 alternatywne wersje softu... to będzie można sobie błyskawicznie zmienić soft do testów :-)

[SP9FKP]

Nie znam Bascoma ale jeśli obsługa błędów jest równie prosta to "szacun".

[SP5FCS]

Po kilku daniach testów uruchomiłem panel dotykowy w sterowniku syntezy TFT. Obsługa panela odbywa się poprzez przetwornik AD7843 dedykowany do paneli rezystancyjnych. Testy wykazały dużą nieliniowość siatki rezystancyjnej co będzie wymagało wykonania procedur kalibracji panela dotykowego.

   

Na ekranie aktywne są górne i dolne klawisze (po cztery) oraz klawisze menu z prawej strony (siedem klawiszy). Próby z mniejszymi klawiszami dały słabe efekty z powodu małej powtarzalności oraz trudnością trafienia w pole klawisza. Kolejny etap to oprogramowanie funkcji poszczególnych klawiszy zgodne z ich opisami.

[SP3SWJ]

Jak kiedys robiłem testy z tym touchpanelem ale obsługiwanym przez cztery nogi procka ATmega (2xADC i 2xIO) to napisałem program testowy - nazwałem go roboczo PAINT ;-)

na ekranie były dwa pola tekstowe pokazujące wartość ADC (0...1024) odpowiedniodla X Y i dla pola pokazujące pozycje przeliczonego poksela XY

Program rysował KROPKĘ w miejscu dotknięcia robił to w szybkiej pętli - w efekcie kropka się "sprajowała" na kranie i pozwoliło to na obserwowanie rozrzutu odczytu. Spostrzeżenia były następujące:
- pierwsze pomiary należy odrzucić
- jeśli dotknięcie zbyt krótkie nie analizować położenia
- jeśli dotknięcie dłuższe (kilka szybkich odczytów )..to wtedy zaczynami kilka klejnych wolniejszych odczytów i je uśredniamy. wyrysowanie jednego poksela to kilkanaście ms....


   

No ale moje uwagi dotyczą w pełni programowej obsługi touchskrina... Bazowałem na tych materiałach z noty aplikacyjnej BASCOM - ale znacznie to zmodyfikowałem.

Jak się dobiorę to tego dedykowanego scalaka co Adam już okiełznał to może wniosę swoje 5 groszy w tym temacie...

[SP3SWJ]

================= EDIT
Testowałem kod (wersja testowo-serwisowa od Adama) do obsługi scalaka do odczytu AD7843 i problemy ze "sprajowaniem" kropki są takie same ;-)

   

Także pozostaje programowe filtrowanie i bronienie się przed szumem - podobnie jak to opisałem wcześniej. Zaleta tego dedykowanego scalaka jest dużo większa szybkość i tym samym możliwość wyliczenia kropki z większą dokładnością (oczywiście także przerwanie od dotknięcia ) .... cdn...

---

Nie znam Bascoma ale jeśli obsługa błędów jest równie prosta to "szacun".

Myślałem że uważniej czytasz posty poprzednika zanim coś napiszesz - i zajrzysz na podane linki - a wtedy ewentualnie skorygujesz stosownie swoja wypowiedź..., zajrzyj więc proszę na linka co wcześniej podałem o BASCOM AVR DOS ... jest tam sekcja Error Codes: w której jest wylistowane prawie 30 mozliwych błędów jakie może ci zwrócić obsługa plików w BASCOM - czy to Ciebie zadowala :-) ??

[SP5FCS]

Niestety ten model wyświetlacza TFT ma matrycę rezystancyjną, która działa mniej pewnie od matryc pojemnościowych. W matrycy rezystancyjnej jeśli "dotyk" panela nie jest dość silny występują przekłamania. Najlepiej działa dotykanie typowym rysikiem z telefonów.

Zaletą dedykowanego układu AD7843 jest oszczędność czasu oraz pinów procesora, możliwość obsługi w przerwaniach, dwa dodatkowe kanały analogowe do pomiarów oraz najważniejsze to tranzystorowe klucze do polaryzacji matrycy względem zasilania i masy.

   

Dodatkowo układ posiada tryb pozwalający pobierać do pomiaru poziomy napięć referencyjnych bezpośrednio z wyjść matrycy. Uniezależnia to obsługę panela dotykowego od ustawień przetworników ADC w procesorze. Układ posiada 12 bitowy przetwornik ADC co ma znaczenie przy starszych procesorach.

[SP5FCS]

Kolejnym poważnym wyzwaniem w pracach nad sterownikiem jest kalibracja panela dotykowego. Proces kalibracji obejmuje dwa zagadnienia.

1. Dane pomiarowe z przetwornika Ad8743 trzeba przekonwertować na współrzędne ekranu co nie stanowi większego problemu. Wystarczy dokonać pomiaru ADC dla 3 punktów kalibracyjnych i przeliczyć je na rozdzielczość wyświetlacza.

2. Zdecydowanie gorzej jest z korektą geometrii matrycy rezystancyjnej. Matryca w moim wyświetlaczu jest mocno nieliniowa w górnej części wyświetlacza, najgorzej w górnym prawym rogu. Proste przeliczenie w siatce prostokątnej nie daje zadowalających wyników dlatego konieczne jest korygowanie geometrii odczytów z panela.

Dla zapoznania ze stopniem trudności oraz metodyką polecam lekturę np.:

How To Calibrate Touch Screens

Na dobry początek imlementacja Carlosa E. Vidales.

[SP3SWJ]

jak robiłem testy to "zawijanie" i zniekształcanie ekranu objawiało się jak były za duże kondensatory na liniach "touch" obecnie dałem 68pF ( miały byc 100pF)

Jak widać na filmie wystarczy proste
y=y_factor*y_adc+y_ofs
v=x_factor*x_adc+x_ofs

i jest OK




bo z 10 nF to była pomyłka...- nawet nie ma sensu pokazywac obrazków... podobnie robiłem próby z bardzo szybkim czytaniem po SPI - też robiły sie "banany" na wykresie - zamiast prostokąta...

(...testy na kodzie C by sp5fcs)

---

warto tu zajrzeć ;-) na pierwszym linku źródła w C do pobrania do noty aplikacyjnej

http://www.psocdeveloper.com/docs/appnot...n2173.html

tu też duzo wzorów http://www.ti.com/lit/an/slyt277/slyt277.pdf

Myśle że przy dobrze dobranych C i kondensatorach - program z filmu "paint na LCD " rozwiewa niepewnośc czy ekran dziala dobrze... czy źle.

---

... i jeszcze ten link - z kodami do metody 3 punktowej

http://www.circuitidea.com/Article/Calib...duino.html

Arduino code

Kod:

/*
  Calibrate call touch_calibrate(). Routine set calibrate matrix and save to eeprom.
  Calibrate using 3 point calibrate.
  First point is 24,32.
  Second point is 215,160.
  Third point is 120,287.
  
  Touch screen api will read matrix at init class. No need to call calibrate again.

*/
lcdFont LCD;
touchscreen TS;

void showPoint(void)
{
  char sTemp[8];

  TS.readPoint();
  if (TS.screenPoint.x > 0)
  {
    LCD.Color = WHITE;
    LCD.FgColor = GREEN;    // text foreground color
    LCD.BkColor = RED;    // text background color
    
    ltoa(TS.screenPoint.x, sTemp, 10);
    LCD.TextBox(  0, 280,  59, 310, sTemp, ALINE_CENTER | BORDER_RECT | BORDER_FILL | BEVEL(8));
    ltoa(TS.screenPoint.y, sTemp, 10);
    LCD.TextBox( 60, 280, 119, 310, sTemp, ALINE_CENTER | BORDER_RECT | BORDER_FILL | BEVEL(8));
    ltoa(TS.displayPoint.x, sTemp, 10);
    LCD.TextBox(120, 280, 179, 310, sTemp, ALINE_CENTER | BORDER_RECT | BORDER_FILL | BEVEL(8));
    ltoa(TS.displayPoint.y, sTemp, 10);
    LCD.TextBox(180, 280, 239, 310, sTemp, ALINE_CENTER | BORDER_RECT | BORDER_FILL | BEVEL(8));
  }
}

int setCalibrationMatrix( POINT * displayPtr,
                          POINT * screenPtr,
                          MATRIX * matrixPtr)
{

    int  retValue = 1 ;


    
    matrixPtr->Divider = ((screenPtr[0].x - screenPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
                         ((screenPtr[1].x - screenPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;

    if( matrixPtr->Divider == 0 )
    {
        retValue = 0 ;
    }
    else
    {
        matrixPtr->An = ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
                        ((displayPtr[1].x - displayPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;

        matrixPtr->Bn = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].x - displayPtr[2].x)) -
                        ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].x - screenPtr[2].x)) ;

        matrixPtr->Cn = (screenPtr[2].x * displayPtr[1].x - screenPtr[1].x * displayPtr[2].x) * screenPtr[0].y +
                        (screenPtr[0].x * displayPtr[2].x - screenPtr[2].x * displayPtr[0].x) * screenPtr[1].y +
                        (screenPtr[1].x * displayPtr[0].x - screenPtr[0].x * displayPtr[1].x) * screenPtr[2].y ;

        matrixPtr->Dn = ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].y - screenPtr[2].y)) -
                        ((displayPtr[1].y - displayPtr[2].y) * (screenPtr[0].y - screenPtr[2].y)) ;
    
        matrixPtr->En = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].y - displayPtr[2].y)) -
                        ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].x - screenPtr[2].x)) ;

        matrixPtr->Fn = (screenPtr[2].x * displayPtr[1].y - screenPtr[1].x * displayPtr[2].y) * screenPtr[0].y +
                        (screenPtr[0].x * displayPtr[2].y - screenPtr[2].x * displayPtr[0].y) * screenPtr[1].y +
                        (screenPtr[1].x * displayPtr[0].y - screenPtr[0].x * displayPtr[1].y) * screenPtr[2].y ;
    }

    return( retValue ) ;

}


void touch_calibrate(void)
{
  unsigned char press;
    
  POINT screenSample[3];   //array of input points
  POINT displaySample[3] = {{24,32},{215,160},{120,287}};  //array of expected correct answers  TS.getMatrix();
  POINT capturePoint;      //array of valid input points

  LCD.Color = WHITE;    // graphic color
  LCD.FgColor = WHITE;  // text foreground color
  LCD.BkColor = BLACK;  // text background color
  
  LCD.TextBox(0, 0, LCD.getMaxX(), 30, "Calibrate", ALINE_CENTER);
  for (uint8_t i=0; i<3; i++)
  {
    // draw touch point
    LCD.Color = RED;
    LCD.Circle(displaySample[i].x, displaySample[i].y , 4);

    press = 0;
    TS.screenPoint.x = 0;
    TS.screenPoint.y = 0;
    while(!press)
    {
      capturePoint.x = TS.screenPoint.x;
      capturePoint.y = TS.screenPoint.y;
      TS.sampling(&TS.screenPoint, 50);
      if (TS.screenPoint.x > 0)
      {
        // Is stable point?
        if ((capturePoint.x == TS.screenPoint.x) && (capturePoint.y == TS.screenPoint.y))
          press = 1;
      }
    }
    // got a point
    screenSample[i].x = TS.screenPoint.x;
    screenSample[i].y = TS.screenPoint.y;

    // mark complete point
    LCD.Circle(displaySample[i].x, displaySample[i].y,3);
    delay(20);
    LCD.Circle(displaySample[i].x, displaySample[i].y,2);
    delay(20);
    LCD.Circle(displaySample[i].x, displaySample[i].y,1);
    delay(60);
    LCD.Color = WHITE;
    LCD.Circle(displaySample[i].x, displaySample[i].y,4);
    delay(20);
    LCD.Circle(displaySample[i].x, displaySample[i].y,3);
    delay(20);
    LCD.Circle(displaySample[i].x, displaySample[i].y,2);
    delay(20);
    LCD.Circle(displaySample[i].x, displaySample[i].y,1);
    delay(250);
  }

  LCD.Clear(BLACK);
  LCD.TextBox(0, 0, LCD.getMaxX(), 30, "Calibrating", ALINE_CENTER);
  setCalibrationMatrix(&displaySample[0], &screenSample[0], &TS.matrix);  // calibration
  TS.setMatrix();                                                         // save matrix to eeprom
  LCD.Clear(BLACK);
  LCD.TextBox(0, 0, LCD.getMaxX(), 30, "Calibrated", ALINE_CENTER);
  delay(1000);
}

void setup()
{

  LCD.Reset();
  LCD.Clear(BLACK);
  LCD.Font(f20x19);

  TS.Reset();
  touch_calibrate();  // use for calibrate only

  LCD.Color = WHITE;    // graphic color
  LCD.FgColor = GREEN;  // text foreground color
  LCD.BkColor = RED;    // text background color

  LCD.TextBox(  0, 250,  59, 279, "scrX", ALINE_CENTER | BORDER_RECT | BORDER_FILL | BEVEL(8));
  LCD.TextBox( 60, 250, 119, 279, "scrY", ALINE_CENTER | BORDER_RECT | BORDER_FILL | BEVEL(8));
  LCD.TextBox(120, 250, 179, 279, "lcdX", ALINE_CENTER | BORDER_RECT | BORDER_FILL | BEVEL(8));
  LCD.TextBox(180, 250, 239, 279, "lcdY", ALINE_CENTER | BORDER_RECT | BORDER_FILL | BEVEL(8));

}

void loop()                    
{
  showPoint();
}

[SP5FCS]

Pierwsza sprawa to nie powinno się zmuszać układu AD8743 do pracy na dużo większych szybkościach. W nocie katalogowej podają szybkość przetwarzania 125kSPS. O szybkości przetwarzania przetwornika ADC decyduje zegar interfejsu SPI. Dla Xmega z zegarem 32MHz i podziałem dla SPI 128 daje zegar równy 250kHz. Przy takiej szybkości układ jeszcze pracuje ale szybko rosną błędy przetwarzania przetwornika ADC (wykres ). Moje pierwsze próby robiłem na przetaktowanym procesorze, stąd duże przekłamania i gorsza praca układu AD7843. Przy powrocie do zegara 32MHz wyniki są zdecydowanie lepsze. Kondensatory na wejściach touch panela muszą mieć małą wartość ze względu na dużą szybkość przetwarzania ADC, w nocie katalogowej do obliczeń przyjęto 39pF (10nF na schemacie to był błąd).

   

Jako, że jest to na tym forum pierwsze urządzenie z panelem dotykowym warto przy tej okazji szerzej zapoznać się z różnymi zagadnieniami do rozwiązania. Jednym z nich jest programowa kalibracja i korekta geometrii panela dotykowego.
Przy urządzeniu powielany w wielu egzemplarzach ze względu na rozrzuty parametrów paneli rezystancyjnych użytkownik musi mieć możliwość okresowej kalibracji panela. Przy dużych klawiszach prawdopodobnie wystarczy kalibracja na 3 punkty + proste skalowanie do rozdzielczości ekranu.

[SP3SWJ]

ja robiłem z zegarem 32 Mhz i /128 /64 ... i nawet /64 działa bardzo dobrze.. ( jak na filmie) - myślę że do naszych celów może wystarczyć ta najprostsza kalibracja na dwa punkty po przekatnej - ale to dopiero mozna zweryfikowac na wiekszej partii .... coż ...

---

... tak jak pisałem ten sam panel pracujący z powolnym ADC z ATMEGA128 zachowywał sie liniowo....