MSP430F5529硬件IIC驱动IIC接口的OLED源码

1. //******************************************************************************
   
2. //   MSP430F552x Demo - USCI_B0, I2C Master multiple byte TX/RX
   
3. //
   
4. //   Description: I2C master communicates to I2C slave sending and receiving
   
5. //   3 different messages of different length. I2C master will enter LPM0 mode
   
6. //   while waiting for the messages to be sent/receiving using I2C interrupt.
   
7. //   ACLK = NA, MCLK = SMCLK = DCO 16MHz.
   
8. //
   
9. //                                     /|\ /|\
   
10. //                   MSP430F5529       4.7k |
    
11. //                 -----------------    |  4.7k
    
12. //            /|\ |             P3.1|---+---|-- I2C Clock (UCB0SCL)
    
13. //             |  |                 |       |
    
14. //             ---|RST          P3.0|-------+-- I2C Data (UCB0SDA)
    
15. //                |                 |
    
16. //                |                 |
    
17. //                |                 |
    
18. //                |                 |
    
19. //                |                 |
    
20. //                |                 |
    
21. //
    
22. //   Nima Eskandari
    
23. //   Texas Instruments Inc.
    
24. //   April 2017
    
25. //   Built with CCS V7.0
    
26. //******************************************************************************
    
27. 
    
28. #include <msp430.h>
    
29. #include <stdint.h>
    
30. #include <stdbool.h>
    
31. #include "oledfont.h"
    
32. 
    
33. //******************************************************************************
    
34. // Example Commands ************************************************************
    
35. //******************************************************************************
    
36. #define X_WIDTH         128
    
37. #define Y_WIDTH         64
    
38. #define OLED_CMD  0        //写命令
    
39. #define OLED_DATA 1        //写数据
    
40. #define SLAVE_ADDR  0x3C
    
41. 
    
42. /* CMD_TYPE_X_SLAVE are example commands the master sends to the slave.
    
43. * The slave will send example SlaveTypeX buffers in response.
    
44. *
    
45. * CMD_TYPE_X_MASTER are example commands the master sends to the slave.
    
46. * The slave will initialize itself to receive MasterTypeX example buffers.
    
47. * */
    
48. 
    
49. #define CMD_TYPE_0_SLAVE      0
    
50. #define CMD_TYPE_1_SLAVE      1
    
51. #define CMD_TYPE_2_SLAVE      2
    
52. 
    
53. #define CMD_TYPE_0_MASTER      3
    
54. #define CMD_TYPE_1_MASTER      4
    
55. #define CMD_TYPE_2_MASTER      5
    
56. 
    
57. #define TYPE_0_LENGTH   1
    
58. #define TYPE_1_LENGTH   2
    
59. #define TYPE_2_LENGTH   6
    
60. 
    
61. #define MAX_BUFFER_SIZE     20
    
62. 
    
63. /* MasterTypeX are example buffers initialized in the master, they will be
    
64. * sent by the master to the slave.
    
65. * SlaveTypeX are example buffers initialized in the slave, they will be
    
66. * sent by the slave to the master.
    
67. * */
    
68. 
    
69. uint8_t MasterType2 [TYPE_2_LENGTH] = {'F', '4', '1', '9', '2', 'B'};
    
70. uint8_t MasterType1 [28] = {0xae,0x00,0x10,0x40,0x81,0xcf,0xa1,0xc8,0xa6,0xa8,0x3f,0xd3,0x00,0xd5,0x80,0xd9,0xf1,0xda,0x12,0xdb,0x40,0x20,0x02,0x8d,0x14,0xa4,0xa6,0xaf};
    
71. uint8_t MasterType0 [1] = {0};
    
72. 
    
73. 
    
74. uint8_t SlaveType2 [TYPE_2_LENGTH] = {0};
    
75. uint8_t SlaveType1 [TYPE_1_LENGTH] = {0};
    
76. uint8_t SlaveType0 [TYPE_0_LENGTH] = {0};
    
77. 
    
78. void delay(unsigned int z)
    
79. {
    
80.   unsigned int x,y;
    
81.   for(x=z;x>0;x--)
    
82.     for(y=5000;y>0;y--);
    
83. }
    
84. 
    
85. //******************************************************************************
    
86. // General I2C State Machine ***************************************************
    
87. //******************************************************************************
    
88. 
    
89. typedef enum I2C_ModeEnum{
    
90.     IDLE_MODE,
    
91.     NACK_MODE,
    
92.     TX_REG_ADDRESS_MODE,
    
93.     RX_REG_ADDRESS_MODE,
    
94.     TX_DATA_MODE,
    
95.     RX_DATA_MODE,
    
96.     SWITCH_TO_RX_MODE,
    
97.     SWITHC_TO_TX_MODE,
    
98.     TIMEOUT_MODE
    
99. } I2C_Mode;
    
100. 
     
101. /* Used to track the state of the software state machine*/
     
102. I2C_Mode MasterMode = IDLE_MODE;
     
103. 
     
104. /* The Register Address/Command to use*/
     
105. uint8_t TransmitRegAddr = 0;
     
106. 
     
107. /* ReceiveBuffer: Buffer used to receive data in the ISR
     
108. * RXByteCtr: Number of bytes left to receive
     
109. * ReceiveIndex: The index of the next byte to be received in ReceiveBuffer
     
110. * TransmitBuffer: Buffer used to transmit data in the ISR
     
111. * TXByteCtr: Number of bytes left to transfer
     
112. * TransmitIndex: The index of the next byte to be transmitted in TransmitBuffer
     
113. * */
     
114. uint8_t ReceiveBuffer[MAX_BUFFER_SIZE] = {0};
     
115. uint8_t RXByteCtr = 0;
     
116. uint8_t ReceiveIndex = 0;
     
117. uint8_t TransmitBuffer[MAX_BUFFER_SIZE] = {0};
     
118. uint8_t TXByteCtr = 0;
     
119. uint8_t TransmitIndex = 0;
     
120. 
     
121. /* I2C Write and Read Functions */
     
122. 
     
123. /* For slave device with dev_addr, writes the data specified in *reg_data
     
124. *
     
125. * dev_addr: The slave device address.
     
126. *           Example: SLAVE_ADDR
     
127. * reg_addr: The register or command to send to the slave.
     
128. *           Example: CMD_TYPE_0_MASTER
     
129. * *reg_data: The buffer to write
     
130. *           Example: MasterType0
     
131. * count: The length of *reg_data
     
132. *           Example: TYPE_0_LENGTH
     
133. *  */
     
134. I2C_Mode I2C_Master_WriteReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t *reg_data, uint8_t count);
     
135. 
     
136. /* For slave device with dev_addr, read the data specified in slaves reg_addr.
     
137. * The received data is available in ReceiveBuffer
     
138. *
     
139. * dev_addr: The slave device address.
     
140. *           Example: SLAVE_ADDR
     
141. * reg_addr: The register or command to send to the slave.
     
142. *           Example: CMD_TYPE_0_SLAVE
     
143. * count: The length of data to read
     
144. *           Example: TYPE_0_LENGTH
     
145. *  */
     
146. I2C_Mode I2C_Master_ReadReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t count);
     
147. void CopyArray(uint8_t *source, uint8_t *dest, uint8_t count);
     
148. 
     
149. I2C_Mode I2C_Master_ReadReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t count)
     
150. {
     
151.     /* Initialize state machine */
     
152.     MasterMode = TX_REG_ADDRESS_MODE;
     
153.     TransmitRegAddr = reg_addr;
     
154.     RXByteCtr = count;
     
155.     TXByteCtr = 0;
     
156.     ReceiveIndex = 0;
     
157.     TransmitIndex = 0;
     
158. 
     
159.     /* Initialize slave address and interrupts */
     
160.     UCB0I2CSA = dev_addr;
     
161.     UCB0IFG &= ~(UCTXIFG + UCRXIFG);       // Clear any pending interrupts
     
162.     UCB0IE &= ~UCRXIE;                       // Disable RX interrupt
     
163.     UCB0IE |= UCTXIE;                        // Enable TX interrupt
     
164. 
     
165.     UCB0CTL1 |= UCTR + UCTXSTT;             // I2C TX, start condition
     
166.     __bis_SR_register(LPM0_bits + GIE);              // Enter LPM0 w/ interrupts
     
167. 
     
168.     return MasterMode;
     
169. 
     
170. }
     
171. 
     
172. 
     
173. I2C_Mode I2C_Master_WriteReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t *reg_data, uint8_t count)
     
174. {
     
175.     /* Initialize state machine */
     
176.     MasterMode = TX_REG_ADDRESS_MODE;
     
177.     TransmitRegAddr = reg_addr;
     
178. 
     
179.     //Copy register data to TransmitBuffer
     
180.     CopyArray(reg_data, TransmitBuffer, count);
     
181. 
     
182.     TXByteCtr = count;
     
183.     RXByteCtr = 0;
     
184.     ReceiveIndex = 0;
     
185.     TransmitIndex = 0;
     
186. 
     
187.     /* Initialize slave address and interrupts */
     
188.     UCB0I2CSA = dev_addr;
     
189.     UCB0IFG &= ~(UCTXIFG + UCRXIFG);       // Clear any pending interrupts
     
190.     UCB0IE &= ~UCRXIE;                       // Disable RX interrupt
     
191.     UCB0IE |= UCTXIE;                        // Enable TX interrupt
     
192. 
     
193.     UCB0CTL1 |= UCTR + UCTXSTT;             // I2C TX, start condition
     
194.     __bis_SR_register(LPM0_bits + GIE);              // Enter LPM0 w/ interrupts
     
195. 
     
196.     return MasterMode;
     
197. }
     
198. 
     
199. void CopyArray(uint8_t *source, uint8_t *dest, uint8_t count)
     
200. {
     
201.     uint8_t copyIndex = 0;
     
202.     for (copyIndex = 0; copyIndex < count; copyIndex++)
     
203.     {
     
204.         dest[copyIndex] = source[copyIndex];
     
205.     }
     
206. }
     
207. 
     
208. //******************************************************************************
     
209. // Device Initialization *******************************************************
     
210. //******************************************************************************
     
211. 
     
212. void initClockTo16MHz()
     
213. {
     
214.     UCSCTL3 |= SELREF_2;                      // Set DCO FLL reference = REFO
     
215.     UCSCTL4 |= SELA_2;                        // Set ACLK = REFO
     
216.     __bis_SR_register(SCG0);                  // Disable the FLL control loop
     
217.     UCSCTL0 = 0x0000;                         // Set lowest possible DCOx, MODx
     
218.     UCSCTL1 = DCORSEL_5;                      // Select DCO range 16MHz operation
     
219.     UCSCTL2 = FLLD_0 + 487;                   // Set DCO Multiplier for 16MHz
     
220.                                               // (N + 1) * FLLRef = Fdco
     
221.                                               // (487 + 1) * 32768 = 16MHz
     
222.                                               // Set FLL Div = fDCOCLK
     
223.     __bic_SR_register(SCG0);                  // Enable the FLL control loop
     
224. 
     
225.     // Worst-case settling time for the DCO when the DCO range bits have been
     
226.     // changed is n x 32 x 32 x f_MCLK / f_FLL_reference. See UCS chapter in 5xx
     
227.     // UG for optimization.
     
228.     // 32 x 32 x 16 MHz / 32,768 Hz = 500000 = MCLK cycles for DCO to settle
     
229.     __delay_cycles(500000);//
     
230.     // Loop until XT1,XT2 & DCO fault flag is cleared
     
231.     do
     
232.     {
     
233.         UCSCTL7 &= ~(XT2OFFG + XT1LFOFFG + DCOFFG); // Clear XT2,XT1,DCO fault flags
     
234.         SFRIFG1 &= ~OFIFG;                          // Clear fault flags
     
235.     }while (SFRIFG1&OFIFG);                         // Test oscillator fault flag
     
236. }
     
237. 
     
238. 
     
239. void initGPIO()
     
240. {
     
241.     //I2C Pins
     
242.     P3SEL |= BIT0 + BIT1;                     // P3.0,1 option select
     
243. 
     
244. }
     
245. 
     
246. void initI2C()
     
247. {
     
248.     UCB0CTL1 |= UCSWRST;                      // Enable SW reset(复位使能)
     
249.     UCB0CTL0 = UCMST + UCMODE_3 + UCSYNC;     //  Master, I2C,synchronous mode(同步模式)
     
250.     UCB0CTL1 = UCSSEL_2 + UCSWRST;            // Use SMCLK, keep SW reset
     
251.     UCB0BR0 = 160;                            // fSCL = SMCLK/160 = ~100kHz
     
252.     UCB0BR1 = 0;
     
253.     UCB0I2CSA = SLAVE_ADDR;                   // Slave Address is 048h
     
254.     UCB0CTL1 &= ~UCSWRST;                     // Clear SW reset, resume operation
     
255.     UCB0IE |= UCNACKIE;                       //使能中断
     
256. }
     
257. 
     
258. void OLED_WrCmd(unsigned char IIC_Command)
     
259. {
     
260.         MasterType0[0]=IIC_Command;
     
261.       I2C_Master_WriteReg(SLAVE_ADDR, 0x00,MasterType0, 1);
     
262. }
     
263. 
     
264. void OLED_WrDat(unsigned char IIC_Data)
     
265. {
     
266.         MasterType0[0]=IIC_Data;
     
267.       I2C_Master_WriteReg(SLAVE_ADDR, 0x40,MasterType0, 1);
     
268. }
     
269. 
     
270. //******************************************************************************
     
271. // Main ************************************************************************
     
272. // Send and receive three messages containing the example commands *************
     
273. //******************************************************************************
     
274. 
     
275. void OLED_Fill(unsigned char bmp_dat)
     
276. {
     
277.         unsigned char y,x;
     
278.         for(y=0;y<8;y++)
     
279.         {
     
280.                 OLED_WrCmd(0xb0+y);
     
281.                 OLED_WrCmd(0x01);
     
282.                 OLED_WrCmd(0x10);
     
283.                 for(x=0;x<128;x++)
     
284.                 OLED_WrDat(bmp_dat);
     
285.         }
     
286. }
     
287. 
     
288. void OLED_Set_Pos(unsigned char x, unsigned char y)
     
289. {
     
290.         OLED_WrCmd(0xb0+y);
     
291.         OLED_WrCmd(((x&0xf0)>>4)|0x10);
     
292.         OLED_WrCmd((x&0x0f)|0x01);
     
293. }
     
294. 
     
295. void OLED_Init(void)
     
296. {
     
297.         unsigned char i=0;
     
298.         for(;i<28;i++)
     
299.         {
     
300.           MasterType0[0]=MasterType1[i];
     
301.           I2C_Master_WriteReg(SLAVE_ADDR, 0x00,MasterType0, 1);
     
302.         }
     
303.         OLED_Fill(0x00); //初始清屏
     
304.         OLED_Set_Pos(0,0);
     
305. }
     
306. 
     
307. void OLED_WR_Byte(unsigned dat,unsigned cmd)
     
308. {
     
309.         if(cmd)
     
310.                         {
     
311. 
     
312.    OLED_WrDat(dat);
     
313.    
     
314.                 }
     
315.         else {
     
316.    OLED_WrCmd(dat);
     
317.                
     
318.         }
     
319. }
     
320. 
     
321. 
     
322. void OLED_ShowChar(unsigned char x,unsigned char y,unsigned char chr,unsigned char Char_Size)
     
323. {           
     
324.         unsigned char c=0,i=0;       
     
325.                 c=chr-' ';//得到偏移后的值                       
     
326.                 if(x>128-1){x=0;y=y+2;}
     
327.                 if(Char_Size ==16)
     
328.                         {
     
329.                         OLED_Set_Pos(x,y);       
     
330.                         for(i=0;i<8;i++)
     
331.                         OLED_WR_Byte(F8X16[c*16+i],OLED_DATA);
     
332.                         OLED_Set_Pos(x,y+1);
     
333.                         for(i=0;i<8;i++)
     
334.                         OLED_WR_Byte(F8X16[c*16+i+8],OLED_DATA);
     
335.                         }
     
336.                         else {       
     
337.                                 OLED_Set_Pos(x,y);
     
338.                                 for(i=0;i<6;i++)
     
339.                                 OLED_WR_Byte(F6x8[c][i],OLED_DATA);
     
340.                                
     
341.                         }
     
342. }
     
343. 
     
344. void OLED_U32toU16(unsigned char x,unsigned char y ,unsigned int n,unsigned char k)
     
345. {
     
346.         switch(n)
     
347.         {
     
348.                 case 0 :OLED_ShowChar(x,y,'0',k);break;
     
349.                 case 1 :OLED_ShowChar(x,y,'1',k);break;
     
350.                 case 2 :OLED_ShowChar(x,y,'2',k);break;
     
351.                 case 3 :OLED_ShowChar(x,y,'3',k);break;
     
352.                 case 4 :OLED_ShowChar(x,y,'4',k);break;
     
353.                 case 5 :OLED_ShowChar(x,y,'5',k);break;
     
354.                 case 6 :OLED_ShowChar(x,y,'6',k);break;
     
355.                 case 7 :OLED_ShowChar(x,y,'7',k);break;
     
356.                 case 8 :OLED_ShowChar(x,y,'8',k);break;
     
357.                 case 9 :OLED_ShowChar(x,y,'9',k);break;
     
358.         }
     
359. }
     
360. 
     
361. void OLED_Show_Number(unsigned char x,unsigned char y ,unsigned int a,unsigned char n)
     
362. {
     
363.         unsigned int b,c,d,e,f,g;
     
364.         b=a/100000;
     
365.         c=a%100000/10000;
     
366.         d=a%10000/1000;
     
367.         e=a%1000/100;
     
368.         f=a%100/10;
     
369.         g=a%10;
     
370.         if(b!=0)
     
371.         {
     
372.                 OLED_U32toU16(x,y,b,n);
     
373.                 OLED_U32toU16(x+n/2,y,c,n);
     
374.                 OLED_U32toU16(x+n,y,d,n);
     
375.                 OLED_U32toU16(x+(n/2)*3,y,e,n);
     
376.                 OLED_U32toU16(x+2*n,y,f,n);
     
377.                 OLED_U32toU16(x+(n/2)*5,y,g,n);
     
378.         }else if(b==0&&c!=0)
     
379.         {
     
380.                 OLED_U32toU16(x,y,c,n);
     
381.                 OLED_U32toU16(x+n/2,y,d,n);
     
382.                 OLED_U32toU16(x+n,y,e,n);
     
383.                 OLED_U32toU16(x+(n/2)*3,y,f,n);
     
384.                 OLED_U32toU16(x+2*n,y,g,n);
     
385.         }else if(b==0&&c==0&&d!=0)
     
386.         {
     
387.                 OLED_U32toU16(x,y,d,n);
     
388.                 OLED_U32toU16(x+n/2,y,e,n);
     
389.                 OLED_U32toU16(x+n,y,f,n);
     
390.                 OLED_U32toU16(x+(n/2)*3,y,g,n);
     
391.         }else if(b==0&&c==0&&d==0&&e!=0)
     
392.         {
     
393.                 OLED_U32toU16(x,y,e,n);
     
394.                 OLED_U32toU16(x+n/2,y,f,n);
     
395.                 OLED_U32toU16(x+n,y,g,n);
     
396.         }else if(b==0&&c==0&&d==0&&e==0&&f!=0)
     
397.         {
     
398.                 OLED_U32toU16(x,y,f,n);
     
399.                 OLED_U32toU16(x+n/2,y,g,n);
     
400.         }else
     
401.         {
     
402.                 OLED_U32toU16(x,y,g,n);
     
403.         }
     
404. }
     
405. 
     
406. int main(void) {
     
407. 
     
408.     WDTCTL = WDTPW | WDTHOLD;                 // Stop watchdog timer
     
409. 
     
410.     initClockTo16MHz();                        //配置系统时钟为16Mhz
     
411.     initGPIO();
     
412.     initI2C();
     
413.     delay(500);
     
414.     OLED_Init();
     
415.     OLED_Show_Number(0,0,500,16);
     
416.     __bis_SR_register(LPM0_bits + GIE);
     
417. }
     
418. 
     
419. //******************************************************************************
     
420. // I2C Interrupt ***************************************************************
     
421. //******************************************************************************
     
422. 
     
423. #if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
     
424. #pragma vector=USCI_B0_VECTOR
     
425. __interrupt void USCI_B0_ISR(void)
     
426. #elif defined(__GNUC__)
     
427. void __attribute__ ((interrupt(USCI_B0_VECTOR))) USCI_B0_ISR (void)
     
428. #else
     
429. #error Compiler not supported!
     
430. #endif
     
431. {
     
432.   //Must read from UCB0RXBUF
     
433.   uint8_t rx_val = 0;
     
434. 
     
435.   switch(__even_in_range(UCB0IV,0xC))
     
436.   {
     
437.     case USCI_NONE:break;                             // Vector 0 - no interrupt
     
438.     case USCI_I2C_UCALIFG:break;                      // Interrupt Vector: I2C Mode: UCALIFG
     
439.     case USCI_I2C_UCNACKIFG:break;                    // Interrupt Vector: I2C Mode: UCNACKIFG
     
440.     case USCI_I2C_UCSTTIFG:break;                     // Interrupt Vector: I2C Mode: UCSTTIFG
     
441.     case USCI_I2C_UCSTPIFG:break;                     // Interrupt Vector: I2C Mode: UCSTPIFG
     
442.     case USCI_I2C_UCRXIFG:
     
443.         rx_val = UCB0RXBUF;
     
444.         if (RXByteCtr)
     
445.         {
     
446.           ReceiveBuffer[ReceiveIndex++] = rx_val;
     
447.           RXByteCtr--;
     
448.         }
     
449. 
     
450.         if (RXByteCtr == 1)
     
451.         {
     
452.           UCB0CTL1 |= UCTXSTP;
     
453.         }
     
454.         else if (RXByteCtr == 0)
     
455.         {
     
456.           UCB0IE &= ~UCRXIE;
     
457.           MasterMode = IDLE_MODE;
     
458.           __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0
     
459.         }
     
460.         break;                      // Interrupt Vector: I2C Mode: UCRXIFG
     
461.     case USCI_I2C_UCTXIFG:
     
462.         switch (MasterMode)
     
463.         {
     
464.           case TX_REG_ADDRESS_MODE:
     
465.               UCB0TXBUF = TransmitRegAddr;
     
466.               if (RXByteCtr)
     
467.                   MasterMode = SWITCH_TO_RX_MODE;   // Need to start receiving now
     
468.               else
     
469.                   MasterMode = TX_DATA_MODE;        // Continue to transmission with the data in Transmit Buffer
     
470.               break;
     
471. 
     
472.           case SWITCH_TO_RX_MODE:
     
473.               UCB0IE |= UCRXIE;              // Enable RX interrupt
     
474.               UCB0IE &= ~UCTXIE;             // Disable TX interrupt
     
475.               UCB0CTL1 &= ~UCTR;            // Switch to receiver
     
476.               MasterMode = RX_DATA_MODE;    // State state is to receive data
     
477.               UCB0CTL1 |= UCTXSTT;          // Send repeated start
     
478.               if (RXByteCtr == 1)
     
479.               {
     
480.                   //Must send stop since this is the N-1 byte
     
481.                   while((UCB0CTL1 & UCTXSTT));
     
482.                   UCB0CTL1 |= UCTXSTP;      // Send stop condition
     
483.               }
     
484.               break;
     
485. 
     
486.           case TX_DATA_MODE:
     
487.               if (TXByteCtr)
     
488.               {
     
489.                   UCB0TXBUF = TransmitBuffer[TransmitIndex++];
     
490.                   TXByteCtr--;
     
491.               }
     
492.               else
     
493.               {
     
494.                   //Done with transmission
     
495.                   UCB0CTL1 |= UCTXSTP;     // Send stop condition
     
496.                   MasterMode = IDLE_MODE;
     
497.                   UCB0IE &= ~UCTXIE;                       // disable TX interrupt
     
498.                   __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0
     
499.               }
     
500.               break;
     
501. 
     
502.           default:
     
503.               __no_operation();
     
504.               break;
     
505.         }
     
506.         break;                      // Interrupt Vector: I2C Mode: UCTXIFG
     
507.     default: break;
     
508.   }
     
509. }
     

复制代码

用keil5打开乱码咋回事

1106998808 发表于 2018-7-20 23:45
用keil5打开乱码咋回事

是用IAR编写的

是个好贴 我准备下载下来试试

好贴，可惜积分不够，很想下载来试一下。

刚好有个其他LCD要硬件IIC接口，在楼主的基础上改了一下测试OK,谢谢楼主分享！

发现有个问题，在运行1-2小时后会宕机，屏幕显示刷新一部分后面刷新不动，重启运行又是正常的，I2C频率改慢也是一样的，上拉电阻使用4.7K.

switch(__even_in_range(UCB0IV,0xC))因为我用的芯片头文件里没有找到UCB0IV，可以用其他的

switch(__even_in_range(UCB0IV,0xC))，因为用的不是F5529，在头文件中没有找到UCB0IV，可以用其他的代替吗？

这个我最近在用不错

这是官方例程吗

谢谢，太有用了！！！

能显示汉自吗？

请问下OLED这个怎么作为子函数使用啊

您好 为什么我的IIC配置进不去中断呢？

1106998808 发表于 2018-7-20 23:45
用keil5打开乱码咋回事

msp430好像只能用ccs或者iar for msp430

怎么接线

driverlib.h显示找不到是怎么回事

想问一下移植了您的程序为什么程序会卡在这里不动啊  if (RXByteCtr == 1)         {           UCB0CTL1 |= UCTXSTP;《----这一行         }         else if (RXByteCtr == 0) 我只不过用的是ccs啊

问一下，sda和scl的io接口3.0和3.1换成别打接口（比如3.5和3.6），程序怎么改，我直接改mainc里面那个gpio没用

好代码，下载用用了

837877663 发表于 2018-7-24 01:37
是用IAR编写的

可以用gcc打开

1106998808 发表于 2018-7-20 23:45
用keil5打开乱码咋回事

软件编码改一下就可以了

tiger_work 发表于 2018-10-29 22:50
好贴，可惜积分不够，很想下载来试一下。

很容易得的