diff --git a/_pi_hal_8h_source.html b/_pi_hal_8h_source.html index 7708e5cc..f113a1b1 100644 --- a/_pi_hal_8h_source.html +++ b/_pi_hal_8h_source.html @@ -120,249 +120,254 @@ $(document).ready(function(){initNavTree('_pi_hal_8h_source.html',''); initResiz
32  }
33 
34  void init() override {
-
35  // first initialise lgpio library
-
36  if((_gpioHandle = lgGpiochipOpen(_gpioDevice)) < 0) {
-
37  fprintf(stderr, "Could not open GPIO chip: %s\n", lguErrorText(_gpioHandle));
-
38  return;
-
39  }
-
40 
-
41  // now the SPI
-
42  spiBegin();
-
43  }
+
35  if(_gpioHandle != -1) {
+
36  return;
+
37  }
+
38 
+
39  // first initialise lgpio library
+
40  if((_gpioHandle = lgGpiochipOpen(_gpioDevice)) < 0) {
+
41  fprintf(stderr, "Could not open GPIO chip: %s\n", lguErrorText(_gpioHandle));
+
42  return;
+
43  }
44 
-
45  void term() override {
-
46  // stop the SPI
-
47  spiEnd();
+
45  // now the SPI
+
46  spiBegin();
+
47  }
48 
-
49  // finally, stop the lgpio library
-
50  lgGpiochipClose(_gpioHandle);
-
51  }
+
49  void term() override {
+
50  // stop the SPI
+
51  spiEnd();
52 
-
53  // GPIO-related methods (pinMode, digitalWrite etc.) should check
-
54  // RADIOLIB_NC as an alias for non-connected pins
-
55  void pinMode(uint32_t pin, uint32_t mode) override {
-
56  if(pin == RADIOLIB_NC) {
-
57  return;
-
58  }
-
59 
-
60  int result;
-
61  int flags = 0;
-
62  switch(mode) {
-
63  case PI_INPUT:
-
64  result = lgGpioClaimInput(_gpioHandle, 0, pin);
-
65  break;
-
66  case PI_OUTPUT:
-
67  result = lgGpioClaimOutput(_gpioHandle, flags, pin, LG_HIGH);
-
68  break;
-
69  default:
-
70  fprintf(stderr, "Unknown pinMode mode %" PRIu32 "\n", mode);
-
71  return;
-
72  }
-
73 
-
74  if(result < 0) {
-
75  fprintf(stderr, "Could not claim pin %" PRIu32 " for mode %" PRIu32 ": %s\n",
-
76  pin, mode, lguErrorText(result));
+
53  // finally, stop the lgpio library
+
54  lgGpiochipClose(_gpioHandle);
+
55  _gpioHandle = -1;
+
56  }
+
57 
+
58  // GPIO-related methods (pinMode, digitalWrite etc.) should check
+
59  // RADIOLIB_NC as an alias for non-connected pins
+
60  void pinMode(uint32_t pin, uint32_t mode) override {
+
61  if(pin == RADIOLIB_NC) {
+
62  return;
+
63  }
+
64 
+
65  int result;
+
66  int flags = 0;
+
67  switch(mode) {
+
68  case PI_INPUT:
+
69  result = lgGpioClaimInput(_gpioHandle, 0, pin);
+
70  break;
+
71  case PI_OUTPUT:
+
72  result = lgGpioClaimOutput(_gpioHandle, flags, pin, LG_HIGH);
+
73  break;
+
74  default:
+
75  fprintf(stderr, "Unknown pinMode mode %" PRIu32 "\n", mode);
+
76  return;
77  }
-
78  }
-
79 
-
80  void digitalWrite(uint32_t pin, uint32_t value) override {
-
81  if(pin == RADIOLIB_NC) {
-
82  return;
-
83  }
+
78 
+
79  if(result < 0) {
+
80  fprintf(stderr, "Could not claim pin %" PRIu32 " for mode %" PRIu32 ": %s\n",
+
81  pin, mode, lguErrorText(result));
+
82  }
+
83  }
84 
-
85  int result = lgGpioWrite(_gpioHandle, pin, value);
-
86  if(result < 0) {
-
87  fprintf(stderr, "Error writing value to pin %" PRIu32 ": %s\n", pin, lguErrorText(result));
+
85  void digitalWrite(uint32_t pin, uint32_t value) override {
+
86  if(pin == RADIOLIB_NC) {
+
87  return;
88  }
-
89  }
-
90 
-
91  uint32_t digitalRead(uint32_t pin) override {
-
92  if(pin == RADIOLIB_NC) {
-
93  return(0);
-
94  }
+
89 
+
90  int result = lgGpioWrite(_gpioHandle, pin, value);
+
91  if(result < 0) {
+
92  fprintf(stderr, "Error writing value to pin %" PRIu32 ": %s\n", pin, lguErrorText(result));
+
93  }
+
94  }
95 
-
96  int result = lgGpioRead(_gpioHandle, pin);
-
97  if(result < 0) {
-
98  fprintf(stderr, "Error writing reading from pin %" PRIu32 ": %s\n", pin, lguErrorText(result));
+
96  uint32_t digitalRead(uint32_t pin) override {
+
97  if(pin == RADIOLIB_NC) {
+
98  return(0);
99  }
-
100  return result;
-
101  }
-
102 
-
103  void attachInterrupt(uint32_t interruptNum, void (*interruptCb)(void), uint32_t mode) override {
-
104  if((interruptNum == RADIOLIB_NC) || (interruptNum > PI_MAX_USER_GPIO)) {
-
105  return;
-
106  }
+
100 
+
101  int result = lgGpioRead(_gpioHandle, pin);
+
102  if(result < 0) {
+
103  fprintf(stderr, "Error writing reading from pin %" PRIu32 ": %s\n", pin, lguErrorText(result));
+
104  }
+
105  return result;
+
106  }
107 
-
108  // set lgpio alert callback
-
109  int result = lgGpioClaimAlert(_gpioHandle, 0, mode, interruptNum, -1);
-
110  if(result < 0) {
-
111  fprintf(stderr, "Could not claim pin %" PRIu32 " for alert: %s\n", interruptNum, lguErrorText(result));
-
112  return;
-
113  }
-
114 
-
115  // enable emulated interrupt
-
116  interruptEnabled[interruptNum] = true;
-
117  interruptModes[interruptNum] = mode;
-
118  interruptCallbacks[interruptNum] = interruptCb;
+
108  void attachInterrupt(uint32_t interruptNum, void (*interruptCb)(void), uint32_t mode) override {
+
109  if((interruptNum == RADIOLIB_NC) || (interruptNum > PI_MAX_USER_GPIO)) {
+
110  return;
+
111  }
+
112 
+
113  // set lgpio alert callback
+
114  int result = lgGpioClaimAlert(_gpioHandle, 0, mode, interruptNum, -1);
+
115  if(result < 0) {
+
116  fprintf(stderr, "Could not claim pin %" PRIu32 " for alert: %s\n", interruptNum, lguErrorText(result));
+
117  return;
+
118  }
119 
-
120  lgGpioSetAlertsFunc(_gpioHandle, interruptNum, lgpioAlertHandler, (void *)this);
-
121  }
-
122 
-
123  void detachInterrupt(uint32_t interruptNum) override {
-
124  if((interruptNum == RADIOLIB_NC) || (interruptNum > PI_MAX_USER_GPIO)) {
-
125  return;
-
126  }
+
120  // enable emulated interrupt
+
121  interruptEnabled[interruptNum] = true;
+
122  interruptModes[interruptNum] = mode;
+
123  interruptCallbacks[interruptNum] = interruptCb;
+
124 
+
125  lgGpioSetAlertsFunc(_gpioHandle, interruptNum, lgpioAlertHandler, (void *)this);
+
126  }
127 
-
128  // clear emulated interrupt
-
129  interruptEnabled[interruptNum] = false;
-
130  interruptModes[interruptNum] = 0;
-
131  interruptCallbacks[interruptNum] = NULL;
+
128  void detachInterrupt(uint32_t interruptNum) override {
+
129  if((interruptNum == RADIOLIB_NC) || (interruptNum > PI_MAX_USER_GPIO)) {
+
130  return;
+
131  }
132 
-
133  // disable lgpio alert callback
-
134  lgGpioFree(_gpioHandle, interruptNum);
-
135  lgGpioSetAlertsFunc(_gpioHandle, interruptNum, NULL, NULL);
-
136  }
+
133  // clear emulated interrupt
+
134  interruptEnabled[interruptNum] = false;
+
135  interruptModes[interruptNum] = 0;
+
136  interruptCallbacks[interruptNum] = NULL;
137 
-
138  void delay(unsigned long ms) override {
-
139  if(ms == 0) {
-
140  sched_yield();
-
141  return;
-
142  }
-
143 
-
144  lguSleep(ms / 1000.0);
-
145  }
-
146 
-
147  void delayMicroseconds(unsigned long us) override {
-
148  if(us == 0) {
-
149  sched_yield();
-
150  return;
-
151  }
-
152 
-
153  lguSleep(us / 1000000.0);
-
154  }
-
155 
-
156  void yield() override {
-
157  sched_yield();
-
158  }
-
159 
-
160  unsigned long millis() override {
-
161  uint32_t time = lguTimestamp() / 1000000UL;
-
162  return time;
+
138  // disable lgpio alert callback
+
139  lgGpioFree(_gpioHandle, interruptNum);
+
140  lgGpioSetAlertsFunc(_gpioHandle, interruptNum, NULL, NULL);
+
141  }
+
142 
+
143  void delay(unsigned long ms) override {
+
144  if(ms == 0) {
+
145  sched_yield();
+
146  return;
+
147  }
+
148 
+
149  lguSleep(ms / 1000.0);
+
150  }
+
151 
+
152  void delayMicroseconds(unsigned long us) override {
+
153  if(us == 0) {
+
154  sched_yield();
+
155  return;
+
156  }
+
157 
+
158  lguSleep(us / 1000000.0);
+
159  }
+
160 
+
161  void yield() override {
+
162  sched_yield();
163  }
164 
-
165  unsigned long micros() override {
-
166  uint32_t time = lguTimestamp() / 1000UL;
+
165  unsigned long millis() override {
+
166  uint32_t time = lguTimestamp() / 1000000UL;
167  return time;
168  }
169 
-
170  long pulseIn(uint32_t pin, uint32_t state, unsigned long timeout) override {
-
171  if(pin == RADIOLIB_NC) {
-
172  return(0);
-
173  }
+
170  unsigned long micros() override {
+
171  uint32_t time = lguTimestamp() / 1000UL;
+
172  return time;
+
173  }
174 
-
175  this->pinMode(pin, PI_INPUT);
-
176  uint32_t start = this->micros();
-
177  uint32_t curtick = this->micros();
-
178 
-
179  while(this->digitalRead(pin) == state) {
-
180  if((this->micros() - curtick) > timeout) {
-
181  return(0);
-
182  }
-
183  }
-
184 
-
185  return(this->micros() - start);
-
186  }
-
187 
-
188  void spiBegin() {
-
189  if(_spiHandle < 0) {
-
190  if((_spiHandle = lgSpiOpen(_spiDevice, _spiChannel, _spiSpeed, 0)) < 0) {
-
191  fprintf(stderr, "Could not open SPI handle on 0: %s\n", lguErrorText(_spiHandle));
-
192  }
-
193  }
-
194  }
-
195 
-
196  void spiBeginTransaction() {}
-
197 
-
198  void spiTransfer(uint8_t* out, size_t len, uint8_t* in) {
-
199  int result = lgSpiXfer(_spiHandle, (char *)out, (char*)in, len);
-
200  if(result < 0) {
-
201  fprintf(stderr, "Could not perform SPI transfer: %s\n", lguErrorText(result));
-
202  }
-
203  }
-
204 
-
205  void spiEndTransaction() {}
-
206 
-
207  void spiEnd() {
-
208  if(_spiHandle >= 0) {
-
209  lgSpiClose(_spiHandle);
-
210  _spiHandle = -1;
-
211  }
-
212  }
-
213 
-
214  void tone(uint32_t pin, unsigned int frequency, unsigned long duration = 0) {
-
215  lgTxPwm(_gpioHandle, pin, frequency, 50, 0, duration);
-
216  }
-
217 
-
218  void noTone(uint32_t pin) {
-
219  lgTxPwm(_gpioHandle, pin, 0, 0, 0, 0);
-
220  }
-
221 
-
222  // interrupt emulation
-
223  bool interruptEnabled[PI_MAX_USER_GPIO + 1];
-
224  uint32_t interruptModes[PI_MAX_USER_GPIO + 1];
-
225  typedef void (*RadioLibISR)(void);
-
226  RadioLibISR interruptCallbacks[PI_MAX_USER_GPIO + 1];
-
227 
-
228  private:
-
229  // the HAL can contain any additional private members
-
230  const unsigned int _spiSpeed;
-
231  const uint8_t _gpioDevice;
-
232  const uint8_t _spiDevice;
-
233  const uint8_t _spiChannel;
-
234  int _gpioHandle = -1;
-
235  int _spiHandle = -1;
-
236 };
-
237 
-
238 // this handler emulates interrupts
-
239 static void lgpioAlertHandler(int num_alerts, lgGpioAlert_p alerts, void *userdata) {
-
240  if(!userdata)
-
241  return;
+
175  long pulseIn(uint32_t pin, uint32_t state, unsigned long timeout) override {
+
176  if(pin == RADIOLIB_NC) {
+
177  return(0);
+
178  }
+
179 
+
180  this->pinMode(pin, PI_INPUT);
+
181  uint32_t start = this->micros();
+
182  uint32_t curtick = this->micros();
+
183 
+
184  while(this->digitalRead(pin) == state) {
+
185  if((this->micros() - curtick) > timeout) {
+
186  return(0);
+
187  }
+
188  }
+
189 
+
190  return(this->micros() - start);
+
191  }
+
192 
+
193  void spiBegin() {
+
194  if(_spiHandle < 0) {
+
195  if((_spiHandle = lgSpiOpen(_spiDevice, _spiChannel, _spiSpeed, 0)) < 0) {
+
196  fprintf(stderr, "Could not open SPI handle on 0: %s\n", lguErrorText(_spiHandle));
+
197  }
+
198  }
+
199  }
+
200 
+
201  void spiBeginTransaction() {}
+
202 
+
203  void spiTransfer(uint8_t* out, size_t len, uint8_t* in) {
+
204  int result = lgSpiXfer(_spiHandle, (char *)out, (char*)in, len);
+
205  if(result < 0) {
+
206  fprintf(stderr, "Could not perform SPI transfer: %s\n", lguErrorText(result));
+
207  }
+
208  }
+
209 
+
210  void spiEndTransaction() {}
+
211 
+
212  void spiEnd() {
+
213  if(_spiHandle >= 0) {
+
214  lgSpiClose(_spiHandle);
+
215  _spiHandle = -1;
+
216  }
+
217  }
+
218 
+
219  void tone(uint32_t pin, unsigned int frequency, unsigned long duration = 0) {
+
220  lgTxPwm(_gpioHandle, pin, frequency, 50, 0, duration);
+
221  }
+
222 
+
223  void noTone(uint32_t pin) {
+
224  lgTxPwm(_gpioHandle, pin, 0, 0, 0, 0);
+
225  }
+
226 
+
227  // interrupt emulation
+
228  bool interruptEnabled[PI_MAX_USER_GPIO + 1];
+
229  uint32_t interruptModes[PI_MAX_USER_GPIO + 1];
+
230  typedef void (*RadioLibISR)(void);
+
231  RadioLibISR interruptCallbacks[PI_MAX_USER_GPIO + 1];
+
232 
+
233  private:
+
234  // the HAL can contain any additional private members
+
235  const unsigned int _spiSpeed;
+
236  const uint8_t _gpioDevice;
+
237  const uint8_t _spiDevice;
+
238  const uint8_t _spiChannel;
+
239  int _gpioHandle = -1;
+
240  int _spiHandle = -1;
+
241 };
242 
-
243  // PiHal instance is passed via the user data
-
244  PiHal* hal = (PiHal*)userdata;
-
245 
-
246  // check the interrupt is enabled, the level matches and a callback exists
-
247  for(lgGpioAlert_t *alert = alerts; alert < (alerts + num_alerts); alert++) {
-
248  if((hal->interruptEnabled[alert->report.gpio]) &&
-
249  (hal->interruptModes[alert->report.gpio] == alert->report.level) &&
-
250  (hal->interruptCallbacks[alert->report.gpio])) {
-
251  hal->interruptCallbacks[alert->report.gpio]();
-
252  }
-
253  }
-
254 }
-
255 
-
256 #endif
+
243 // this handler emulates interrupts
+
244 static void lgpioAlertHandler(int num_alerts, lgGpioAlert_p alerts, void *userdata) {
+
245  if(!userdata)
+
246  return;
+
247 
+
248  // PiHal instance is passed via the user data
+
249  PiHal* hal = (PiHal*)userdata;
+
250 
+
251  // check the interrupt is enabled, the level matches and a callback exists
+
252  for(lgGpioAlert_t *alert = alerts; alert < (alerts + num_alerts); alert++) {
+
253  if((hal->interruptEnabled[alert->report.gpio]) &&
+
254  (hal->interruptModes[alert->report.gpio] == alert->report.level) &&
+
255  (hal->interruptCallbacks[alert->report.gpio])) {
+
256  hal->interruptCallbacks[alert->report.gpio]();
+
257  }
+
258  }
+
259 }
+
260 
+
261 #endif
PiHal
Definition: PiHal.h:23
-
PiHal::noTone
void noTone(uint32_t pin)
Method to stop producing a tone.
Definition: PiHal.h:218
-
PiHal::millis
unsigned long millis() override
Get number of milliseconds since start. Must be implemented by the platform-specific hardware abstrac...
Definition: PiHal.h:160
-
PiHal::digitalWrite
void digitalWrite(uint32_t pin, uint32_t value) override
Digital write method. Must be implemented by the platform-specific hardware abstraction!
Definition: PiHal.h:80
-
PiHal::pulseIn
long pulseIn(uint32_t pin, uint32_t state, unsigned long timeout) override
Measure the length of incoming digital pulse in microseconds. Must be implemented by the platform-spe...
Definition: PiHal.h:170
-
PiHal::spiBegin
void spiBegin()
SPI initialization method.
Definition: PiHal.h:188
-
PiHal::spiEnd
void spiEnd()
SPI termination method.
Definition: PiHal.h:207
+
PiHal::noTone
void noTone(uint32_t pin)
Method to stop producing a tone.
Definition: PiHal.h:223
+
PiHal::millis
unsigned long millis() override
Get number of milliseconds since start. Must be implemented by the platform-specific hardware abstrac...
Definition: PiHal.h:165
+
PiHal::digitalWrite
void digitalWrite(uint32_t pin, uint32_t value) override
Digital write method. Must be implemented by the platform-specific hardware abstraction!
Definition: PiHal.h:85
+
PiHal::pulseIn
long pulseIn(uint32_t pin, uint32_t state, unsigned long timeout) override
Measure the length of incoming digital pulse in microseconds. Must be implemented by the platform-spe...
Definition: PiHal.h:175
+
PiHal::spiBegin
void spiBegin()
SPI initialization method.
Definition: PiHal.h:193
+
PiHal::spiEnd
void spiEnd()
SPI termination method.
Definition: PiHal.h:212
PiHal::init
void init() override
Module initialization method. This will be called by all radio modules at the beginning of startup....
Definition: PiHal.h:34
-
PiHal::spiEndTransaction
void spiEndTransaction()
Method to end SPI transaction.
Definition: PiHal.h:205
-
PiHal::tone
void tone(uint32_t pin, unsigned int frequency, unsigned long duration=0)
Method to produce a square-wave with 50% duty cycle ("tone") of a given frequency at some pin.
Definition: PiHal.h:214
-
PiHal::spiTransfer
void spiTransfer(uint8_t *out, size_t len, uint8_t *in)
Method to transfer buffer over SPI.
Definition: PiHal.h:198
-
PiHal::micros
unsigned long micros() override
Get number of microseconds since start. Must be implemented by the platform-specific hardware abstrac...
Definition: PiHal.h:165
-
PiHal::spiBeginTransaction
void spiBeginTransaction()
Method to start SPI transaction.
Definition: PiHal.h:196
-
PiHal::digitalRead
uint32_t digitalRead(uint32_t pin) override
Digital read method. Must be implemented by the platform-specific hardware abstraction!
Definition: PiHal.h:91
-
PiHal::delayMicroseconds
void delayMicroseconds(unsigned long us) override
Blocking microsecond wait function. Must be implemented by the platform-specific hardware abstraction...
Definition: PiHal.h:147
-
PiHal::attachInterrupt
void attachInterrupt(uint32_t interruptNum, void(*interruptCb)(void), uint32_t mode) override
Method to attach function to an external interrupt. Must be implemented by the platform-specific hard...
Definition: PiHal.h:103
-
PiHal::pinMode
void pinMode(uint32_t pin, uint32_t mode) override
GPIO pin mode (input/output/...) configuration method. Must be implemented by the platform-specific h...
Definition: PiHal.h:55
-
PiHal::delay
void delay(unsigned long ms) override
Blocking wait function. Must be implemented by the platform-specific hardware abstraction!
Definition: PiHal.h:138
-
PiHal::term
void term() override
Module termination method. This will be called by all radio modules when the destructor is called....
Definition: PiHal.h:45
-
PiHal::yield
void yield() override
Yield method, called from long loops in multi-threaded environment (to prevent blocking other threads...
Definition: PiHal.h:156
-
PiHal::detachInterrupt
void detachInterrupt(uint32_t interruptNum) override
Method to detach function from an external interrupt. Must be implemented by the platform-specific ha...
Definition: PiHal.h:123
+
PiHal::spiEndTransaction
void spiEndTransaction()
Method to end SPI transaction.
Definition: PiHal.h:210
+
PiHal::tone
void tone(uint32_t pin, unsigned int frequency, unsigned long duration=0)
Method to produce a square-wave with 50% duty cycle ("tone") of a given frequency at some pin.
Definition: PiHal.h:219
+
PiHal::spiTransfer
void spiTransfer(uint8_t *out, size_t len, uint8_t *in)
Method to transfer buffer over SPI.
Definition: PiHal.h:203
+
PiHal::micros
unsigned long micros() override
Get number of microseconds since start. Must be implemented by the platform-specific hardware abstrac...
Definition: PiHal.h:170
+
PiHal::spiBeginTransaction
void spiBeginTransaction()
Method to start SPI transaction.
Definition: PiHal.h:201
+
PiHal::digitalRead
uint32_t digitalRead(uint32_t pin) override
Digital read method. Must be implemented by the platform-specific hardware abstraction!
Definition: PiHal.h:96
+
PiHal::delayMicroseconds
void delayMicroseconds(unsigned long us) override
Blocking microsecond wait function. Must be implemented by the platform-specific hardware abstraction...
Definition: PiHal.h:152
+
PiHal::attachInterrupt
void attachInterrupt(uint32_t interruptNum, void(*interruptCb)(void), uint32_t mode) override
Method to attach function to an external interrupt. Must be implemented by the platform-specific hard...
Definition: PiHal.h:108
+
PiHal::pinMode
void pinMode(uint32_t pin, uint32_t mode) override
GPIO pin mode (input/output/...) configuration method. Must be implemented by the platform-specific h...
Definition: PiHal.h:60
+
PiHal::delay
void delay(unsigned long ms) override
Blocking wait function. Must be implemented by the platform-specific hardware abstraction!
Definition: PiHal.h:143
+
PiHal::term
void term() override
Module termination method. This will be called by all radio modules when the destructor is called....
Definition: PiHal.h:49
+
PiHal::yield
void yield() override
Yield method, called from long loops in multi-threaded environment (to prevent blocking other threads...
Definition: PiHal.h:161
+
PiHal::detachInterrupt
void detachInterrupt(uint32_t interruptNum) override
Method to detach function from an external interrupt. Must be implemented by the platform-specific ha...
Definition: PiHal.h:128
RadioLibHal
Hardware abstraction library base interface.
Definition: Hal.h:13
RadioLibHal::RadioLibHal
RadioLibHal(const uint32_t input, const uint32_t output, const uint32_t low, const uint32_t high, const uint32_t rising, const uint32_t falling)
Default constructor.
Definition: Hal.cpp:3