Controller reagiert nicht immer auf Tasterdruck

6a66 Gast #4185208
Lesenswert?
• ▲
▼ 
Thomas schrieb:
> Mein Arduino reagiert nicht auf jeden Tastendruck.

Mein Auto fährt nicht - woran liegt das? Kann das seind ass man da den 
Zündschlüssel rumdrehen muss oder die runden Dinger da dran sein müssen?

Wenn Du uns gute Informationen gibts können wir auch gute Antworten 
liefern!

rgds
Antwort Zitieren Bearbeiten Löschen Beitrag melden
oldmax Gast #4185425
Lesenswert?
• ▲
▼ 
Hi
man kann aber auch den Taster dauernd festhalten, bis erwünschte 
Reaktion erfolgt. Dann die Pfoten von. und gut, Automatisiert... geht 
auch. Ein Modellauto einschalten, wenn Tastersignal erkannt, das fährt 
dann weg. Ist auch gut. Na ja, zum Betätigen halt das Auto wieder 
draufstellen...
Gruß oldmax

PS: das ihr aber auch immer so geil auf den geheimen Code seid..
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thomas Gast #4189832
Lesenswert?
• ▲
▼ 
Hallo


hier der Code. Ich muss immer so ca. 3 Sek. warten, wenn ich dann einen 
der Taster betätige reagiert der Controller.

Kann man das noch optimierten?


1
#include <Wire.h>

2


3
//#include <LiquidCrystal.h>

4


5
unsigned char search_mode=0;

6


7
char string[8];

8


9
int b=0;

10
int c=0;

11


12
#define Button_next 30

13
#define Button_prev 31

14


15


16


17
unsigned char frequencyH=0;

18
unsigned char frequencyL=0;

19


20
unsigned int frequencyB;

21
double frequency=0;

22


23
float freq_available=0;

24


25


26


27
#define RST 12

28
#define CE  11

29
#define DC  10

30
#define DIN  9

31
#define CLK  8

32


33
static const byte ASCII[][5] =

34
{

35
 {0x00, 0x00, 0x00, 0x00, 0x00} // 20  

36
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !

37
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "

38
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #

39
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $

40
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %

41
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &

42
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '

43
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (

44
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )

45
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *

46
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +

47
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,

48
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -

49
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .

50
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /

51
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0

52
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1

53
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2

54
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3

55
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4

56
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5

57
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6

58
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7

59
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8

60
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9

61
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :

62
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;

63
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <

64
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =

65
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >

66
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?

67
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @

68
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A

69
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B

70
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C

71
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D

72
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E

73
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F

74
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G

75
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H

76
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I

77
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J

78
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K

79
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L

80
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M

81
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N

82
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O

83
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P

84
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q

85
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R

86
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S

87
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T

88
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U

89
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V

90
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W

91
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X

92
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y

93
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z

94
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [

95
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥

96
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]

97
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^

98
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _

99
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `

100
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a

101
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b

102
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c

103
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d

104
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e

105
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f

106
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g

107
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h

108
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i

109
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j 

110
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k

111
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l

112
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m

113
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n

114
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o

115
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p

116
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q

117
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r

118
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s

119
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t

120
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u

121
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v

122
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w

123
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x

124
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y

125
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z

126
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {

127
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |

128
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }

129
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ←

130
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f →

131
};

132


133
void LcdXY(int x, int y)

134
{

135
  LcdWriteCmd(0x80 | x); //Column

136
  LcdWriteCmd(0x40 | y); //Row

137
}

138


139
void LcdWriteString(char *characters)

140
{

141
  while(*characters) LcdWriteCharacter(*characters++);

142
}

143


144
void LcdWriteCharacter(char character)

145
{

146
  for(int i=0; i<5; i++) LcdWriteData(ASCII[character - 0x20][i]);

147
  LcdWriteData(0x00);

148
}

149


150
void LcdWriteData(byte cmd)

151
{

152
digitalWrite(DC, HIGH);// DC pin is High for Data

153
digitalWrite(CE, LOW);

154
shiftOut(DIN, CLK, MSBFIRST, cmd);//transmit serial data

155
digitalWrite(CE, HIGH);

156
}

157


158
void LcdWriteCmd(byte cmd)

159
{

160
digitalWrite(DC, LOW);// DC pin is low for commands

161
digitalWrite(CE, LOW);

162
shiftOut(DIN, CLK, MSBFIRST, cmd);//transmit serial data

163
digitalWrite(CE, HIGH);

164
}

165


166


167


168
//LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 

169


170
void setup()   { 

171


172
  Wire.begin();

173
  //lcd.begin(16, 2);

174


175


176
  pinMode(RST, OUTPUT);

177
  pinMode(CE, OUTPUT);

178
  pinMode(DC, OUTPUT);

179
  pinMode(DIN, OUTPUT);

180
  pinMode(CLK, OUTPUT);

181
  digitalWrite(RST, LOW);

182
  digitalWrite(RST, HIGH);

183


184


185
  LcdWriteCmd(0x21); //LCD extended commands

186
  LcdWriteCmd(0xB8); // set LCD Vop (contrast)

187
  LcdWriteCmd(0x04); // set temp coefficent

188
  LcdWriteCmd(0x14); //LCD bias mode 1:40

189
  LcdWriteCmd(0x20); //LCD basic commands

190
  LcdWriteCmd(0x0C); //LCD normal video mode

191


192
  //LcdXY(0,0);

193


194
  /// buttons  

195


196
  pinMode(Button_next, INPUT);

197
  digitalWrite(Button_next, HIGH); //pull up resistor

198


199
  pinMode(Button_prev, INPUT);

200
  digitalWrite(Button_prev, HIGH); //pull up resistor

201


202
  frequency=94.7; //starting frequency

203


204
  

205


206
  frequencyB=4*(frequency*1000000+225000)/32768; //calculating PLL word

207


208
  frequencyH=frequencyB>>8;

209


210
  frequencyL=frequencyB&0XFF;

211


212
  //delay(1);

213


214
  Wire.beginTransmission(0x60);   //writing TEA5767

215


216
  Wire.write(frequencyH);

217
  Wire.write(frequencyL);

218
  Wire.write(0xB0);

219
  Wire.write(0x10);

220
  Wire.write(0x00);

221
  Wire.endTransmission();

222


223
  //delay(1);

224


225
}

226


227
void loop()

228
{

229


230
  unsigned char buffer[5];

231


232
  //lcd.setCursor(0, 0);

233


234
  Wire.requestFrom(0x60,5); //reading TEA5767

235


236
  if (Wire.available()) 

237


238
  {

239
    for (int i=0; i<5; i++) {

240


241
      buffer[i]= Wire.read();

242
    }

243


244
    freq_available=(((buffer[0]&0x3F)<<8)+buffer[1])*32768/4-225000;

245


246
     LcdWriteString("FM ");

247
    //lcd.print("FM ");

248
    LcdWriteString(dtostrf(freq_available/1000000,5,2,string));

249


250
    //lcd.print((freq_available/1000000));

251


252
    frequencyH=((buffer[0]&0x3F));

253


254
    frequencyL=buffer[1];

255


256
    if (search_mode) {

257


258
      if(buffer[0]&0x80) search_mode=0;

259


260
    }

261


262
    //if (search_mode==1) LcdWriteString(" SCAN");//lcd.print(" SCAN");

263
    //else {

264
      //LcdWriteString("NO SCAN");//lcd.print("       ");

265
    //}

266


267
    //lcd.setCursor(0, 1);

268
    LcdXY(0, 1);

269
    

270


271
    //LcdWriteString("Level: ");//lcd.print("Level: ");

272
    //LcdWriteCharacter((buffer[3]>>4));

273
    //LcdWriteString("/16");

274
    //lcd.print((buffer[3]>>4));

275
    //lcd.print("/16 ");

276


277
    if (buffer[2]&0x80) LcdWriteString("STEREO   ");//lcd.print("STEREO   ");

278
    else LcdWriteString("MONO     ");//lcd.print("MONO   ");

279


280
  }

281


282
  ///// buttons read

283


284
  //////////// button_next////////// 

285
  if (!digitalRead(Button_next)&&!b) {

286


287
    frequency=(freq_available/1000000)+0.10;

288


289
    frequencyB=4*(frequency*1000000+225000)/32768+1;

290


291
    frequencyH=frequencyB>>8;

292
    frequencyL=frequencyB&0XFF;   

293


294
    Wire.beginTransmission(0x60);   

295


296
    Wire.write(frequencyH);

297
    Wire.write(frequencyL);

298
    Wire.write(0xB0);

299
    Wire.write(0x1F);

300
    Wire.write(0x00); 

301


302
    Wire.endTransmission(); 

303


304
    //////////////////////

305


306
    b=100;

307


308
  };

309


310
  if (!digitalRead(Button_next)&&b==1) {

311


312
    ///scannnn UP

313


314
    search_mode=1;

315


316
    Wire.beginTransmission(0x60);   

317


318
    Wire.write(frequencyH+0x40);

319
    Wire.write(frequencyL);

320
    Wire.write(0xD0);

321
    Wire.write(0x1F);

322
    Wire.write(0x00); 

323


324
    Wire.endTransmission();

325


326
    /////////////////

327


328
    b=100;

329


330
  };    

331


332
  if (!b==0) b--;

333


334
  //////////// button_prev////////// 

335
  if (!digitalRead(Button_prev)&&!c) {

336


337
    frequency=(freq_available/1000000)-0.10;

338


339
    frequencyB=4*(frequency*1000000+225000)/32768+1;

340


341
    frequencyH=frequencyB>>8;

342
    frequencyL=frequencyB&0XFF;

343


344
    Wire.beginTransmission(0x60);   

345


346
    Wire.write(frequencyH);

347
    Wire.write(frequencyL);

348
    Wire.write(0xB0);

349
    Wire.write(0x1F);

350
    Wire.write(0x00); 

351


352
    Wire.endTransmission(); 

353


354
    c=100;

355


356
  };

357


358
  if (!digitalRead(Button_prev)&&c==1) {

359


360
    ///scannnn DOWN

361


362
    search_mode=1;

363


364
    Wire.beginTransmission(0x60);   

365


366
    Wire.write(frequencyH+0x40);

367
    Wire.write(frequencyL); 

368


369
    Wire.write(0x50);

370
    Wire.write(0x1F);

371
    Wire.write(0x00);

372
    Wire.endTransmission();   

373


374
    c=100;

375


376
  };          

377


378
  if (!c==0) c--;

379


380
  ////////////////////

381


382
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Alf Gast #4189900
Lesenswert?
• ▲
▼ 
Ich kann nicht erkennen, was du da für wichtige Wire.Transmissions
aussendest, aber:

Eine sichere Tastenerkennung ohne einen Timer-Interrupt,
der z.B. alle 1...50 ms den Zustand der Tasten abfragt, ist
unzuverlässig, wenn der µC auch manchmal für längere Zeit mit
was ganz anderem beschäftigt ist.

Wenn man die Tastenerkennung in diesem Timer-Interrupt
fix bearbeitet, stört das kaum bei den anderen Aufgaben.
Du musst nur ein paar Register bereitstellen, in denen die
Tasten-Aktionen für die Hauptschleife festgehalten werden.

In der Hauptschleife wird irgendwann in den Registern nachgeschaut,
was angefordert wurde - und darauf reagiert. - Und das bearbeitete
Register gelöscht, sonst wird es eine Endlos-Reaktion...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #4189915
Lesenswert?
• ▲
▼ 
Erklär doch mal, was hier
1
  if (!digitalRead(Button_next)&&!b) {

2


3
....

4
    b=100;

5


6
  };

7


8
  if (!digitalRead(Button_next)&&b==1) {

9


10
....

11
    b=100;

12


13
  };    

14


15
  if (!b==0) b--;

der Sinn der Sache ist. So ganz durchschau ich das noch nicht, welchen 
Zweck hier b erfüllen soll.
Ich seh aber das, wenn b erst mal auf 100 ist, es mindestens 99 
Durchläufe durch loop benötigt, bis b wieder entweder 0 oder 1 ist. 99 
(bzw. 100) Durchläufe in denen offenbar jedesmal per I2C ein Empfänger 
nach seiner Frequenz gefragt wird, die dann mittels Floating Point 
Arithmetik umgerechnet und aufs Display gegeben wird. Was beides auch 
nicht gerade das schnellste zu sein scheint. Und vor allen Dingen: 99 
Durchläufe, in denen eine gedrückte Taste zu keiner Aktion führt.

"Kann man das optimieren" ist gut. Man könnte zuallererst mal eine 
vernünftige Tastendruckerkennung einbauen.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren