2 * Copyright © 2012 Keith Packard <keithp@keithp.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; version 2 of the License.
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
19 #include <ao_mma655x.h>
24 #define PRINTD(...) do { printf ("\r%5u %s: ", ao_tick_count, __func__); printf(__VA_ARGS__); } while(0)
29 static uint8_t mma655x_configured;
31 uint8_t ao_mma655x_spi_index = AO_MMA655X_SPI_INDEX;
34 ao_mma655x_start(void) {
35 ao_spi_get_bit(AO_MMA655X_CS_PORT,
43 ao_mma655x_stop(void) {
44 ao_spi_put_bit(AO_MMA655X_CS_PORT,
47 AO_MMA655X_SPI_INDEX);
51 ao_mma655x_restart(void) {
53 ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, AO_MMA655X_CS, 1);
55 /* Emperical testing on STM32L151 at 32MHz for this delay amount */
56 for (i = 0; i < 9; i++)
58 ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, AO_MMA655X_CS, 0);
65 /* down to four bits */
66 p = (v ^ (v >> 4)) & 0xf;
68 /* Cute lookup hack -- 0x6996 encodes the sixteen
69 * even parity values in order.
71 p = (~0x6996 >> p) & 1;
76 ao_mma655x_cmd(uint8_t d[2])
79 PRINTD("\tSEND %02x %02x\n", d[0], d[1]);
80 ao_spi_duplex(d, d, 2, AO_MMA655X_SPI_INDEX);
81 PRINTD("\t\tRECV %02x %02x\n", d[0], d[1]);
86 ao_mma655x_reg_read(uint8_t addr)
90 d[0] = addr | (ao_parity(addr) << 7);
92 ao_spi_send(&d, 2, AO_MMA655X_SPI_INDEX);
95 /* Send a dummy read of 00 to clock out the SPI data */
98 ao_spi_duplex(&d, &d, 2, AO_MMA655X_SPI_INDEX);
104 ao_mma655x_reg_write(uint8_t addr, uint8_t value)
108 addr |= (1 << 6); /* write mode */
109 d[0] = addr | (ao_parity(addr^value) << 7);
112 ao_spi_send(d, 2, AO_MMA655X_SPI_INDEX);
116 PRINTD("write %x %x = %x\n",
117 addr, value, ao_mma655x_reg_read(addr));
121 ao_mma655x_value(void)
126 d[0] = ((0 << 6) | /* Axis selection (X) */
127 (1 << 5) | /* Acceleration operation */
128 (1 << 4)); /* Raw data */
129 d[1] = ((1 << 3) | /* must be one */
130 (1 << 2) | /* Unsigned data */
131 (0 << 1) | /* Arm disabled */
132 (1 << 0)); /* Odd parity */
134 PRINTD("value SEND %02x %02x\n", d[0], d[1]);
135 ao_spi_send(d, 2, AO_MMA655X_SPI_INDEX);
136 ao_mma655x_restart();
139 ao_spi_duplex(d, d, 2, AO_MMA655X_SPI_INDEX);
141 PRINTD("value RECV %02x %02x\n", d[0], d[1]);
143 v = (uint16_t) d[1] << 2;
145 v |= (uint16_t) (d[0] & 3) << 10;
150 ao_mma655x_reset(void) {
151 ao_mma655x_reg_write(AO_MMA655X_DEVCTL,
152 (0 << AO_MMA655X_DEVCTL_RES_1) |
153 (0 << AO_MMA655X_DEVCTL_RES_1));
154 ao_mma655x_reg_write(AO_MMA655X_DEVCTL,
155 (1 << AO_MMA655X_DEVCTL_RES_1) |
156 (1 << AO_MMA655X_DEVCTL_RES_1));
157 ao_mma655x_reg_write(AO_MMA655X_DEVCTL,
158 (0 << AO_MMA655X_DEVCTL_RES_1) |
159 (1 << AO_MMA655X_DEVCTL_RES_1));
162 #define DEVCFG_VALUE (\
163 (1 << AO_MMA655X_DEVCFG_OC) | /* Disable offset cancelation */ \
164 (1 << AO_MMA655X_DEVCFG_SD) | /* Receive unsigned data */ \
165 (0 << AO_MMA655X_DEVCFG_OFMON) | /* Disable offset monitor */ \
166 (AO_MMA655X_DEVCFG_A_CFG_DISABLE << AO_MMA655X_DEVCFG_A_CFG))
168 #define AXISCFG_VALUE (\
169 (0 << AO_MMA655X_AXISCFG_LPF)) /* 100Hz 4-pole filter */
173 ao_mma655x_setup(void)
179 uint8_t s0, s1, s2, s3;
185 if (mma655x_configured)
187 mma655x_configured = 1;
188 ao_delay(AO_MS_TO_TICKS(10)); /* Top */
190 ao_delay(AO_MS_TO_TICKS(10)); /* Top */
191 (void) ao_mma655x_reg_read(AO_MMA655X_DEVSTAT);
192 v = ao_mma655x_reg_read(AO_MMA655X_DEVSTAT);
194 /* Configure R/W register values.
195 * Most of them relate to the arming feature, which
196 * we don't use, so the only registers we need to
197 * write are DEVCFG and AXISCFG
200 ao_mma655x_reg_write(AO_MMA655X_DEVCFG,
201 DEVCFG_VALUE | (0 << AO_MMA655X_DEVCFG_ENDINIT));
206 ao_mma655x_reg_write(AO_MMA655X_AXISCFG,
208 (1 << AO_MMA655X_AXISCFG_ST));
209 for (i = 0; i < 10; i++) {
210 a_st = ao_mma655x_value();
211 printf ("SELF-TEST %2d = %6d\n", i, a_st);
214 stdefl = ao_mma655x_reg_read(AO_MMA655X_STDEFL);
216 ao_mma655x_reg_write(AO_MMA655X_AXISCFG,
218 (0 << AO_MMA655X_AXISCFG_ST));
219 a = ao_mma655x_value();
221 for (i = 0; i < 10; i++) {
222 a = ao_mma655x_value();
223 printf("NORMAL %2d = %6d\n", i, a);
226 ao_mma655x_reg_write(AO_MMA655X_DEVCFG,
227 DEVCFG_VALUE | (1 << AO_MMA655X_DEVCFG_ENDINIT));
228 s0 = ao_mma655x_reg_read(AO_MMA655X_SN0);
229 s1 = ao_mma655x_reg_read(AO_MMA655X_SN1);
230 s2 = ao_mma655x_reg_read(AO_MMA655X_SN2);
231 s3 = ao_mma655x_reg_read(AO_MMA655X_SN3);
232 lot = ((uint32_t) s3 << 24) | ((uint32_t) s2 << 16) |
233 ((uint32_t) s1 << 8) | ((uint32_t) s0);
234 serial = lot & 0x1fff;
236 pn = ao_mma655x_reg_read(AO_MMA655X_PN);
237 printf ("MMA655X lot %d serial %d number %d\n", lot, serial, pn);
241 uint16_t ao_mma655x_current;
244 ao_mma655x_dump(void)
246 printf ("MMA655X value %d\n", ao_mma655x_current);
249 __code struct ao_cmds ao_mma655x_cmds[] = {
250 { ao_mma655x_dump, "A\0Display MMA655X data" },
259 ao_mma655x_current = ao_mma655x_value();
261 AO_DATA_PRESENT(AO_DATA_MMA655X);
267 static __xdata struct ao_task ao_mma655x_task;
270 ao_mma655x_init(void)
272 mma655x_configured = 0;
274 ao_cmd_register(&ao_mma655x_cmds[0]);
275 ao_spi_init_cs(AO_MMA655X_CS_PORT, (1 << AO_MMA655X_CS_PIN));
277 ao_add_task(&ao_mma655x_task, ao_mma655x, "mma655x");