csr867x i2c和uart参考代码（来源文档）

365894126

I2C

1. #include <message.h>
   
2. #include <stdlib.h>
   
3. #include <i2c.h>
   
4. #include <panic.h>
   
5. #define MESSAGE_TX_DATA 0x4000
   
6. #define MESSAGE_RX_DATA 0x4001
   
7. #define I2C_DEVICE_ADDRESS 0x22
   
8. #define I2C_A_DEVICE_REGISTER 0x10
   
9. typedef struct
   
10. {
    
11.     TaskData task;
    
12. } I2CTaskData;
    
13. I2CTaskData theI2CTaskData;
    
14. uint16 i2c_register_data;
    
15. static void I2CMessageHandler(Task pTask, MessageId pId, Message pMessage);
    
16. static void i2c_example_init(void);
    
17. static void i2c_write_16bit_device_register(uint8 device_address, uint8 device_register, uint16 data);
    
18. static void i2c_read_16bit_device_register(uint8 device_address, uint8 device_register, uint16 *data);
    
19. int main(void)
    
20. {
    
21.     i2c_example_init();
    
22. 
    
23.     /* Start the message scheduler loop */
    
24.     MessageLoop();
    
25. 
    
26.     /* Never get here...*/
    
27.     return 0;
    
28. }
    
29. void i2c_example_init(void)
    
30. {
    
31.     /* Assign task message handler */
    
32.     theI2CTaskData.task.handler = I2CMessageHandler;
    
33.     /* Send MESSAGE_TX_DATA to the task */
    
34.     MessageSendLater(&theI2CTaskData.task, MESSAGE_TX_DATA, 0, 1000);
    
35.     /* Send MESSAGE_RX_DATA to the task */
    
36.     MessageSendLater(&theI2CTaskData.task, MESSAGE_RX_DATA, 0, 2000);
    
37. }
    
38. void i2c_write_16bit_device_register(uint8 device_address, uint8 device_register, uint16 data)
    
39. {
    
40.     uint8 i2c_data[3];
    
41.     i2c_data[0] = device_register;
    
42.     i2c_data[1] = (data >> 8) & 0xFF;
    
43.     i2c_data[2] = data & 0xFF;
    
44.     /*
    
45. I2cTransfer(uint16 address, const uint8 *tx, uint16 tx_len, uint8 *rx, uint16 rx_len)
    
46. If tx_len is non-zero and rx_len is zero then the sequence reduces to:
    
47. - Start condition (S).
    
48. - Write slave address and direction byte (address | 0).
    
49. - Write tx_len data bytes from the buffer at tx.
    
50. - Stop condition (P).
    
51. */
    
52.     PanicZero(I2cTransfer(device_address, i2c_data, 3, NULL, 0));
    
53. }
    
54. void i2c_read_16bit_device_register(uint8 device_address, uint8 device_register, uint16 *data)
    
55. {
    
56.     uint8 i2c_data[1];
    
57.     uint8 i2c_rx_data[2];
    
58.     i2c_data[0] = device_register;
    
59.     /*
    
60. I2cTransfer(uint16 address, const uint8 *tx, uint16 tx_len, uint8 *rx, uint16 rx_len)
    
61. If tx_len is non-zero and rx_len is non-zero then the sequence is:
    
62. - Start condition (S).
    
63. - Write slave address and direction byte (address | 0).
    
64. - Write tx_len data bytes from the buffer at tx.
    
65. - Repeated start condition (Sr).
    
66. - Write slave address and direction byte (address | 1).
    
67. - Read rx_len bytes into the buffer at rx, acknowledging all but the final byte.
    
68. - Stop condition (P).
    
69. */
    
70.     PanicZero(I2cTransfer(device_address, i2c_data, 1, i2c_rx_data, 2));
    
71.     *data = (i2c_rx_data[0] << 8) + i2c_rx_data[1];
    
72. }
    
73. void I2CMessageHandler(Task pTask, MessageId pId, Message pMessage)
    
74. {
    
75.     switch (pId)
    
76.     {
    
77.     case MESSAGE_TX_DATA:
    
78.         i2c_write_16bit_device_register(I2C_DEVICE_ADDRESS, I2C_A_DEVICE_REGISTER,
    
79.                                         0x1234);
    
80.         /* Send MESSAGE_TX_DATA to the task */
    
81.         MessageSendLater(&theI2CTaskData.task, MESSAGE_TX_DATA, 0, 1000);
    
82.         break;
    
83.     case MESSAGE_RX_DATA:
    
84.         i2c_read_16bit_device_register(I2C_DEVICE_ADDRESS, I2C_A_DEVICE_REGISTER,
    
85.                                        &i2c_register_data);
    
86.         /* Send MESSAGE_RX_DATA to the task */
    
87.         MessageSendLater(&theI2CTaskData.task, MESSAGE_RX_DATA, 0, 2000);
    
88.         break;
    
89.     default:
    
90.         break;
    
91.     }
    
92. }

复制代码

365894126

UART （managed connection）

1. #include <stream.h>
   
2. #include <sink.h>
   
3. #include <source.h>
   
4. #include <string.h>
   
5. #include <panic.h>
   
6. #include <message.h>
   
7. #include <app/uart/uart_if.h>
   
8. typedef struct
   
9. {
   
10.     TaskData task;
    
11.     Sink uart_sink;
    
12.     Source uart_source;
    
13. } UARTStreamTaskData;
    
14. UARTStreamTaskData theUARTStreamTask;
    
15. static void UARTStreamMessageHandler(Task pTask, MessageId pId, Message pMessage);
    
16. static void uart_data_stream_rx_data(Source src);
    
17. static void uart_data_stream_tx_data(const uint8 *data, uint16 length);
    
18. static void uart_data_stream_init(void);
    
19. int main(void)
    
20. {
    
21.     uart_data_stream_init();
    
22. 
    
23.     /* Start the message scheduler loop */
    
24.     MessageLoop();
    
25. 
    
26.     /* Never get here...*/
    
27.     return 0;
    
28. }
    
29. void uart_data_stream_init(void)
    
30. {
    
31.     /* Assign task message handler */
    
32.     theUARTStreamTask.task.handler = UARTStreamMessageHandler;
    
33.     /* Configure uart settings */
    
34.     StreamUartConfigure(VM_UART_RATE_38K4, VM_UART_STOP_ONE, VM_UART_PARITY_NONE);
    
35.     /* Get the sink for the uart */
    
36.     theUARTStreamTask.uart_sink = StreamUartSink();
    
37.     PanicNull(theUARTStreamTask.uart_sink);
    
38.     /* Get the source for the uart */
    
39.     theUARTStreamTask.uart_source = StreamUartSource();
    
40.     PanicNull(theUARTStreamTask.uart_source);
    
41.     /* Register uart source with task */
    
42.     MessageSinkTask(StreamSinkFromSource(theUARTStreamTask.uart_source),
    
43.                     &theUARTStreamTask.task);
    
44. }
    
45. void uart_data_stream_tx_data(const uint8 *data, uint16 length)
    
46. {
    
47.     uint16 offset = 0;
    
48.     uint8 *dest = NULL;
    
49.     /* Claim space in the sink, getting the offset to it */
    
50.     offset = SinkClaim(theUARTStreamTask.uart_sink, length);
    
51.     if (offset == 0xFFFF)
    
52.         Panic();
    
53.     /* Map the sink into memory space */
    
54.     dest = SinkMap(theUARTStreamTask.uart_sink);
    
55.     PanicNull(dest);
    
56.     /* Copy data into the claimed space */
    
57.     memcpy(dest + offset, data, length);
    
58.     /* Flush the data out to the uart */
    
59.     PanicZero(SinkFlush(theUARTStreamTask.uart_sink, length));
    
60. }
    
61. void uart_data_stream_rx_data(Source src)
    
62. {
    
63.     uint16 length = 0;
    
64.     const uint8 *data = NULL;
    
65.     /* Get the number of bytes in the specified source before the next packet  boundary */
    
66.     if (!(length = SourceBoundary(src)))
    
67.         return;
    
68.     /* Maps the specified source into the address map */
    
69.     data = SourceMap(src);
    
70.     PanicNull((void *)data);
    
71.     /* Transmit the received data */
    
72.     uart_data_stream_tx_data(data, length);
    
73.     /* Discards the specified amount of bytes from the front of the specified  source */
    
74.     SourceDrop(src, length);
    
75. }
    
76. void UARTStreamMessageHandler(Task pTask, MessageId pId, Message pMessage)
    
77. {
    
78.     switch (pId)
    
79.     {
    
80.     case MESSAGE_MORE_DATA:
    
81.         uart_data_stream_rx_data(((MessageMoreData *)pMessage)->source);
    
82.         break;
    
83.     default:
    
84.         break;
    
85.     }
    
86. }
    

复制代码

365894126

UART （Direct connection）

1. #include <stream.h>
   
2. #include <sink.h>
   
3. #include <source.h>
   
4. #include <string.h>
   
5. #include <panic.h>
   
6. #include <message.h>
   
7. #include <stdlib.h>
   
8. #include <app/uart/uart_if.h>
   
9. #define MESSAGE_SEND_STRING 0x4000
   
10. typedef struct
    
11. {
    
12.     TaskData task;
    
13.     Sink uart_sink;
    
14.     Source region_source;
    
15.     const uint8 *region_data;
    
16. } UARTAndRegionStreamTaskData;
    
17. UARTAndRegionStreamTaskData theUARTAndRegionStreamTask;
    
18. const uint8 example_text[] = "Hello World";
    
19. static void UARTAndRegionStreamMessageHandler(Task pTask, MessageId pId, Message pMessage);
    
20. static void uart_and_region_data_stream_tx_data(const uint8 *data, uint16 length);
    
21. static void uart_and_region_data_stream_init(void);
    
22. int main(void)
    
23. {
    
24.     uart_and_region_data_stream_init();
    
25. 
    
26.     /* Start the message scheduler loop */
    
27.     MessageLoop();
    
28. 
    
29.     /* Never get here...*/
    
30.     return 0;
    
31. }
    
32. void uart_and_region_data_stream_init(void)
    
33. {
    
34.     /* Assign task message handler */
    
35.     theUARTAndRegionStreamTask.task.handler = UARTAndRegionStreamMessageHandler;
    
36.     /* Configure uart settings */
    
37.     StreamUartConfigure(VM_UART_RATE_38K4, VM_UART_STOP_ONE, VM_UART_PARITY_NONE);
    
38.     /* Get the sink for the uart */
    
39.     theUARTAndRegionStreamTask.uart_sink = StreamUartSink();
    
40.     PanicNull(theUARTAndRegionStreamTask.uart_sink);
    
41.     /* Send MESSAGE_SEND_STRING to the task */
    
42.     MessageSendLater(&theUARTAndRegionStreamTask.task, MESSAGE_SEND_STRING, 0, 1000);
    
43. }
    
44. void uart_and_region_data_stream_tx_data(const uint8 *data, uint16 length)
    
45. {
    
46.     if (!length)
    
47.         return;
    
48.     /* Allocate memory for the region */
    
49.     theUARTAndRegionStreamTask.region_data = malloc(length);
    
50.     /* Region of memory to be treated as a source */
    
51.     theUARTAndRegionStreamTask.region_source =
    
52.         StreamRegionSource(theUARTAndRegionStreamTask.region_data, length);
    
53.     PanicNull(theUARTAndRegionStreamTask.region_source);
    
54.     /* Register region source with task */
    
55.     MessageSinkTask(StreamSinkFromSource(theUARTAndRegionStreamTask.region_source),
    
56.                     &theUARTAndRegionStreamTask.task);
    
57.     /* Establishes an automatic connection between the region source and sink */
    
58.     PanicZero(StreamConnect(theUARTAndRegionStreamTask.region_source,
    
59.                             theUARTAndRegionStreamTask.uart_sink));
    
60.     /* Copy data into the region */
    
61.     memcpy((uint8 *)theUARTAndRegionStreamTask.region_data, data, length);
    
62. }
    
63. void UARTAndRegionStreamMessageHandler(Task pTask, MessageId pId, Message pMessage)
    
64. {
    
65.     switch (pId)
    
66.     {
    
67.     case MESSAGE_SOURCE_EMPTY:
    
68.         /* Free the memory allocated for the region data */
    
69.         /* The source created using StreamRegionSource() only exists  while the data is being read */
    
70.         /* However, the memory block being treated as a source  is not freed by the stream subsystem */
    
71.         if (theUARTAndRegionStreamTask.region_data)
    
72.         {
    
73.             free((uint8 *)theUARTAndRegionStreamTask.region_data);
    
74.         }
    
75.         /* Send MESSAGE_SEND_STRING to the task */
    
76.         MessageSendLater(&theUARTAndRegionStreamTask.task, MESSAGE_SEND_STRING, 0, 1000);
    
77.         break;
    
78.     case MESSAGE_SEND_STRING:
    
79.         uart_and_region_data_stream_tx_data(example_text, sizeof(example_text));
    
80.         break;
    
81.     default:
    
82.         break;
    
83.     }
    
84. }

复制代码

365894126

来源文档：
http://www.52bluetooth.com/forum.php?mod=viewthread&tid=5353

213465982

支持分享。

深圳市

学习

asfjin72

thank you