Forum: Mikrocontroller und Digitale Elektronik Konflikt zwischen TWI Bus und t6963


Konflikt zwischen TWI Bus und t6963
von Patrick P. (Gast)

Lesenswert?
• ▲
▼ 
Guten Tag!
Ich habe folgendes Problem, an dem ich schon seit Tagen arbeite:
Bei meinem derzeitigen Projekt, versuche ich mittels TWI Bus einen DAC 
Wandler anzusteuern, was auch problemlos funktioniert.
Nun möchte ich ein Grafikdisplay zusätzlich benutzen zur Darstellung von 
Grafiken. Hier habe ich ein Display mit t6963 Controller genommen.

Nun scheint es einen Konflikt zwischen dem TWI und dem Display zu geben. 
Vor der Initialisierung des TWI Bus kann ich auf das Display schreiben, 
dann nicht mehr. Wenn ich vor der TWI Bus initialisierung zb einen Text 
schreibe und dann die Twi Routine startet, verändert sich zufällig der 
Text am Display. Anscheinend beeinflusst der TWI Bus irgendwie das 
Display.

TWI Pins: P0 P1
Grafikdisplay: Port A Port B
Verwendeter Controller: ATMEGA 128 prog im AVR Studio

Display initialisierung:
GLCD_Initalize();
GLCD_ClearText(); // Clear text area
GLCD_ClearCG(); // Clear character generator area
GLCD_ClearGraphic(); // Clear graphic area



Initialisiert wird der TWI Bus folgendermaßen:
TWSR = (0<<TWPS1)|(1<<TWPS0); //prescaler bits 1
TWBR = 0x12;                  //Prescaler Bits 2



Die t6963.h Datei:
1
include <inttypes.h>

2
#include <avr/io.h>

3
#include <avr/pgmspace.h>

4
#include <util/delay.h>

5
6
// data port

7
#define GLCD_DATA_PORT   PORTC

8
#define GLCD_DATA_PIN  PINC

9
#define GLCD_DATA_DDR  DDRC

10
// control port

11
#define GLCD_CTRL_PORT  PORTA

12
#define GLCD_CTRL_PIN  PINA

13
#define GLCD_CTRL_DDR  DDRA

14
// control signals

15
#define GLCD_WR      PA5

16
#define GLCD_RD      PA6

17
#define GLCD_CE      PA4

18
#define GLCD_CD      PA7

19
#define GLCD_RESET    PA3

20
#define GLCD_FS      PA1

21
// display properties

22
#define GLCD_NUMBER_OF_LINES        128

23
#define GLCD_PIXELS_PER_LINE        240

24
#define GLCD_FONT_WIDTH            8

25
//

26
#define GLCD_GRAPHIC_AREA          (GLCD_PIXELS_PER_LINE / GLCD_FONT_WIDTH)

27
#define GLCD_TEXT_AREA            (GLCD_PIXELS_PER_LINE / GLCD_FONT_WIDTH)

28
#define GLCD_GRAPHIC_SIZE          (GLCD_GRAPHIC_AREA * GLCD_NUMBER_OF_LINES)

29
#define GLCD_TEXT_SIZE            (GLCD_TEXT_AREA * (GLCD_NUMBER_OF_LINES/8))

30
31
32
#define GLCD_TEXT_HOME            0

33
#define GLCD_GRAPHIC_HOME          (GLCD_TEXT_HOME + GLCD_TEXT_SIZE)

34
#define GLCD_OFFSET_REGISTER        2

35
#define GLCD_EXTERNAL_CG_HOME        (GLCD_OFFSET_REGISTER << 11)

36
37
38
#define T6963_SET_CURSOR_POINTER      0x21

39
#define T6963_SET_OFFSET_REGISTER      0x22

40
#define T6963_SET_ADDRESS_POINTER      0x24

41
42
#define T6963_SET_TEXT_HOME_ADDRESS      0x40

43
#define T6963_SET_TEXT_AREA          0x41

44
#define T6963_SET_GRAPHIC_HOME_ADDRESS    0x42

45
#define T6963_SET_GRAPHIC_AREA        0x43

46
47
#define T6963_MODE_SET            0x80

48
49
50
#define T6963_DISPLAY_MODE          0x90

51
  #define T6963_CURSOR_BLINK_ON      0x01

52
  #define T6963_CURSOR_DISPLAY_ON      0x02

53
  #define T6963_TEXT_DISPLAY_ON      0x04

54
  #define T6963_GRAPHIC_DISPLAY_ON    0x08        

55
56
57
#define T6963_CURSOR_PATTERN_SELECT      0xA0

58
  #define T6963_CURSOR_1_LINE        0x00

59
  #define T6963_CURSOR_2_LINE        0x01

60
  #define T6963_CURSOR_3_LINE        0x02

61
  #define T6963_CURSOR_4_LINE        0x03

62
  #define T6963_CURSOR_5_LINE        0x04

63
  #define T6963_CURSOR_6_LINE        0x05

64
  #define T6963_CURSOR_7_LINE        0x06

65
  #define T6963_CURSOR_8_LINE        0x07

66
67
#define T6963_SET_DATA_AUTO_WRITE      0xB0

68
#define T6963_SET_DATA_AUTO_READ      0xB1

69
#define T6963_AUTO_RESET          0xB2

70
71
#define T6963_DATA_WRITE_AND_INCREMENT    0xC0

72
#define T6963_DATA_READ_AND_INCREMENT    0xC1

73
#define T6963_DATA_WRITE_AND_DECREMENT    0xC2

74
#define T6963_DATA_READ_AND_DECREMENT    0xC3

75
#define T6963_DATA_WRITE_AND_NONVARIALBE  0xC4

76
#define T6963_DATA_READ_AND_NONVARIABLE    0xC5

77
78
#define T6963_SCREEN_PEEK          0xE0

79
#define T6963_SCREEN_COPY          0xE8

80
81
82
void GLCD_InitalizeInterface(void);

83
unsigned char GLCD_ChceckStatus(void);

84
void GLCD_WriteCommand(unsigned char);

85
void GLCD_WriteData(unsigned char);

86
unsigned char GLCD_ReadData(void);

87
void GLCD_ClearText(void);

88
void GLCD_ClearCG(void);

89
void GLCD_ClearGraphic(void);

90
void GLCD_WriteChar(char ch);

91
void GLCD_WriteString(char * str);

92
void GLCD_WriteStringPgm(prog_char * str);

93
void GLCD_TextGoTo(unsigned char, unsigned char);

94
void GLCD_DefineCharacter(unsigned char, unsigned char *);

95
void GLCD_Initalize(void);

96
void GLCD_SetPixel(unsigned char, unsigned char, unsigned char);

97
void GLCD_WriteDisplayData(unsigned char);



Die t6963.c Datei:

1
#include "T6963C.h"

2
//-------------------------------------------------------------------------------------------------

3
//

4
// Delay function

5
//  

6
//-------------------------------------------------------------------------------------------------

7
void delay(void)

8
{

9
volatile unsigned char i;

10
for(i = 0; i < (16000000/1000000); i++)

11
  {

12
  asm("nop");

13
  }

14
}

15
//-------------------------------------------------------------------------------------------------

16
//

17
// Ports intalization

18
//

19
//-------------------------------------------------------------------------------------------------

20
void GLCD_InitalizeInterface(void)

21
{

22
GLCD_DATA_DDR = 0xFF;

23
GLCD_CTRL_DDR = ((1 << GLCD_WR) | (1 << GLCD_RD) | (1 << GLCD_CE) | (1 << GLCD_CD) | (1 << GLCD_RESET) | (1 << GLCD_FS));

24
GLCD_CTRL_PORT |= ((1 << GLCD_WR) | (1 << GLCD_RD) | (1 << GLCD_CE) | (1 << GLCD_CD) | (1 << GLCD_RESET) | (1 << GLCD_FS));

25
}

26
//-------------------------------------------------------------------------------------------------

27
//

28
// Reads dispay status

29
//

30
//-------------------------------------------------------------------------------------------------

31
unsigned char GLCD_ChceckStatus(void)

32
{

33
uint8_t tmp;

34
GLCD_DATA_DDR = 0x00;

35
36
GLCD_CTRL_PORT &= ~((1 << GLCD_RD) | (1 << GLCD_CE));

37
delay();

38
tmp = GLCD_DATA_PIN;

39
GLCD_DATA_DDR = 0xFF;

40
GLCD_CTRL_PORT |= ((1 << GLCD_RD) | (1 << GLCD_CE));

41
return tmp;

42
}

43
//-------------------------------------------------------------------------------------------------

44
//

45
// Writes instruction 

46
//

47
//-------------------------------------------------------------------------------------------------

48
void GLCD_WriteCommand(unsigned char command)

49
{

50
while(!(GLCD_ChceckStatus()&0x03));

51
GLCD_DATA_PORT = command;

52
53
GLCD_CTRL_PORT &= ~((1 << GLCD_WR) | (1 << GLCD_CE));

54
delay();

55
GLCD_CTRL_PORT |= ((1 << GLCD_WR) | (1 << GLCD_CE));

56
}

57
58
//-------------------------------------------------------------------------------------------------

59
//

60
// Writes data

61
//

62
//-------------------------------------------------------------------------------------------------

63
void GLCD_WriteData(unsigned char data)

64
{

65
while(!(GLCD_ChceckStatus()&0x03));

66
GLCD_DATA_PORT = data;

67
68
GLCD_CTRL_PORT &= ~((1 << GLCD_WR) | (1 << GLCD_CE) | (1 << GLCD_CD));

69
delay();

70
GLCD_CTRL_PORT |= ((1 << GLCD_WR) | (1 << GLCD_CE) | (1 << GLCD_CD));

71
}

72
//-------------------------------------------------------------------------------------------------

73
//

74
// Reads data

75
//

76
//-------------------------------------------------------------------------------------------------

77
unsigned char GLCD_ReadData(void)

78
{

79
uint8_t tmp;

80
while(!(GLCD_ChceckStatus()&0x03));

81
GLCD_DATA_DDR = 0x00;

82
83
GLCD_CTRL_PORT &= ~((1 << GLCD_RD) | (1 << GLCD_CE) | (1 << GLCD_CD));

84
delay();

85
tmp = GLCD_DATA_PIN;

86
GLCD_CTRL_PORT |= ((1 << GLCD_RD) | (1 << GLCD_CE) | (1 << GLCD_CD));

87
GLCD_DATA_DDR = 0xFF;

88
return tmp;

89
}

90
//-------------------------------------------------------------------------------------------------

91
//

92
// Sets address pointer for display RAM memory

93
//

94
//-------------------------------------------------------------------------------------------------

95
void GLCD_SetAddressPointer(unsigned int address)

96
{

97
GLCD_WriteData(address & 0xFF);

98
GLCD_WriteData(address >> 8);

99
GLCD_WriteCommand(T6963_SET_ADDRESS_POINTER);

100
}

101
//-------------------------------------------------------------------------------------------------

102
//

103
// Clears text area of display RAM memory

104
//

105
//-------------------------------------------------------------------------------------------------

106
void GLCD_ClearText(void)

107
{

108
int i;

109
GLCD_SetAddressPointer(GLCD_TEXT_HOME);

110
111
for(i = 0; i < GLCD_TEXT_SIZE; i++)

112
  {

113
  GLCD_WriteDisplayData(0);

114
  }

115
}

116
//-------------------------------------------------------------------------------------------------

117
//

118
// Clears characters generator area of display RAM memory

119
//

120
//-------------------------------------------------------------------------------------------------

121
void GLCD_ClearCG(void)

122
{

123
unsigned int i;

124
GLCD_SetAddressPointer(GLCD_EXTERNAL_CG_HOME);

125
126
for(i = 0; i < 256 * 8; i++)

127
  {

128
  GLCD_WriteDisplayData(0);

129
  }

130
}

131
//-------------------------------------------------------------------------------------------------

132
//

133
// Clears graphics area of display RAM memory

134
//

135
//-------------------------------------------------------------------------------------------------

136
void GLCD_ClearGraphic(void)

137
{

138
int i;

139
GLCD_SetAddressPointer(GLCD_GRAPHIC_HOME);

140
for(i = 0; i < GLCD_GRAPHIC_SIZE; i++)

141
  {

142
  GLCD_WriteDisplayData(0x00);

143
  }

144
}

145
//-------------------------------------------------------------------------------------------------

146
//

147
// Writes a single character (ASCII code) to display RAM memory

148
//

149
//-------------------------------------------------------------------------------------------------

150
void GLCD_WriteChar(char charCode)

151
{

152
GLCD_WriteDisplayData(charCode - 32);

153
}

154
//-------------------------------------------------------------------------------------------------

155
//

156
// Writes null-terminated string to display RAM memory

157
//

158
//-------------------------------------------------------------------------------------------------

159
void GLCD_WriteString(char * string)

160
{

161
while(*string)

162
  {

163
  GLCD_WriteChar(*string++);

164
  }

165
}

166
//-------------------------------------------------------------------------------------------------

167
//

168
// Writes null-terminated string from program memory to display RAM memory

169
//

170
//-------------------------------------------------------------------------------------------------

171
void GLCD_WriteStringPgm(prog_char * string)

172
{

173
char ch;

174
while((ch = pgm_read_byte(string++)))

175
  {

176
  GLCD_WriteChar(ch);

177
  }

178
}

179
//-------------------------------------------------------------------------------------------------

180
//

181
// Sets display coordinates

182
//

183
//-------------------------------------------------------------------------------------------------

184
void GLCD_TextGoTo(unsigned char x, unsigned char y)

185
{

186
unsigned int address;

187
188
address = GLCD_TEXT_HOME +  x + (GLCD_TEXT_AREA * y);

189
190
GLCD_SetAddressPointer(address);

191
}

192
//-------------------------------------------------------------------------------------------------

193
//

194
// Writes single char pattern to character generator area of display RAM memory

195
//

196
//-------------------------------------------------------------------------------------------------

197
void GLCD_DefineCharacter(unsigned char charCode, unsigned char * defChar)

198
{

199
unsigned int address;

200
unsigned char i; 

201
202
address = GLCD_EXTERNAL_CG_HOME + (8 * charCode);

203
204
GLCD_SetAddressPointer(address);

205
206
for(i = 0; i < 8 ; i++)

207
  {

208
  GLCD_WriteDisplayData(*(defChar + i));

209
  }

210
}

211
212
//-------------------------------------------------------------------------------------------------

213
//

214
// Set (if color==1) or clear (if color==0) pixel on screen

215
//

216
//-------------------------------------------------------------------------------------------------

217
void GLCD_SetPixel(unsigned char x, unsigned char y, unsigned char color)

218
{

219
unsigned char tmp;

220
unsigned int address;

221
222
address = GLCD_GRAPHIC_HOME + (x / GLCD_FONT_WIDTH) + (GLCD_GRAPHIC_AREA * y);

223
224
GLCD_SetAddressPointer(address);

225
226
GLCD_WriteCommand(T6963_DATA_READ_AND_NONVARIABLE);

227
tmp = GLCD_ReadData();

228
229
if(color)

230
  tmp |= (1 <<  (GLCD_FONT_WIDTH - 1 - (x % GLCD_FONT_WIDTH)));

231
else

232
 tmp &= ~(1 <<  (GLCD_FONT_WIDTH - 1 - (x % GLCD_FONT_WIDTH)));

233
234
GLCD_WriteDisplayData(tmp);

235
236
}

237
//-------------------------------------------------------------------------------------------------

238
//

239
// Writes display data and increment address pointer

240
//

241
//-------------------------------------------------------------------------------------------------

242
void GLCD_WriteDisplayData(unsigned char x)

243
{

244
GLCD_WriteData(x);

245
GLCD_WriteCommand(T6963_DATA_WRITE_AND_INCREMENT);

246
}

247
//-------------------------------------------------------------------------------------------------

248
//

249
// Sets graphics coordinates

250
//

251
//-------------------------------------------------------------------------------------------------

252
void GLCD_GraphicGoTo(unsigned char x, unsigned char y)

253
{

254
unsigned int address;

255
address = GLCD_GRAPHIC_HOME + (x / GLCD_FONT_WIDTH) + (GLCD_GRAPHIC_AREA * y);

256
GLCD_SetAddressPointer(address);

257
}

258
//-------------------------------------------------------------------------------------------------

259
//

260
// Displays bitmap from program memory

261
//

262
//-------------------------------------------------------------------------------------------------

263
void GLCD_Bitmap(unsigned char * bitmap, unsigned char x, unsigned char y, unsigned char width, unsigned char height)

264
{

265
unsigned char i, j;

266
267
for(j = 0; j < height; j++)

268
{

269
GLCD_GraphicGoTo(x, y + j);

270
for(i = 0; i < width/GLCD_FONT_WIDTH; i++)

271
  {

272
  GLCD_WriteDisplayData(pgm_read_byte(bitmap + i + (GLCD_GRAPHIC_AREA * j)));   

273
  }

274
}

275
}

276
//-------------------------------------------------------------------------------------------------

277
//

278
// Display initalization

279
//

280
//-------------------------------------------------------------------------------------------------

281
void GLCD_Initalize(void)

282
{

283
GLCD_InitalizeInterface();

284
285
GLCD_CTRL_PORT &= ~(1 << GLCD_RESET);

286
_delay_ms(1);

287
GLCD_CTRL_PORT |= (1 << GLCD_RESET);

288
289
#if (GLCD_FONT_WIDTH == 8)

290
GLCD_CTRL_PORT &= ~(1 << GLCD_FS);

291
#endif

292
293
GLCD_WriteData(GLCD_GRAPHIC_HOME & 0xFF);

294
GLCD_WriteData(GLCD_GRAPHIC_HOME >> 8);

295
GLCD_WriteCommand(T6963_SET_GRAPHIC_HOME_ADDRESS);

296
297
GLCD_WriteData(GLCD_GRAPHIC_AREA);

298
GLCD_WriteData(0x00);

299
GLCD_WriteCommand(T6963_SET_GRAPHIC_AREA);

300
301
GLCD_WriteData(GLCD_TEXT_HOME);

302
GLCD_WriteData(GLCD_TEXT_HOME >> 8);

303
GLCD_WriteCommand(T6963_SET_TEXT_HOME_ADDRESS);

304
305
GLCD_WriteData(GLCD_TEXT_AREA);

306
GLCD_WriteData(0x00);

307
GLCD_WriteCommand(T6963_SET_TEXT_AREA);

308
309
GLCD_WriteData(GLCD_OFFSET_REGISTER);

310
GLCD_WriteData(0x00);

311
GLCD_WriteCommand(T6963_SET_OFFSET_REGISTER);

312
313
GLCD_WriteCommand(T6963_DISPLAY_MODE  | T6963_GRAPHIC_DISPLAY_ON   | T6963_TEXT_DISPLAY_ON /*| T6963_CURSOR_DISPLAY_ON*/);

314
315
GLCD_WriteCommand(T6963_MODE_SET | 0);

316
317
}


  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Konflikt zwischen TWI Bus und t6963
  


  

    

      von
      
        Gruenschnabel (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
>include <inttypes.h>

Hier ist der Fehler!
Wo ist der Wald?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Konflikt zwischen TWI Bus und t6963
  


  

    

      von
      
        Patrick P. (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
das rautezeichen ist beim kopieren verloren gegangen, es funktioniert 
leider noch immer nicht... aber danke für die erste schnelle antwort =)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Konflikt zwischen TWI Bus und t6963
  


  

    

      von
      
        Patrick P. (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
UPDATE:

Folgende Abfolge ist möglich:

1 Display starten und beschreiben
2 TWI starten - Display nicht beschreibbar
3 TWI stoppen mittels TWEN Register
4 Display wieder initialisieren und dann beschreibbar
5 TWI leider nicht mehr Startbar

Durch einen geschickten Programmaufbau bin ich den Konflik aus dem weg 
gegangen, was leider mit Einschränkungen verbunden ist.....

Danke an alle die sich die Mühe gemacht haben den Post durchzulesen!

bin noch immer für bessere Lösungsvorschläge offen =)

lg

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.