1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
#include "i2c.h"
#include "rcc.h"
#include "thread.h"
#if defined(STM32F1)
I2C_t I2C1(0x40005400, 36000000, Interrupt::I2C1_EV, Interrupt::I2C1_ER);
I2C_t I2C2(0x40005800, 36000000, Interrupt::I2C2_EV, Interrupt::I2C2_ER);
#elif defined(STM32F4)
I2C_t I2C1(0x40005400, 42000000, Interrupt::I2C1_EV, Interrupt::I2C1_ER);
I2C_t I2C2(0x40005800, 42000000, Interrupt::I2C2_EV, Interrupt::I2C2_ER);
//I2C_t I2C3(0x40005c00, 42000000, Interrupt::I2C3_EV, Interrupt::I2C3_ER);
#endif
void I2C_t::irq_ev() {
uint32_t sr1 = reg.SR1;
reg.SR2;
// EV5, SB = 1: Start condition sent.
if(sr1 & 0x01) {
// Send address.
reg.DR = (addr << 1) | (writing ? 0 : 1);
}
// EV6, ADDR = 1: Address sent.
if(sr1 & 0x02) {
if(writing) {
reg.DR = *write_p++;
writing--;
} else {
if(reading > 1) {
reg.CR1 |= 0x400; // Set ACK.
} else {
reg.CR1 |= 0x200; // Set STOP.
}
}
}
// EV7, RxNE = 1: Receive buffer not empty.
if(sr1 & 0x40) {
*read_p++ = reg.DR;
reading--;
if(reading == 1) {
// Unset ACK, set STOP.
reg.CR1 = (reg.CR1 & ~0x400) | 0x200;
}
if(reading == 0) {
busy = 0;
}
}
//reg.CR1 &= ~0x400;
// EV8, TxE = 1, BTF = 0: Transmit buffer empty, still writing.
if(sr1 & 0x80 && !(sr1 & 0x04)) {
if(writing) {
// Send data.
reg.DR = *write_p++;
writing--;
} else {
// All data sent.
if(reading) {
// Send repeat start.
reg.CR1 |= 0x100;
} else {
// Send stop.
reg.CR1 |= 0x200;
busy = 0;
}
}
}
}
void I2C_t::irq_er() {
handle_error();
}
void I2C_t::handle_error() {
reg.SR1;
reg.SR2;
//while(1);
reg.CR1 |= 0x200;
busy = 0;
}
void I2C_t::enable(Pin& scl, Pin& sda) {
RCC.enable(RCC.I2C1);
asm volatile("nop");
scl.set_af(4);
sda.set_af(4);
scl.set_type(Pin::OpenDrain);
sda.set_type(Pin::OpenDrain);
scl.set_mode(Pin::AF);
sda.set_mode(Pin::AF);
reg.CR1 = 0x8000;
reg.CR1 = 0;
reg.CR2 = 0x700 | (clk / 1000000);
reg.TRISE = clk / 1000000 + 1;
reg.CCR = clk / 2 / 100000;
Interrupt::enable(irq_ev_n, &I2C_t::irq_ev, this);
Interrupt::enable(irq_er_n, &I2C_t::irq_er, this);
reg.CR1 = 1;
}
void I2C_t::write_reg(uint8_t addr_, uint8_t reg_, uint8_t data) {
addr = addr_;
writing = 2;
reading = 0;
volatile uint8_t buf[] = {reg_, data};
write_p = buf;
busy = 1;
reg.CR1 |= 0x100;
while(busy) {
Thread::yield();
}
}
void I2C_t::read_reg(uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t* buf) {
addr = addr_;
writing = 1;
reading = len;
write_p = ®_;
read_p = buf;
busy = 1;
reg.CR1 |= 0x100;
while(busy) {
Thread::yield();
}
}
|
