ATNEL tech-forum

Re: Klawiatura ekranowa - jak podejść do liczb rzeczywistych

2013-03-17T20:43:43+01:00

Dzięki za rady, jednak te stringi mnie pokonały... Do tego celu moim zdaniem nie nadają się - lepiej pracować na liczbach i strukturce o której pisałem.
Zrobiłem po swojemu i działa pięknie - w tym cofanie (backspace), +/-, liczby całkowite i rzeczywiste.
Czyli pełna klawiaturka numeryczna.
Jak chcecie zapodam kod.

------------------------ [ Dodano po: 13 minutach ]

[syntax=c]typedef enum
{
false,
true
} bool;

typedef struct
{
bool isReal;
int intPart;
int fractPart;
} numKbdResult;

typedef struct
{
uint16_t leftBorder[KEYS_NR];
uint8_t upBorder[KEYS_NR];
uint8_t xSize[KEYS_NR];
uint8_t ySize[KEYS_NR];
}screenKbd;

extern screenKbd numKbd;
extern numKbdResult numKbdRes;[/syntax]

[syntax=c]int scrKbdHandle(int x, int y);
numKbdResult numKbdRes;
numKbdResult lastNumKbdRes;
double scrKbdRes;
int fractDiv(int arg);[/syntax]

[syntax=c]frame_ptr = SSDXBUF4;
tftCls(white);
setCurrentFont(&CourierNew10pt_boldFontInfo);
char* kbdStr[15] = {"0","1","2","3","4","5","6","7","8","9","
for(uint8_t i=0; i<15; i++)
{
drawButton(numKbd.leftBorder[i], numKbd.upBorder[i], numKbd.xSize[i], numKbd.ySize[i],kbdStr[i],1);
}

tftRect(30,50,210,30,black);[/syntax]

[syntax=c]void handleTouch()
{
int x = tpX, y = tpY;
static int lx, ly;
int keyNo;

if(((x <= (lx+TP_THR)) && (x >= (lx-TP_THR))) || ((y <= (ly+TP_THR) && (y >= (ly-TP_THR)))))
{
return;
}

else
{
switch(currMenu)
{
case mI_screenKbd:
frame_ptr = SSDXBUF4;
keyNo = scrKbdHandle(x,y);

switch(keyNo)
{
case -1:
return;

case 10:// if(numKbdRes.isReal == true)
{
if(numKbdRes.fractPart < 10)
{
numKbdRes.isReal = false;
numKbdRes.fractPart = 0;
}
else
{
numKbdRes.fractPart /= 10;
}
}
else
{
numKbdRes.intPart /= 10;
}
break;

case 11:// +/-
numKbdRes.intPart = - numKbdRes.intPart;
break;

case 12:// .
if(numKbdRes.isReal == false)
{
numKbdRes.isReal = true;
}
else
{

}
break;

default:
CX = 34;
}

if(keyNo < 10)
{
if(numKbdRes.isReal == true)
{
numKbdRes.fractPart = 10*numKbdRes.fractPart + keyNo;
}
else
{
numKbdRes.intPart = 10*numKbdRes.intPart + keyNo;
}

}

tftFillRect(31,51,208,28,white);
tftPutInt(34,60,numKbdRes.intPart,black,white);

if(numKbdRes.isReal == true)
{
tftPutsP(CX,60,PSTR("."),black,white);

if(numKbdRes.fractPart != 0)
{
int cxOld = CX;
tftPutInt(cxOld,60,numKbdRes.fractPart,black,white);
}
}

// ------------- sprawdzenie --------------------
tftFillRect(10,10,100,20,white);
tftPutInt(10,10,numKbdRes.intPart,black,white);
tftPutInt(10,20,numKbdRes.fractPart,black,white);
// ----------------------------------------------

if(numKbdRes.isReal == false)
{
scrKbdRes = numKbdRes.intPart;
}
else
{
scrKbdRes += numKbdRes.fractPart/fractDiv(numKbdRes.fractPart);
}

// sprawdzenie
tftPutDouble(150,20,numKbdRes.intPart,numKbdRes.fractPart,black,white);

break;
}
}

lx = x;
ly = y;
}[/syntax]

[syntax=c]int scrKbdHandle(int x, int y)
{
for(int i=0; i{
if(x>numKbd.leftBorder[i] && x<(numKbd.leftBorder[i] + numKbd.xSize[i]) && y>numKbd.upBorder[i] && y<(numKbd.upBorder[i] + numKbd.ySize[i]))
{
return i;
}
}
return -1;
}
[/syntax]

[syntax=c]// zwraca przez ile trzeba podzielić częc ułamkową
// (np. arg = 234, funkcja zwróci 1000, bo 234/1000 = 0.234)
int fractDiv(int arg)
{
uint8_t cnt = 0;
int res = 1;

while(arg > 0)
{
cnt++;
arg /= 10;
}

while(cnt--)
{
res *= 10;
}

return res;
}[/syntax]

I na deser - funkcja wyświetlająca double na TFT:
[syntax=c]void tftPutDouble(int x, int y, int intPart, int fractPart, uint32_t pen, uint32_t brush)
{
char bufor[17];

itoa(intPart, bufor, 10);
tftPuts(x, y, bufor, pen, brush);

if(fractPart != 0)
{
tftPutsP(CX, y, PSTR("."),pen,brush);

itoa(fractPart, bufor, 10);
tftPuts(CX, y, bufor, pen, brush);
}
}[/syntax]

Statystyki: Napisane przez Ledes — 17 mar 2013, o 20:43

Re: Klawiatura ekranowa - jak podejść do liczb rzeczywistych

2013-03-17T09:48:53+01:00

Pamiętaj że jak używasz funkcji z biblioteki string.h to łańcuchy na których operujesz muszą kończyć się '\0', nawet jak łańcuch jest dla ciebie pusty, to musi on mieć na pozycji zerowej właśnie '\0'.

Tutaj masz jeden z przykładów jak dodawać kolejne znaki do łańcucha. Może trzeba to lekko zmodyfikować, bo piszę tak na sucho, chodzi mi o pokazanie idei:

[syntax=c]char buf[5];
char znak;

uint8_t len = strlen(buf);

znak = get_key();//tutaj pobierasz z ekranu pojedyncza cyfre ktora wcisnales

*(buf + len) = znak;len++; //dodanie do bufora nowej cyfry
*(buf + len) = '\0'; //dopisanie konca lini

float liczba = atof(buf);

[/syntax]

To co "wypluwa" ci ekran (czyli dla ciebie cyfry) musisz traktować jako znak i operować na znakach

Statystyki: Napisane przez savian86 — 17 mar 2013, o 09:48

Re: Klawiatura ekranowa - jak podejść do liczb rzeczywistych

2013-03-16T22:26:38+01:00

Chyba wrócę do swojej metody, te stringi w AVR-GCC to jakaś masakra, nie to co w C++.

Statystyki: Napisane przez Ledes — 16 mar 2013, o 22:26

Re: Klawiatura ekranowa - jak podejść do liczb rzeczywistych

2013-03-16T21:20:08+01:00

Nie radzę sobie z tym podejściem - tzn samo atof() to na końcu, ale jak uzyskać tego stringa? Jak dopisywać do niego poszczególne literki? Jakiej funkcji użyć? Próbowałem strcat(), ale coś nie wychodzi...

Statystyki: Napisane przez Ledes — 16 mar 2013, o 21:20

Re: Klawiatura ekranowa - jak podejść do liczb rzeczywistych

2013-03-15T23:54:12+01:00

Hmmm nie pomyślałem o takim podejściu - jutro spróbuję, dzięki. Faktycznie to może być "właściwa" droga. Proszę o dalsze wskazówki. Jutro się przydadzą.

Statystyki: Napisane przez Ledes — 15 mar 2013, o 23:54

Re: Klawiatura ekranowa - jak podejść do liczb rzeczywistych

2013-03-15T10:02:36+01:00

savian86 - życzę smacznej kawy, ja też zaraz po nią sięgnę ..... napij się ... i ew pisz dalej - bo w dobrym kierunku idziesz z podpowiedzią

Statystyki: Napisane przez mirekk36 — 15 mar 2013, o 10:02

Re: Klawiatura ekranowa - jak podejść do liczb rzeczywistych

2013-03-15T07:27:27+01:00

A nie mógłbyś wprowadzać tych liczb jako tekst, a następnie potraktować tego funkcją - long atol( char *p ) ?

Ehh, sorki, za wczesna godzina dla mnie:) Chciałeś floata a nie całkowitą ;] wycofuje się z podpowiedzi

---------
znalazłem jeszcze coś takiego

Code:

double strtod(const char *s, char **endptr)
Zamienia łańcuch ASCII na liczbę typu double.

Nie znam tego, nie testowałem i nie wiem jak z pożeraniem zasobów.

--------
No dobra, powyżej trochę pomarudziłem może mniej sensownie

Odszukałem taką informację, że należy dodać bibliotekę libm.m i wtedy dostępna będzie funkcja atof(char *n). Nie siedzę teraz przy swoim kompie więc namacalnie nie jestem w stanie tego sprawdzić.

Dobra idę po kawę bo nie ujadę

Statystyki: Napisane przez savian86 — 15 mar 2013, o 07:27

Klawiatura ekranowa - jak podejść do liczb rzeczywistych

2013-03-15T01:13:29+01:00

Witam, podczas realizacji mojej pracy mgr przyszło mi zaimplementować klawiaturę ekranową (numeryczną) do wprowadzania liczb (całkowite i rzeczywiste, np. -4.12, 5, 23.14) na LCD TFT ze sklepu Atnela.

Z całkowitymi (wraz z ujemnymi) sobie łatwo poradziłem, ale mam problem z "przecinkowymi". Mam kilka pomysłów jak do tego podejść, ale nie wiem, czy nie idę nieco dookoła zagadnienia.

Pytanie jest następujące: czy ktoś z szanowych forumowiczów zetknął się z zadaniem stworzenia takiej klawiatury ekranowej i mógłby zdradzić, jak podszedł do parsowania danych z niej? Może przedstawię, jak się u mnie prezentuje taka klawiaturka:

zdjęcie pod linkiem: https://dl.dropbox.com/u/6082561/2013-0 ... .27.53.jpg

Kod odpowiedzialny za nią (póki co z tymi rzeczywistymi walczyłem, ale bez powodzenia więc część kodu bez sensu):

[syntax=c]#define KEYS_NR 15

typedef struct
{
uint16_t leftBorder[KEYS_NR];
uint8_t upBorder[KEYS_NR];
uint8_t xSize[KEYS_NR];
uint8_t ySize[KEYS_NR];
}screenKbd;

extern screenKbd numKbd;[/syntax]

[syntax=c]void controllerInit()
{
// ------------------ klawiatura ekranowa ------------------------
for(int i=0; i<5; i++)// 0-4
{
numKbd.leftBorder[i] = 30 + i*43;
numKbd.upBorder[i] = 90;
numKbd.xSize[i] = 38;
numKbd.ySize[i] = 38;
}

for(int i=5; i<10; i++) // 5-9
{
numKbd.leftBorder[i] = 30 + (i-5)*43;
numKbd.upBorder[i] = 140;
numKbd.xSize[i] = 38;
numKbd.ySize[i] = 38;
}

for(int i=10; i<13; i++) // {
numKbd.leftBorder[i] = 251;
numKbd.upBorder[i] = 5 + (i-9)*45;
numKbd.xSize[i] = 38;
numKbd.ySize[i] = 38;
}

for(int i=13; i<15; i++) // anuluj, ok
{
numKbd.leftBorder[i] = 90+(i-12)*77;
numKbd.upBorder[i] = 200;
numKbd.xSize[i] = 70 - (i-13)*24;
numKbd.ySize[i] = 30;
}

//--------------------------------------------------------------------

}[/syntax]

[syntax=c]void handleTouch()
{
int x = tpX, y = tpY;
static int lx, ly;
int keyNo;
bool fFract = false;
static int lastScrKbdRes;

switch(currMenu)
{
case mI_screenKbd:
lastScrKbdRes = scrKbdRes;

frame_ptr = SSDXBUF4;
keyNo = scrKbdHandle(x,y);
switch(keyNo)
{
case 10:// if(fFract == true)
{
scrKbrResFract /= 10;
}
else
{
scrKbdRes /= 10;
}
break;

case 11:// +/-
scrKbdRes = -scrKbdRes;
break;

case 12:// .
fFract = true;
tftPutsP(CX,60,PSTR("."),black,white);
break;

default:
CX = 34;
}

if(keyNo < 10)
{
if(fFract == true)
{
scrKbrResFract = 10*scrKbrResFract + keyNo;
}
else
{
scrKbdRes = 10*scrKbdRes + keyNo;
}

}

if(fFract == false)
{
tftPutInt(34,60,lastScrKbdRes,white,white);
tftPutInt(34,60,scrKbdRes,black,white);
}

else if(fFract == true && scrKbrResFract != 0)
{
//tftPutInt(34,60,scrKbrResFract,white,white);
tftPutInt(CX,60,scrKbrResFract,black,white);
}
break;
[/syntax]

[syntax=c]int scrKbdHandle(int x, int y)
{
for(int i=0; i{
if(x>numKbd.leftBorder[i] && x<(numKbd.leftBorder[i] + numKbd.xSize[i]) && y>numKbd.upBorder[i] && y<(numKbd.upBorder[i] + numKbd.ySize[i]))
{
return i;
}
}
return -1;
}[/syntax]

Problem jest właśnie z liczbami typu 31.52 (gdzie występuje część całkowita i ułamkowa), problemy są różnorakie:
1) jak to reprezentować w programie? myślałem o tym, aby klawiatura zwracała wynik będący strukturą zbudowaną z trzech składowych. Te składowe to byłaby flaga mówiąca o tym, czy wynik jest liczbą całkowitą, czy rzeczywistą, druga składowa to część całkowita (int), trzecia to część ułamkowa (również int). Czy jest to dobre podejście?

2) sparsowanie tego z "dotyku" to ciężka sprawa, narysowałem do tego "automat", link: https://dl.dropbox.com/u/6082561/2013-0 ... .46.51.jpg , ale czy nie idę nieco dookoła? jest prostszy sposób?

3) następny problem: zamiana tych dwóch intów na jednego, wynikowego floata. Niby już doszedłem do tego, jak, ale znowu - dodatkowe komplikacje. Pomysł jest taki:
mamy liczbę 2.34, to oznacza inta 2 i inta 34. Floata składamy tak: 2 + 34*0.01 = 2+0.34 = 2.34. To, jaki jest mnożnik (tutaj: 0.01) zależy od tego, ile cyfr jest w drugim incie. Tutaj mamy dwie cyfry (34, czyli 3 i 4), więc mamy mnożnik z jednym zerem po przecinku (o jedno zero mniej niż cyfr w drugim incie). Dobry sposób? Czy zbyt zamotany?

Proszę o pomoc.
Pozdrawiam, Michał

Statystyki: Napisane przez Ledes — 15 mar 2013, o 01:13