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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
/*
* spreadspace avr utils
*
*
* Copyright (C) 2013-2015 Christian Pointner <equinox@spreadspace.org>
*
* This file is part of spreadspace avr utils.
*
* spreadspace avr utils is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* spreadspace avr utils is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with spreadspace avr utils. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include "cc1101.h"
#include "cc1101_defines.h"
static cc1101_driver_conf_t drv = {
.spi_cs_enable = NULL,
.spi_cs_disable = NULL,
.spi_read_miso = NULL,
.spi_write_byte = NULL,
.spi_read_byte = NULL,
.spi_transfer_byte = NULL,
.freq_corr = 1.0
};
/*
* internal functions
*/
static inline void cc1101_spi_wait_rdy(void)
{
while(drv.spi_read_miso()); // wait for CHP_RDY to go low, TODO: timeout...
}
static uint8_t cc1101_spi_strobe_command(uint8_t cmd)
{
if(cmd < CC1101_CMD_MIN || cmd > CC1101_CMD_MAX)
return -1;
drv.spi_cs_enable();
cc1101_spi_wait_rdy();
uint8_t status = drv.spi_transfer_byte(CC1101_HEADER_COMMAND | cmd);
drv.spi_cs_disable();
return status;
}
static uint8_t cc1101_spi_read_register(uint8_t addr)
{
if(addr > CC1101_ADDR_MAX)
return 0xFF;
if(addr > CC1101_REG_RW_MAX)
addr |= CC1101_HEADER_READONLY;
else
addr |= CC1101_HEADER_READ;
drv.spi_cs_enable();
cc1101_spi_wait_rdy();
drv.spi_write_byte(addr);
uint8_t data = drv.spi_read_byte();
drv.spi_cs_disable();
return data;
}
static void cc1101_spi_write_register(uint8_t addr, uint8_t data)
{
if(addr > CC1101_REG_RW_MAX)
return;
drv.spi_cs_enable();
cc1101_spi_wait_rdy();
drv.spi_write_byte(CC1101_HEADER_WRITE | addr);
drv.spi_write_byte(data);
drv.spi_cs_disable();
}
/*
* EXTERNAL INTERFACE
*/
void cc1101_init(cc1101_driver_conf_t conf)
{
drv = conf;
}
void cc1101_reg_init(void)
{
// TODO: init register depending on mode beacon vs. data
}
void cc1101_soft_reset(void)
{
cc1101_spi_strobe_command(CC1101_CMD_SRES);
}
void cc1101_powerdown(void)
{
cc1101_spi_strobe_command(CC1101_CMD_SPWD);
}
void cc1101_set_freq_hz(uint32_t hz)
{
uint32_t freq = (uint32_t)((float)hz / drv.freq_corr);
if(freq <= 0x3FFFFF)
// TODO: this is only allowed in idle mode
cc1101_spi_write_register(CC1101_REG_RW_FREQ0, freq & 0xFF);
cc1101_spi_write_register(CC1101_REG_RW_FREQ1, (freq >> 8) & 0xFF);
cc1101_spi_write_register(CC1101_REG_RW_FREQ2, (freq >> 16) & 0x3F);
}
uint32_t cc1101_get_freq_hz(void)
{
uint32_t freq = 0;
freq = cc1101_spi_read_register(CC1101_REG_RW_FREQ2) & 0x3F;
freq = freq << 8;
freq |= cc1101_spi_read_register(CC1101_REG_RW_FREQ1);
freq = freq << 8;
freq |= cc1101_spi_read_register(CC1101_REG_RW_FREQ0);
return (uint32_t)((float)freq * drv.freq_corr);
}
static char* cc1101_config_reg_to_string(uint8_t addr)
{
switch(addr) {
case CC1101_REG_RW_IOCFG2: return "IOCFG2";
case CC1101_REG_RW_IOCFG1: return "IOCFG1";
case CC1101_REG_RW_IOCFG0: return "IOCFG0";
case CC1101_REG_RW_FIFOTHR: return "FIFOTHR";
case CC1101_REG_RW_SYNC1: return "SYNC1";
case CC1101_REG_RW_SYNC0: return "SYNC0";
case CC1101_REG_RW_PKTLEN: return "PKTLEN";
case CC1101_REG_RW_PKTCTRL1: return "PKTCTRL1";
case CC1101_REG_RW_PKTCTRL0: return "PKTCTRL0";
case CC1101_REG_RW_ADDR: return "ADDR";
case CC1101_REG_RW_CHANNR: return "CHANNR";
case CC1101_REG_RW_FSCTRL1: return "FSCTRL1";
case CC1101_REG_RW_FSCTRL0: return "FSCTRL0";
case CC1101_REG_RW_FREQ2: return "FREQ2";
case CC1101_REG_RW_FREQ1: return "FREQ1";
case CC1101_REG_RW_FREQ0: return "FREQ0";
case CC1101_REG_RW_MDMCFG4: return "MDMCFG4";
case CC1101_REG_RW_MDMCFG3: return "MDMCFG3";
case CC1101_REG_RW_MDMCFG2: return "MDMCFG2";
case CC1101_REG_RW_MDMCFG1: return "MDMCFG1";
case CC1101_REG_RW_MDMCFG0: return "MDMCFG0";
case CC1101_REG_RW_DEVIATN: return "DEVIATN";
case CC1101_REG_RW_MCSM2: return "MCSM2";
case CC1101_REG_RW_MCSM1: return "MCSM1";
case CC1101_REG_RW_MCSM0: return "MCSM0";
case CC1101_REG_RW_FOCCFG: return "FOCCFG";
case CC1101_REG_RW_BSCFG: return "BSCFG";
case CC1101_REG_RW_AGCCTRL2: return "AGCCTRL2";
case CC1101_REG_RW_AGCCTRL1: return "AGCCTRL1";
case CC1101_REG_RW_AGCCTRL0: return "AGCCTRL0";
case CC1101_REG_RW_WOREVT1: return "WOREVT1";
case CC1101_REG_RW_WOREVT0: return "WOREVT0";
case CC1101_REG_RW_WORCTRL: return "WORCTRL";
case CC1101_REG_RW_FREND1: return "FREND1";
case CC1101_REG_RW_FREND0: return "FREND0";
case CC1101_REG_RW_FSCAL3: return "FSCAL3";
case CC1101_REG_RW_FSCAL2: return "FSCAL2";
case CC1101_REG_RW_FSCAL1: return "FSCAL1";
case CC1101_REG_RW_FSCAL0: return "FSCAL0";
case CC1101_REG_RW_RCCTRL1: return "RCCTRL1";
case CC1101_REG_RW_RCCTRL0: return "RCCTRL0";
case CC1101_REG_RW_FSTEST: return "FSTEST";
case CC1101_REG_RW_PTEST: return "PTEST";
case CC1101_REG_RW_AGCTEST: return "AGCTEST";
case CC1101_REG_RW_TEST2: return "TEST2";
case CC1101_REG_RW_TEST1: return "TEST1";
case CC1101_REG_RW_TEST0: return "TEST0";
default: return "unknown";
}
}
static char* cc1101_status_reg_to_string(uint8_t addr)
{
switch(addr) {
case CC1101_REG_RO_PARTNUM: return "PARTNUM";
case CC1101_REG_RO_VERSION: return "VERSION";
case CC1101_REG_RO_FREQUEST: return "FREQUEST";
case CC1101_REG_RO_LQI: return "LQI";
case CC1101_REG_RO_RSSI: return "RSSI";
case CC1101_REG_RO_MARCSTATE: return "MARCSTATE";
case CC1101_REG_RO_WORTIME1: return "WORTIME1";
case CC1101_REG_RO_WORTIME0: return "WORTIME0";
case CC1101_REG_RO_PKTSTATUS: return "PKTSTATUS";
case CC1101_REG_RO_VCO_VC_DAC: return "VCO_VC_DAC";
case CC1101_REG_RO_TXBYTES: return "TXBYTES";
case CC1101_REG_RO_RXBYTES: return "RXBYTES";
case CC1101_REG_RO_RCCTRL1_STATUS: return "RCCTRL1_STATUS";
case CC1101_REG_RO_RCCTRL0_STATUS: return "RCCTRL0_STATUS";
default: return "unknown";
}
}
void cc1101_dump_register(void)
{
printf("CC1101: register dump\r\n\r\n");
int i;
printf(" config (read/write) register:\r\n");
for(i=0; i<=CC1101_REG_RW_MAX; ++i) {
uint8_t data = cc1101_spi_read_register(i); // TODO: use burst mode...
printf(" 0x%02X (%s): 0x%02X\r\n", i, cc1101_config_reg_to_string(i), data);
}
printf("\r\n");
printf(" status (read-only) register:\r\n");
for(i=CC1101_REG_RO_MIN; i<=CC1101_REG_RO_MAX; ++i) {
uint8_t data = cc1101_spi_read_register(i);
printf(" 0x%02X (%s): 0x%02X\r\n", i, cc1101_status_reg_to_string(i), data);
}
printf("\r\n");
}
|
