Statistics
| Branch: | Tag: | Revision:

amiro-os / components / proximity / vcnl4020.cpp @ f3972840

History | View | Annotate | Download (5.043 KB)

1 58fe0e0b Thomas Schöpping
#include <ch.hpp>
2
#include <hal.h>
3
#include <chdebug.h>
4
#include <chprintf.h>
5
6
#include <amiro/bus/i2c/I2CParams.hpp>
7
#include <amiro/bus/i2c/I2CDriver.hpp>
8
#include <amiro/proximity/vcnl4020.hpp>
9 b4885314 Thomas Schöpping
#include <amiro/Constants.h>
10 58fe0e0b Thomas Schöpping
11
using namespace chibios_rt;
12
13
namespace amiro {
14
15
VCNL4020::
16
~VCNL4020() {
17
18
}
19
20
VCNL4020::
21
VCNL4020(I2CDriver *driver, const VCNL4020Config *config) :
22
  BaseStaticThread<256>(),
23
  driver(driver),
24
  config(config),
25
  ambient(0x0000u),
26
  proximity(0x0000u),
27
  proximityOffset(0x0000u) {
28
29
  this->tx_params.addr = VCNL4020::SLA;
30
31
}
32
33
uint16_t
34
VCNL4020::
35
getAmbientLight() {
36
37
  return this->ambient;
38
}
39
40
void
41
VCNL4020::
42
setProximityOffset(uint16_t offset) {
43
44
  this->proximityOffset = offset;
45
}
46
47
uint16_t
48
VCNL4020::
49
getProximityOffset() {
50
51
  return this->proximityOffset;
52
}
53
54
EvtSource*
55
VCNL4020::
56
getEventSource() {
57
58
  return &this->eventSource;
59
}
60
61
uint16_t
62
VCNL4020::
63
getProximity() {
64
65
  return this->proximity;
66
}
67
68
uint16_t
69
VCNL4020::
70
getProximityScaledWoOffset() {
71
72
  if (this->proximity <= this->proximityOffset)
73
    return 0;
74
75
  // Scale factor for the offset-less proximity value, so that we can reach full-scale
76
  const float scaleFactor = float(0xFFFFu) / float((0xFFFFu - this->proximityOffset));
77
78
  return uint16_t(float(this->proximity - this->proximityOffset) * scaleFactor);
79
}
80
81
msg_t
82
VCNL4020::
83
main(void) {
84
85
  I2CDriver *drv = this->driver;
86
  msg_t res;
87
88
  this->setName("Vcnl4020");
89
90
  drv->acquireBus();
91
92
  /* exit if writing configuration fails */
93
  res = this->writeIRConf();
94
95
  drv->releaseBus();
96
97
  if (res)
98
    return RDY_RESET;
99
100
  //TODO Read calibration from eeprom
101
102
  while (!this->shouldTerminate()) {
103
104
    drv->acquireBus();
105
106
    this->readIntensities();
107
    drv->releaseBus();
108
109
    this->eventSource.broadcastFlags(0);
110
111 8dbafe16 Thomas Schöpping
    this->waitAnyEventTimeout(ALL_EVENTS, CAN::UPDATE_PERIOD);
112 58fe0e0b Thomas Schöpping
  }
113
114
  return RDY_OK;
115
}
116
117
msg_t
118
VCNL4020::
119
writeIRConf() {
120
121
  msg_t res;
122
  const VCNL4020Config *cfg = this->config;
123
124
  uint8_t buffer[4];
125
  this->tx_params.txbuf = buffer;
126
  this->tx_params.txbytes = 4;
127
  this->tx_params.rxbytes = 0;
128
129
  buffer[0] = offsetof(VCNL4020::registers, proximity_rate);
130
  buffer[1] = cfg->proximity_rate;
131
  buffer[2] = cfg->ir_led_current_mA > 200 ? 20u : cfg->ir_led_current_mA / 10u;
132
  buffer[3] = cfg->ambient_parameter;
133
134
  res = this->driver->masterTransmit(&this->tx_params);
135
136
  buffer[0] = offsetof(VCNL4020::registers, command);
137
  buffer[1] = cfg->command;
138
139
  this->tx_params.txbytes = 2;
140
141
  if (!res)
142
    res = this->driver->masterTransmit(&this->tx_params);
143
144
  return res;
145
}
146
147
msg_t
148
VCNL4020::
149
readIntensities() {
150
151
  msg_t res;
152
  uint8_t buffer[4];
153
  uint8_t reg = offsetof(VCNL4020::registers, ambient_result);
154
  this->tx_params.txbuf = &reg;
155
  this->tx_params.txbytes = 1;
156
  this->tx_params.rxbuf = buffer;
157
  this->tx_params.rxbytes = 4;
158
159
  res = this->driver->masterTransmit(&this->tx_params);
160
161
  if (!res) {
162
163
    /* update internal values */
164
    this->ambient = (buffer[0] << 8) | buffer[1];
165
    this->proximity = (buffer[2] << 8) | buffer[3];
166
167
  }
168
169
  return res;
170
171
}
172
173
uint8_t
174
VCNL4020::
175
getCheck(void) {
176
177
  int8_t resTx;
178
  uint8_t rxBuffer[2]; /** This is a bug workaround: 1 byte is impossible to read on STM32F1*/
179
  const uint8_t txBuffer = uint8_t(offsetof(VCNL4020::registers, revision));
180
181
  // Use own datastructure, so that there is now faulty
182
  // behaviour with the other threads using it
183
  I2CTxParams tx_params = this->tx_params;
184
  tx_params.txbuf = &txBuffer;
185
  tx_params.txbytes = 1;
186
  tx_params.rxbytes = 2; /** This is a bug workaround: 1 byte is impossible to read on STM32F1*/
187
  tx_params.rxbuf = rxBuffer;
188
189
  // Read the data
190
  resTx = this->driver->masterTransmit(&tx_params);
191
  // Failed to transmit
192
  if (resTx != RDY_OK || VCNL4020::PRODUCT_ID_REVISION != rxBuffer[0]) {
193
    return VCNL4020::CHECK_FAIL;
194
  } else {
195
    return VCNL4020::CHECK_OK;
196
  }
197
198
}
199
200
uint8_t
201
VCNL4020::
202
calibrate() {
203
204
  uint16_t proximityFloorMeanValue;
205
206
  // Get the offset
207
  msg_t res = calibrateOffset(proximityFloorMeanValue);
208
  if (res == CALIB_OK) {
209
    this->proximityOffset = proximityFloorMeanValue;
210
    //TODO Write value to eeprom
211
    return res;
212
  } else {
213
    return res;
214
  }
215
216
}
217
218
uint8_t
219
VCNL4020::
220
calibrateOffset(uint16_t &proximityFloorMeanValue) {
221
222
  uint32_t tmpProximityFloorMeanValue;
223
224
  // Register an event listener, to receive updates
225
  chibios_rt::EvtListener eventTimerEvtListener;
226
  chibios_rt::EvtSource *vcnlEvtSource;
227
  vcnlEvtSource = reinterpret_cast<EvtSource *>(this->getEventSource());
228
  vcnlEvtSource->registerOne(&eventTimerEvtListener,0);
229
230
  // Get the first values
231
  tmpProximityFloorMeanValue = this->getProximity();
232
233
  // Get the others with a floating mean
234
  const uint32_t maxValues = 20;
235
  for (uint32_t idxMean = 2; idxMean <= maxValues; ++idxMean) {
236
    this->waitOneEvent(ALL_EVENTS); /* Wait for a new update */
237
    tmpProximityFloorMeanValue = (((idxMean-1) * tmpProximityFloorMeanValue) + uint32_t(this->getProximity())) / idxMean;
238
  }
239
240
  vcnlEvtSource->unregister(&eventTimerEvtListener);
241
242
  // Cast the calculated offset to the temporary member variable
243
  proximityFloorMeanValue = uint16_t(tmpProximityFloorMeanValue);
244
245
  return CALIB_OK;
246
}
247
248
} /* amiro */