Statistics
| Branch: | Tag: | Revision:

amiro-lld / source / alld_at42qt1050.c @ ef078306

History | View | Annotate | Download (7.53 KB)

1 9e45662e Thomas Schöpping
/*
2
AMiRo-LLD is a compilation of low-level hardware drivers for the Autonomous Mini Robot (AMiRo) platform.
3
Copyright (C) 2016..2019  Thomas Schöpping et al.
4

5
This program is free software: you can redistribute it and/or modify
6
it under the terms of the GNU Lesser General Public License as published by
7
the Free Software Foundation, either version 3 of the License, or
8
(at your option) any later version.
9

10
This program is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
GNU Lesser General Public License for more details.
14

15
You should have received a copy of the GNU Lesser General Public License
16
along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
*/
18
19
/**
20
 * @file    alld_at42qt1050.c
21
 * @brief   Touch sensor function implementations.
22
 *
23
 * @addtogroup lld_touch
24
 * @{
25
 */
26
27
#include <alld_at42qt1050.h>
28
29
#if defined(AMIROLLD_CFG_USE_AT42QT1050) || defined(__DOXYGEN__)
30
31
#include <math.h>
32
33 ef078306 Thomas Schöpping
/******************************************************************************/
34
/* LOCAL DEFINITIONS                                                          */
35
/******************************************************************************/
36
37
/******************************************************************************/
38
/* EXPORTED VARIABLES                                                         */
39
/******************************************************************************/
40
41
/******************************************************************************/
42
/* LOCAL TYPES                                                                */
43
/******************************************************************************/
44
45
/******************************************************************************/
46
/* LOCAL VARIABLES                                                            */
47
/******************************************************************************/
48
49
/******************************************************************************/
50
/* LOCAL FUNCTIONS                                                            */
51
/******************************************************************************/
52
53
/******************************************************************************/
54
/* EXPORTED FUNCTIONS                                                         */
55
/******************************************************************************/
56
57 9e45662e Thomas Schöpping
/**
58
 * @brief   Read 8bit data from any register.
59
 *
60
 * @param[in]   at42qt1050d   The AT42QT1050 driver to use.
61
 * @param[in]   reg           Register address to read from.
62
 * @param[out]  data          Pointer to store the register data to.
63
 * @param[in]   timeout       Timeout for the function to return (in microseconds).
64
 *
65
 * @return    Indicator whether the function call was successful or a timeout occurred.
66
 */
67
inline apalExitStatus_t
68
at42qt1050_lld_read_reg(const AT42QT1050Driver* at42qt1050d, const at42qt1050_lld_register_t reg, uint8_t* const data, const apalTime_t timeout)
69
{
70
  apalDbgAssert(at42qt1050d != NULL && at42qt1050d->i2cd != NULL);
71
  apalDbgAssert(data != NULL);
72
73
  const uint8_t txbuf = (uint8_t)reg;
74
  return apalI2CMasterTransmit(at42qt1050d->i2cd, at42qt1050d->addr, &txbuf, 1, data, 1, timeout);
75
}
76
77
/**
78
 * @brief   Write 8bit data to any (writable) register.
79
 *
80
 * @param[in]   at42qt1050d   The AT42QT1050 driver to use.
81
 * @param[in]   reg           Register address to write to.
82
 * @param[in]   data          Data to transmit.
83
 * @param[in]   timeout       Timeout for the function to return (in microseconds).
84
 *
85
 * @return    Indicator whether the function call was successful or a timeout occurred.
86
 */
87
inline apalExitStatus_t
88
at42qt1050_lld_write_reg(const AT42QT1050Driver* at42qt1050d, const at42qt1050_lld_register_t reg, const uint8_t data, const apalTime_t timeout)
89
{
90
  apalDbgAssert(at42qt1050d != NULL && at42qt1050d->i2cd != NULL);
91
92
  const uint8_t txbuf[2] = { (uint8_t)reg, data };
93
  return apalI2CMasterTransmit(at42qt1050d->i2cd, at42qt1050d->addr, txbuf, 2, NULL, 0, timeout);
94
}
95
96
/**
97
 * @brief   Read signal information of a key.
98
 *
99
 * @param[in]   at42qt1050d   The AT42QT1050 driver to use.
100
 * @param[in]   key           Key to read the signal information of.
101
 * @param[out]  signal        Pointer to store the data to.
102
 * @param[in]   timeout       Timeout for the function to return (in microseconds).
103
 *
104
 * @return    Indicator whether the function call was successful or a timeout occurred.
105
 */
106
inline apalExitStatus_t
107
at42qt1050_lld_read_keyssignal(const AT42QT1050Driver* at42qt1050d, const uint8_t key, uint16_t* signal, const apalTime_t timeout)
108
{
109
  apalDbgAssert(at42qt1050d != NULL && at42qt1050d->i2cd != NULL);
110
  apalDbgAssert(key < AT42QT1050_LLD_NUM_KEYS);
111
  apalDbgAssert(signal != NULL);
112
113
  const uint8_t txbuf = AT42QT1050_LLD_REG_KEYSIGNAL_0 + (2*key) + ((key > 1) ? 1 : 0);
114
  uint8_t rxbuf[2];
115
  const apalExitStatus_t status = apalI2CMasterTransmit(at42qt1050d->i2cd, at42qt1050d->addr, &txbuf, 1, rxbuf, 2, timeout);
116
  *signal = (rxbuf[0] << 8) | rxbuf[1];
117
  return status;
118
}
119
120
/**
121
 * @brief   Read reference data of a key.
122
 *
123
 * @param[in]   at42qt1050d   The AT42QT1050 driver to use.
124
 * @param[in]   key           Key to read the signal information of.
125
 * @param[out]  refdata       Pointer to store the data to.
126
 * @param[in]   timeout       Timeout for the function to return (in microseconds).
127
 *
128
 * @return    Indicator whether the function call was successful or a timeout occurred.
129
 */
130
inline apalExitStatus_t
131
at42qt1050_lld_read_referencedata(const AT42QT1050Driver* at42qt1050d, const uint8_t key, uint16_t* refdata, const apalTime_t timeout)
132
{
133
  apalDbgAssert(at42qt1050d != NULL && at42qt1050d->i2cd != NULL);
134
  apalDbgAssert(key < AT42QT1050_LLD_NUM_KEYS);
135
  apalDbgAssert(refdata != NULL);
136
137
  const uint8_t txbuf = AT42QT1050_LLD_REG_REFERENCEDATA_0 + (2*key) + ((key > 1) ? 1 : 0);
138
  uint8_t rxbuf[2];
139
  const apalExitStatus_t status = apalI2CMasterTransmit(at42qt1050d->i2cd, at42qt1050d->addr, &txbuf, 1, rxbuf, 2, timeout);
140
  *refdata = (rxbuf[0] << 8) | rxbuf[1];
141
  return status;
142
}
143
144
/**
145
 * @brief   Convert a 4 bit pulse value to the representing number of samples.
146
 * @details Calculation: <#samples> = 2^(<pulse value>)
147
 *
148
 * @param[in]   pulse   Pulse value.
149
 *
150
 * @return    Resulting sample count.
151
 */
152
inline uint16_t
153
at42qt1050_lld_pulse2samples(const uint8_t pulse)
154
{
155
  apalDbgAssert(pulse <= 0x0Fu);
156
157
  return (1 << pulse);
158
}
159
160
/**
161
 * @brief   Convert a desired number of samples to the according (theoretical) pulse value.
162
 * @details Calculation: <pulse value> = log2(<#samples>)
163
 *
164
 * @param[in]   samples   Desired number of samples.
165
 *
166
 * @return    The (theoretical) value to set to the pulse register.
167
 */
168
inline float
169
at42qt1050_lld_samples2pulse(const uint16_t samples)
170
{
171
  return log2f(samples);
172
}
173
174
/**
175
 * @brief   Convert a 4 bit scale value to the accoring scaling factor.
176
 * @details Calculation: <scaling factor> = 2^(<scale value>)
177
 *
178
 * @param[in]   scale   Scale value.
179
 *
180
 * @return    Resulting scaling factor.
181
 */
182
inline uint16_t
183
at42qt1050_lld_scale2scaling(const uint8_t scale)
184
{
185
  apalDbgAssert(scale <= 0x0Fu);
186
187
  return (1 << scale);
188
}
189
190
/**
191
 * @brief   Convert a desired scaling factor to the according (theoretical) scale value.
192
 * @details Calculation: <scale value> = log2(<scaling factor>
193
 * )
194
 * @param[in]   factor    Desired scaling factor.
195
 *
196
 * @return    The (theoretcial) value to set to the scale register.
197
 */
198
inline float
199
at42qt1050_lld_scaling2scale(const uint16_t factor)
200
{
201
  return log2f(factor);
202
}
203
204
#endif /* defined(AMIROLLD_CFG_USE_AT42QT1050) */
205
206
/** @} */