Arduino Uno & HDLx

#3982901
Lesenswert?

Hi @ll,

Zuerst eine Begrüßung. Dies ist mein erster Beitrag oder vielmehr eine 
Frage. Also hallo an alle "Alt Eingesessenen".

Also ich versuche gerade mit einem Arduino Uno ein HDLx-2416 von Avago 
zum schwatzen zu überreden. Nur funktioniert das nicht so recht. Das 
Drecksding gibt kein Mux von sich. Das schöne an diesen HDLx's ist, sie 
gehen nicht so schnell kaputt; das blöde daran, ich glaube langsam, 
meiner ist kaputt.

Ich habe mich echt an dieses Datasheet gehalten und ich stelle mal die 
kühne Behauptung auf, ich hätte sie verstanden.

Datasheet: http://www.avagotech.com/docs/AV02-0662EN

Aber ich scheine mich entweder zu deppert anzustellen oder mein HDLA ist 
tatsächlich kaputt.

Hier ist mein Code, die Pinbelegung habe ich oben in den Code 
geschrieben. Vielleicht hat ja jemand so was schon mal gemacht oder hat 
Arduino und HDLx zu Hause rumfliegen, um sich meinen Mist mal 
anzuschauen.


Vielen Dank im Vorraus.

Gruß
Emanuel
1
/////////////////// Arduino UNO:
2
// Pin 1 = CLR
3
// Pin 2 = A0
4
// Pin 3 = A1
5
// Pin 4 = D0
6
// Pin 5 = D1
7
// Pin 6 = D2
8
// Pin 7 = D3
9
// Pin 8 = D4
10
// Pin 9 = A5
11
// Pin 10 = A6
12
// Pin 11 = WR
13
// Pin 12 = BL
14
// Pin 5V = VDD
15
// Pin GND = GND
16

17
int clr = 1;
18
int wr = 11;
19
int bl = 12;
20
byte a[2]; 
21
byte d[7]; 
22

23
/*
24
 * Init display
25
 */
26
void setup() {   
27
  Serial.begin(9600);  
28
  Serial.println("DISPLAY");
29
  
30
  // Reset RAM
31
  pinMode(clr, OUTPUT); 
32
  digitalWrite(clr, 0);
33
  delay(100);
34
  digitalWrite(clr, 1);
35
  
36
  // Display Ascii
37
  pinMode(bl, OUTPUT); 
38
  digitalWrite(bl, 1); 
39
  
40
  // Do not set display  
41
  pinMode(wr, OUTPUT); 
42
  digitalWrite(wr, 1); 
43

44
  // Init pins
45
  for(int i = 0 ;i < 2; i++)  {
46
    a[i] = i + 2;
47
    pinMode(a[i], OUTPUT);
48
    digitalWrite(a[i], 0); 
49
  } 
50
  
51
  for(int i = 0 ; i < 7; i++)  {
52
    d[i] = i + 4;
53
    pinMode(d[i], OUTPUT); 
54
    digitalWrite(d[i], 0); 
55
  }
56
}
57

58
/*
59
 * Run display
60
 */
61
void loop() { 
62
  // Print A-D 
63
  dsply(0x41, 0x42, 0x43, 0x44);  
64
  delay(5000);
65

66
  // Print E-H 
67
  dsply(0x45, 0x46, 0x47, 0x48);
68
  delay(5000);
69
}
70

71
/*
72
 * Display characters
73
 */
74
void dsply(byte c0, byte c1, byte c2, byte c3) {
75
  // From left
76
  dsply(0x0, c0);
77
  dsply(0x1, c1);
78
  dsply(0x2, c2);
79
  dsply(0x3, c3);
80
}
81

82
/*
83
 * Print a single character
84
 */
85
void dsply(byte pos, byte val) {
86
  //Serial.print(getBit(pos, 0));
87
  //Serial.print(" ");
88
  //Serial.println(getBit(pos, 1));
89
  
90
  digitalWrite(a[0], getBit(pos, 0)); 
91
  digitalWrite(a[1], getBit(pos, 1));   
92
  delay(500);
93
  
94
  digitalWrite(wr,0);
95
  for(int i = 0; i < 7; i++) {
96
    //Serial.print(getBit(val, i));
97
    //Serial.print(" ");
98
    digitalWrite(d[i], getBit(val, i)); 
99
  }
100
  delay(5);
101
  digitalWrite(wr,1); 
102
  delay(500);
103
  
104
  //Serial.println();
105
}
106

107
/*
108
 * Returns a bit from a value of a given index
109
 */
110
bool getBit(byte val, int index) {
111
  return (val >> index) & 1;
112
}
#3983008
Lesenswert?

Vielleicht ist es so etwas angenehmer, sorry nochmal. Ansonsten die 
Benamung der Variablen ist am Datasheet ausgerichtet.


/////////////////// Arduino UNO:
// Pin 1 = CLR
// Pin 2 = A0
// Pin 3 = A1
// Pin 4 = D0
// Pin 5 = D1
// Pin 6 = D2
// Pin 7 = D3
// Pin 8 = D4
// Pin 9 = D5
// Pin 10 = D6
// Pin 11 = WR
// Pin 12 = BL
// Pin 5V = VDD
// Pin GND = GND

int clr = 1;
int wr = 11;
int bl = 12;
byte a[2];
byte d[7];

/*
 * Init display
 */
void setup() {
  Serial.begin(9600);
  Serial.println("DISPLAY");

  // Reset RAM
  pinMode(clr, OUTPUT);
  digitalWrite(clr, 0);
  delay(100);
  digitalWrite(clr, 1);

  // Display Ascii
  pinMode(bl, OUTPUT);
  digitalWrite(bl, 1);

  // Do not set display
  pinMode(wr, OUTPUT);
  digitalWrite(wr, 1);

  // Init pins
  for(int i = 0 ;i < 2; i++)  {
    a[i] = i + 2;
    pinMode(a[i], OUTPUT);
    digitalWrite(a[i], 0);
  }

  for(int i = 0 ; i < 7; i++)  {
    d[i] = i + 4;
    pinMode(d[i], OUTPUT);
    digitalWrite(d[i], 0);
  }
}

/*
 * Run display
 */
void loop() {
  // Print A-D
  setDisplay(0x41, 0x42, 0x43, 0x44);
  delay(5000);

  // Print E-H
  setDisplay(0x45, 0x46, 0x47, 0x48);
  delay(5000);
}

/*
 * Display characters
 */
void setDisplay(byte c0, byte c1, byte c2, byte c3) {
  // From left
  setChar(0x0, c0);
  setChar(0x1, c1);
  setChar(0x2, c2);
  setChar(0x3, c3);
}

/*
 * Print a single character
 */
void setChar(byte pos, byte character) {
  //Serial.print(getBit(pos, 0));
  //Serial.print(" ");
  //Serial.println(getBit(pos, 1));

  digitalWrite(a[0], getBitAtPos(pos, 0));
  digitalWrite(a[1], getBitAtPos(pos, 1));
  delay(500);

  digitalWrite(wr,0);
  for(int i = 0; i < 7; i++) {
    //Serial.print(getBit(val, i));
    //Serial.print(" ");
    digitalWrite(d[i], getBitAtPos(character, i));
  }
  delay(5);
  digitalWrite(wr,1);
  delay(500);

  //Serial.println();
}

/*
 * Returns a bit from a value of a given index
 */
int getBitAtPos(byte val, int index) {
  return (val >> index) & 1;
}
#3983041
Lesenswert?

Ich halte die Zustände ein, jedoch im Nanosekunden Bereich schalte ich 
nicht. Ich habe mit den Timings rumgespielt und sie verkürzt und 
verlängert. Jedoch mache ich alles in seinem Zeitschritt, wie ich meine. 
Ich habe das mit einem analogen Multimeter durchgespielt und angepeilt, 
wie lange es dauert bis ein Pin von High auf Low ist. Aber wie sicher 
oder genau das letztlich mit dem Multimeter ist, weiß ich nicht und was 
anderes habe ich nicht.
#3983073
Lesenswert?

So hier nochmal bereinigt:


/////////////////// Arduino UNO:
// Pin 1 = CLR
// Pin 2 = A0
// Pin 3 = A1
// Pin 4 = D0
// Pin 5 = D1
// Pin 6 = D2
// Pin 7 = D3
// Pin 8 = D4
// Pin 9 = D5
// Pin 10 = D6
// Pin 11 = WR
// Pin 12 = BL
// Pin 5V = VDD
// Pin GND = GND

// Clear
int clr = 1;
// Write mode
int wr = 11;
// Display Blank
int bl = 12;
// Adress input
byte a[2];
// Data input
byte d[7];

/*
 * Init display
 */
void setup() {
  //Serial.begin(9600);
  //Serial.println("DISPLAY");

  // Reset RAM
  pinMode(clr, OUTPUT);
  digitalWrite(clr, 0);
  delay(100);
  digitalWrite(clr, 1);

  // Display Ascii Mode
  pinMode(bl, OUTPUT);
  digitalWrite(bl, 1);

  // Do not set to display mode (write to Character-Ram not allowed)
  pinMode(wr, OUTPUT);
  digitalWrite(wr, 1);

  // Init pins D0-D6
  for(int i = 0 ;i < 2; i++)  {
    a[i] = i + 2;
    pinMode(a[i], OUTPUT);
    digitalWrite(a[i], 0);
  }

  // Init pins A0-A2
  for(int i = 0 ; i < 7; i++)  {
    d[i] = i + 4;
    pinMode(d[i], OUTPUT);
    digitalWrite(d[i], 0);
  }
}

/*
 * Run display output and prints in the first step A-D on the screen
 * and after 5 sec the Characters E-H.
 */
void loop() {
  // Print A-D
  setDisplay(0x41, 0x42, 0x43, 0x44);
  delay(5000);

  // Print E-H
  setDisplay(0x45, 0x46, 0x47, 0x48);
  delay(5000);
}

/*
 * Displays 4 characters on the HDLx
 * @param c0 Character at position 1
 * @param c1 Character at position 2
 * @param c2 Character at position 3
 * @param c3 Character at position 4
 */
void setDisplay(byte c0, byte c1, byte c2, byte c3) {
  // From left
  setChar(0x0, c0);
  setChar(0x1, c1);
  setChar(0x2, c2);
  setChar(0x3, c3);
}

/*
 * Print a single character at the index position
 * @param pos Position of the display (Range 0-3)
 * @param character The character that is displayed on the HDLx at a 
given position
 */
void setCharAt(byte pos, byte character) {
  //Serial.print(getBit(pos, 0));
  //Serial.print(" ");
  //Serial.println(getBit(pos, 1));

  // Set character position
  digitalWrite(a[0], getBitAtPos(pos, 0));
  digitalWrite(a[1], getBitAtPos(pos, 1));
  delay(500);

  // Set to displays write mode
  digitalWrite(wr,0);
  // Set the character to the Character-RAM
  for(int i = 0; i < 7; i++) {
    //Serial.print(getBit(val, i));
    //Serial.print(" ");
    digitalWrite(d[i], getBitAtPos(character, i));
  }
  delay(5);
  // Set Character-RAM to the display
  digitalWrite(wr,1);
  delay(500);

  //Serial.println();
}

/*
 * Returns a bit from a value of a given index.
 * @param character displayed character.
 * @param index Index position of the bit (Range 0-7)
 */
int getBitAtPos(byte character, int index) {
  return (character >> index) & 1;
}
#3983366
Lesenswert?

CE1 und CE2 sind egal und können auf Low bleiben. Sie haben eigentlich 
keinen Einfluß nach dem Datasheet. Zudem hatte ich das mit CE1 und CE2 
bereits ausprobiert.
1
/////////////////// Arduino UNO:
2
// Pin 1 = CLR
3
// Pin 2 = A0
4
// Pin 3 = A1
5
// Pin 4 = D0
6
// Pin 5 = D1
7
// Pin 6 = D2
8
// Pin 7 = D3
9
// Pin 8 = D4
10
// Pin 9 = D5
11
// Pin 10 = D6
12
// Pin 11 = WR
13
// Pin 12 = BL
14
// Pin 5V = VDD
15
// Pin GND = GND
16

17
int clr = 1;
18
int wr = 11;
19
int bl = 12;
20
byte a[2];
21
byte d[7];
22

23
/*
24
 * Init display
25
 */
26
void setup() {
27
  Serial.begin(9600);
28
  Serial.println("DISPLAY");
29

30
  // Reset RAM
31
  pinMode(clr, OUTPUT);
32
  digitalWrite(clr, 0);
33
  delay(100);
34
  digitalWrite(clr, 1);
35

36
  // Display Ascii
37
  pinMode(bl, OUTPUT);
38
  digitalWrite(bl, 1);
39

40
  // Do not set display
41
  pinMode(wr, OUTPUT);
42
  digitalWrite(wr, 1);
43

44
  // Init pins
45
  for(int i = 0 ;i < 2; i++)  {
46
    a[i] = i + 2;
47
    pinMode(a[i], OUTPUT);
48
    digitalWrite(a[i], 0);
49
  }
50

51
  for(int i = 0 ; i < 7; i++)  {
52
    d[i] = i + 4;
53
    pinMode(d[i], OUTPUT);
54
    digitalWrite(d[i], 0);
55
  }
56
}
57

58
/*
59
 * Run display
60
 */
61
void loop() {
62
  // Print A-D
63
  setDisplay(0x41, 0x42, 0x43, 0x44);
64
  delay(5000);
65

66
  // Print E-H
67
  setDisplay(0x45, 0x46, 0x47, 0x48);
68
  delay(5000);
69
}
70

71
/*
72
 * Display characters
73
 */
74
void setDisplay(byte c0, byte c1, byte c2, byte c3) {
75
  // From left
76
  setChar(0x0, c0);
77
  setChar(0x1, c1);
78
  setChar(0x2, c2);
79
  setChar(0x3, c3);
80
}
81

82
/*
83
 * Print a single character
84
 */
85
void setChar(byte pos, byte character) {
86
  //Serial.print(getBit(pos, 0));
87
  //Serial.print(" ");
88
  //Serial.println(getBit(pos, 1));
89

90
  digitalWrite(a[0], getBitAtPos(pos, 0));
91
  digitalWrite(a[1], getBitAtPos(pos, 1));
92
  delay(500);
93

94
  digitalWrite(wr,0);
95
  for(int i = 0; i < 7; i++) {
96
    //Serial.print(getBit(val, i));
97
    //Serial.print(" ");
98
    digitalWrite(d[i], getBitAtPos(character, i));
99
  }
100
  delay(5);
101
  digitalWrite(wr,1);
102
  delay(500);
103

104
  //Serial.println();
105
}
106

107
/*
108
 * Returns a bit from a value of a given index
109
 */
110
int getBitAtPos(byte val, int index) {
111
  return (val >> index) & 1;
112
}
113

114

115
Re: Arduino Uno & HDLx
116
  
117
Autor: google (Gast)
118
Datum: 25.01.2015 22:22
119

120
Wenn Du Deinen Code in Ordnung gebracht hast, (hast Du noch nicht) 
121
empfehle ich Dir die timing conventions auf Seite 6 des datasheets. Ist 
122
digitalWrite und ähnliches schnell genug? Hältst Du Reihenfolge und 
123
Zeiten ein?
124

125

126
Re: Arduino Uno & HDLx
127
  
128
Autor: Emanuel A. (reset2000)
129
Datum: 25.01.2015 22:33
130

131
Ich halte die Zustände ein, jedoch im Nanosekunden Bereich schalte ich 
132
nicht. Ich habe mit den Timings rumgespielt und sie verkürzt und 
133
verlängert. Jedoch mache ich alles in seinem Zeitschritt, wie ich meine. 
134
Ich habe das mit einem analogen Multimeter durchgespielt und angepeilt, 
135
wie lange es dauert bis ein Pin von High auf Low ist. Aber wie sicher 
136
oder genau das letztlich mit dem Multimeter ist, weiß ich nicht und was 
137
anderes habe ich nicht.
138

139

140
Re: Arduino Uno & HDLx
141
  
142
Autor: Emanuel A. (reset2000)
143
Datum: 25.01.2015 22:58
144

145
So hier nochmal bereinigt:
146

147

148
/////////////////// Arduino UNO:
149
// Pin 1 = CLR
150
// Pin 2 = A0
151
// Pin 3 = A1
152
// Pin 4 = D0
153
// Pin 5 = D1
154
// Pin 6 = D2
155
// Pin 7 = D3
156
// Pin 8 = D4
157
// Pin 9 = D5
158
// Pin 10 = D6
159
// Pin 11 = WR
160
// Pin 12 = BL
161
// Pin 5V = VDD
162
// Pin GND = GND
163

164
// Clear
165
int clr = 1;
166
// Write mode
167
int wr = 11;
168
// Display Blank
169
int bl = 12;
170
// Adress input
171
byte a[2];
172
// Data input
173
byte d[7];
174

175
/*
176
 * Init display
177
 */
178
void setup() {
179
  //Serial.begin(9600);
180
  //Serial.println("DISPLAY");
181

182
  // Reset RAM
183
  pinMode(clr, OUTPUT);
184
  digitalWrite(clr, 0);
185
  delay(100);
186
  digitalWrite(clr, 1);
187

188
  // Display Ascii Mode
189
  pinMode(bl, OUTPUT);
190
  digitalWrite(bl, 1);
191

192
  // Do not set to display mode (write to Character-Ram not allowed)
193
  pinMode(wr, OUTPUT);
194
  digitalWrite(wr, 1);
195

196
  // Init pins D0-D6
197
  for(int i = 0 ;i < 2; i++)  {
198
    a[i] = i + 2;
199
    pinMode(a[i], OUTPUT);
200
    digitalWrite(a[i], 0);
201
  }
202

203
  // Init pins A0-A2
204
  for(int i = 0 ; i < 7; i++)  {
205
    d[i] = i + 4;
206
    pinMode(d[i], OUTPUT);
207
    digitalWrite(d[i], 0);
208
  }
209
}
210

211
/*
212
 * Run display output and prints in the first step A-D on the screen
213
 * and after 5 sec the Characters E-H.
214
 */
215
void loop() {
216
  // Print A-D
217
  setDisplay(0x41, 0x42, 0x43, 0x44);
218
  delay(5000);
219

220
  // Print E-H
221
  setDisplay(0x45, 0x46, 0x47, 0x48);
222
  delay(5000);
223
}
224

225
/*
226
 * Displays 4 characters on the HDLx
227
 * @param c0 Character at position 1
228
 * @param c1 Character at position 2
229
 * @param c2 Character at position 3
230
 * @param c3 Character at position 4
231
 */
232
void setDisplay(byte c0, byte c1, byte c2, byte c3) {
233
  // From left
234
  setCharAt(0x0, c0);
235
  setCharAt(0x1, c1);
236
  setCharAt(0x2, c2);
237
  setCharAt(0x3, c3);
238
}
239

240
/*
241
 * Print a single character at the index position
242
 * @param pos Position of the display (Range 0-3)
243
 * @param character The character that is displayed on the HDLx at a 
244
given position
245
 */
246
void setCharAt(byte pos, byte character) {
247
  //Serial.print(getBitAtPos(pos, 0));
248
  //Serial.print(" ");
249
  //Serial.println(getBitAtPos(pos, 1));
250

251
  // Set character position
252
  digitalWrite(a[0], getBitAtPos(pos, 0));
253
  digitalWrite(a[1], getBitAtPos(pos, 1));
254
  delay(500);
255

256
  // Set to displays write mode
257
  digitalWrite(wr,0);
258
  // Set the character to the Character-RAM
259
  for(int i = 0; i < 7; i++) {
260
    //Serial.print(getBitAtPos(val, i));
261
    //Serial.print(" ");
262
    digitalWrite(d[i], getBitAtPos(character, i));
263
  }
264
  delay(5);
265
  // Set Character-RAM to the display
266
  digitalWrite(wr,1);
267
  delay(500);
268

269
  //Serial.println();
270
}
271

272
/*
273
 * Returns a bit from a value of a given index.
274
 * @param character displayed character.
275
 * @param index Index position of the bit (Range 0-7)
276
 */
277
int getBitAtPos(byte character, int index) {
278
  return (character >> index) & 1;
279
}
Gast #3984735
Lesenswert?

Also das Display ist nicht kaputt und funkt jetzt.
Der Fehler war, dass man C1, C2 und CUE auf Ground legen muß. Ich dachte 
ich kann die einfach unbeschaltet lassen.

Hier der funktionierende Code:
1
/////////////////// Arduino UNO:
2
// Arduino = HDLx
3
// Pin 1 = CLR
4
// Pin 2 = A0
5
// Pin 3 = A1
6
// Pin 4 = D0
7
// Pin 5 = D1
8
// Pin 6 = D2
9
// Pin 7 = D3
10
// Pin 8 = D4
11
// Pin 9 = D5
12
// Pin 10 = D6
13
// Pin 11 = WR
14
// Pin 12 = BL
15
// Pin 5V = VDD
16
// Pin 5V = CU
17
// Pin GND = GND
18
// Pin C1 = GND
19
// Pin C2 = GND
20
// Pin CUE = GND
21

22
// Clear
23
int clr = 1;
24
// Write mode
25
int wr = 11;
26
// Display Blank
27
int bl = 12;
28
// Adress input
29
byte a[2]; 
30
// Data input
31
byte d[7]; 
32

33
/*
34
 * Init display
35
 */
36
void setup() {   
37
  //Serial.begin(9600);  
38
  //Serial.println("DISPLAY");
39
  
40
  // Reset RAM
41
  pinMode(clr, OUTPUT); 
42
  digitalWrite(clr, 0);
43
  delay(100);
44
  digitalWrite(clr, 1); 
45
  
46
  // Display Ascii Mode
47
  pinMode(bl, OUTPUT); 
48
  digitalWrite(bl, 1); 
49
  
50
  // Do not set to display mode (write to Character-Ram not allowed) 
51
  pinMode(wr, OUTPUT); 
52
  digitalWrite(wr, 1); 
53

54
  // Init pins D0-D6
55
  for(int i = 0 ;i < 2; i++)  {
56
    a[i] = i + 2;
57
    pinMode(a[i], OUTPUT);
58
    digitalWrite(a[i], 0); 
59
  } 
60

61
  // Init pins A0-A2  
62
  for(int i = 0 ; i < 7; i++)  {
63
    d[i] = i + 4;
64
    pinMode(d[i], OUTPUT); 
65
    digitalWrite(d[i], 0); 
66
  }
67
  delay(10);
68
}
69

70
/*
71
 * Run display output and prints in the first step A-D on the screen 
72
 * and after 5 sec the Characters E-H.
73
 */
74
void loop() {
75
  // Print A-D 
76
  setDisplay(0x41, 0x42, 0x43, 0x44);  
77
  delay(5000);
78

79
  // Print E-H 
80
  setDisplay(0x45, 0x46, 0x47, 0x48);
81
  delay(5000);
82
}
83

84
/*
85
 * Displays 4 characters on the HDLx
86
 * @param c3 Character at position 1 
87
 * @param c2 Character at position 2
88
 * @param c1 Character at position 3
89
 * @param c0 Character at position 4
90
 */
91
void setDisplay(byte c0, byte c1, byte c2, byte c3) {
92
  // Clean the display
93
  //digitalWrite(clr,0);
94
  //delay(1);
95
  //digitalWrite(clr,1);
96
  
97
  // From left
98
  setCharAt(0x3, c0);
99
  setCharAt(0x2, c1);
100
  setCharAt(0x1, c2);
101
  setCharAt(0x0, c3);
102
}
103

104
/*
105
 * Print a single character at the index position 
106
 * @param pos Position of the display (Range 0-3)
107
 * @param character The character that is displayed on the HDLx at a given position
108
 */
109
void setCharAt(byte pos, byte character) {
110
  // Set character position
111
  digitalWrite(a[0], getBitAtPos(pos, 0)); 
112
  digitalWrite(a[1], getBitAtPos(pos, 1));
113
  
114
  // Set to displays write mode
115
  digitalWrite(wr,0);
116
  
117
  // Set the character to the Character-RAM
118
  for(int i = 0; i < 7; i++) {
119
    digitalWrite(d[i], getBitAtPos(character, i)); 
120
  }
121
  
122
  // Set Character-RAM to the display
123
  digitalWrite(wr,1); 
124
}
125

126
/*
127
 * Returns a bit from a value of a given index.
128
 * @param character displayed character.
129
 * @param index Index position of the bit (Range 0-7)
130
 */
131
int getBitAtPos(byte character, int index) {
132
  return (character >> index) & 1;
133
}

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren