Devin Alexander / Mbed OS Low_Power_Long_Distance_IR_Vision_Robot

This is example code that can get you started with building your own IR vision robot that communicates over LoRa

Dependencies:   Adafruit-MotorShield Adafruit-PWM-Servo-Driver Adafruit_GFX BufferedSerial MAX17055_EZconfig NEO-6m-GPS SX1276GenericLib USBDeviceHT max32630fthr max77650_charger_sample

Fork of MAX326xxFTHR_LoRa_Example_test by Devin Alexander

main.cpp@43:b38b934d82e6, 2018-08-15 (annotated)

Committer:
dev_alexander
Date:
Wed Aug 15 04:12:27 2018 +0000
Revision:
43:b38b934d82e6
Parent:
42:911770814147 
Commit after publishing fork of Adafruit_GFX library

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Helmut64 0:c43b6919ae15 1 /*
dev_alexander 21:1b92cabe8a3b 2 * For Wiring Instructions, please visit the link below:
dev_alexander 21:1b92cabe8a3b 3 * https://www.hackster.io/DevinAlex64/getting-started-with-the-max32620fthr-and-lora-f9d8dd\
dev_alexander 21:1b92cabe8a3b 4 */
dev_alexander 40:6f8744c366c2 5
dev_alexander 40:6f8744c366c2 6 /***************************************************************************
dev_alexander 40:6f8744c366c2 7 * Misc Instantiation
dev_alexander 40:6f8744c366c2 8 **************************************************************************/\
dev_alexander 40:6f8744c366c2 9 #include "mbed.h"
dev_alexander 30:66f9750cc44c 10 #include "main.h"
dev_alexander 30:66f9750cc44c 11 #include "global_buffers.h"
dev_alexander 35:bae9b236070b 12 //#define DEBUG_GRID_EYE
dev_alexander 41:1381a49e019e 13 //#define DEBUG_MAX17055
dev_alexander 32:b108ed6096b0 14 #define RASPBERRY_PI
dev_alexander 42:911770814147 15 #define NUM_TIMEOUTS_TO_STOP_ROBOT 15
dev_alexander 42:911770814147 16 #define OLED_FREQ 1000
dev_alexander 42:911770814147 17
dev_alexander 40:6f8744c366c2 18 DigitalOut myled(LED);
dev_alexander 40:6f8744c366c2 19 Serial pc(USBTX, USBRX);
dev_alexander 23:f74a50977593 20
dev_alexander 40:6f8744c366c2 21 I2C i2cBus0(P1_6, P1_7);
dev_alexander 40:6f8744c366c2 22 I2C i2cBus1(P3_4, P3_5);
dev_alexander 40:6f8744c366c2 23 I2C i2cBus2(P5_7, P6_0);
dev_alexander 32:b108ed6096b0 24
dev_alexander 40:6f8744c366c2 25 /***************************************************************************
dev_alexander 40:6f8744c366c2 26 * MAX32630FTHR Instantiation
dev_alexander 40:6f8744c366c2 27 **************************************************************************/
dev_alexander 40:6f8744c366c2 28 #if defined(TARGET_MAX32630FTHR)
dev_alexander 40:6f8744c366c2 29 /* If the board that is compiled is the master device (BLE enabled MAX32630FTHR),
dev_alexander 40:6f8744c366c2 30 * then it needs this library and needs to be configed in order for the device to
dev_alexander 40:6f8744c366c2 31 * work with a 3.3volt output instead of a 1.8 volt output.
dev_alexander 40:6f8744c366c2 32 *
dev_alexander 40:6f8744c366c2 33 * This is only needed for the MAX32630FTHR. The MAX325620FTHR is exampt from this
dev_alexander 40:6f8744c366c2 34 * additional setup in the main program.
dev_alexander 40:6f8744c366c2 35 */
dev_alexander 40:6f8744c366c2 36 #include "max32630fthr.h"
dev_alexander 40:6f8744c366c2 37 MAX32630FTHR pegasus(MAX32630FTHR::VIO_3V3);
dev_alexander 32:b108ed6096b0 38 #endif
dev_alexander 32:b108ed6096b0 39
dev_alexander 40:6f8744c366c2 40 /***************************************************************************
dev_alexander 40:6f8744c366c2 41 * MAX32620FTHR Instantiation
dev_alexander 40:6f8744c366c2 42 **************************************************************************/
dev_alexander 32:b108ed6096b0 43 #if defined(TARGET_MAX32620FTHR)
dev_alexander 32:b108ed6096b0 44
dev_alexander 29:f7a0e49b826b 45 #endif
Helmut64 0:c43b6919ae15 46
dev_alexander 31:f15747cffb20 47
dev_alexander 40:6f8744c366c2 48 /***************************************************************************
dev_alexander 40:6f8744c366c2 49 * Grid Eye Sensor Instantiation
dev_alexander 40:6f8744c366c2 50 **************************************************************************/
dev_alexander 40:6f8744c366c2 51 #include "GridEye.h"
Helmut64 0:c43b6919ae15 52
dev_alexander 23:f74a50977593 53 #if defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway
dev_alexander 23:f74a50977593 54 /* No grid eye object needed. The function the master uses to convert the raw
dev_alexander 23:f74a50977593 55 * data that is sent over from the slave deevice that contains the data from the
dev_alexander 23:f74a50977593 56 * actual grid eye sensor is actually a function that is not part of the grid eye
dev_alexander 23:f74a50977593 57 * class. this is due to the fact that the grid eye class requires n i2c bus to
dev_alexander 23:f74a50977593 58 * be assigned to a phyiscal sensor. In this case, the library for the Grid Eye
dev_alexander 32:b108ed6096b0 59 * sensor has a support function that is used to convert data that is aquired from
dev_alexander 23:f74a50977593 60 * the grid eye sensor. So it is not supposed to be a class specific function.
dev_alexander 40:6f8744c366c2 61 */
dev_alexander 40:6f8744c366c2 62 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 63 GridEye gridEye(i2cBus0);
dev_alexander 40:6f8744c366c2 64 #endif
dev_alexander 40:6f8744c366c2 65
dev_alexander 40:6f8744c366c2 66 /***************************************************************************
dev_alexander 40:6f8744c366c2 67 * GPS Instantiation
dev_alexander 40:6f8744c366c2 68 **************************************************************************/
dev_alexander 40:6f8744c366c2 69 #if defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway
dev_alexander 40:6f8744c366c2 70 // No GPS module on the master device
dev_alexander 40:6f8744c366c2 71 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 72 #include "GPS.h"
dev_alexander 40:6f8744c366c2 73 GPS gps(P0_1, P0_0, 115200); // (Tx, Rx, Baud rate)
dev_alexander 40:6f8744c366c2 74 #endif
dev_alexander 40:6f8744c366c2 75
dev_alexander 40:6f8744c366c2 76 /***************************************************************************
dev_alexander 40:6f8744c366c2 77 * MAX77650 Instatiation
dev_alexander 40:6f8744c366c2 78 **************************************************************************/
dev_alexander 40:6f8744c366c2 79 #if defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway
dev_alexander 40:6f8744c366c2 80 // No MAX77650 PMIC on this board
dev_alexander 40:6f8744c366c2 81 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 82 #include "max77650.h"
dev_alexander 40:6f8744c366c2 83
dev_alexander 40:6f8744c366c2 84 // Definitions for running board off of battery
dev_alexander 40:6f8744c366c2 85 #define POWER_HOLD_ON 1
dev_alexander 40:6f8744c366c2 86 #define POWER_HOLD_OFF 0
dev_alexander 40:6f8744c366c2 87
dev_alexander 40:6f8744c366c2 88 /* This is the pin that the MAX77650's Power Hold pin is connected to on MAX32620FTHR
dev_alexander 40:6f8744c366c2 89 * Without programming it to POWER_HOLD_ON, the device cant be started off of battery
dev_alexander 40:6f8744c366c2 90 * power alone.
dev_alexander 40:6f8744c366c2 91 */
dev_alexander 40:6f8744c366c2 92 DigitalOut pw_Hold(P2_2, POWER_HOLD_ON);
dev_alexander 40:6f8744c366c2 93
dev_alexander 40:6f8744c366c2 94 // Instatiate instance of the Simo Pimic
dev_alexander 40:6f8744c366c2 95 MAX77650 simo_pmic(i2cBus2);
dev_alexander 40:6f8744c366c2 96
dev_alexander 40:6f8744c366c2 97 // Battery Charger Interrupt
dev_alexander 40:6f8744c366c2 98 InterruptIn simoIRQ(P2_3);
dev_alexander 40:6f8744c366c2 99
dev_alexander 40:6f8744c366c2 100 void charger_Detect();
dev_alexander 40:6f8744c366c2 101 bool chrg_State_fn();
dev_alexander 40:6f8744c366c2 102 #endif
dev_alexander 40:6f8744c366c2 103
dev_alexander 40:6f8744c366c2 104
dev_alexander 40:6f8744c366c2 105 /***************************************************************************
dev_alexander 40:6f8744c366c2 106 * MAX17055 Instatiation
dev_alexander 40:6f8744c366c2 107 **************************************************************************/
dev_alexander 40:6f8744c366c2 108 #if defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway
dev_alexander 40:6f8744c366c2 109 // No MAX77650 PMIC on this board
dev_alexander 40:6f8744c366c2 110 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 111 #include "max17055.h"
dev_alexander 40:6f8744c366c2 112
dev_alexander 40:6f8744c366c2 113 MAX17055 fuelGauge(i2cBus2);
dev_alexander 40:6f8744c366c2 114 MAX17055::platform_data design_param;
dev_alexander 40:6f8744c366c2 115
dev_alexander 40:6f8744c366c2 116 #endif
dev_alexander 40:6f8744c366c2 117
dev_alexander 40:6f8744c366c2 118
dev_alexander 40:6f8744c366c2 119 /***************************************************************************
dev_alexander 40:6f8744c366c2 120 * OLED Instatiation
dev_alexander 40:6f8744c366c2 121 **************************************************************************/
dev_alexander 40:6f8744c366c2 122 #if defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway
dev_alexander 40:6f8744c366c2 123 #include "Adafruit_SSD1306.h"
dev_alexander 40:6f8744c366c2 124 #include "maxim_bitmap.h"
dev_alexander 40:6f8744c366c2 125 Adafruit_SSD1306_I2c displayOled(i2cBus1);
dev_alexander 40:6f8744c366c2 126
dev_alexander 40:6f8744c366c2 127
dev_alexander 32:b108ed6096b0 128 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 129 /* Currently, there is no OLED display attached to the MAX32620,
dev_alexander 40:6f8744c366c2 130 * so we are not compiling for it at the moment
dev_alexander 40:6f8744c366c2 131 */
dev_alexander 40:6f8744c366c2 132 #endif
dev_alexander 40:6f8744c366c2 133
dev_alexander 40:6f8744c366c2 134
dev_alexander 40:6f8744c366c2 135 /***************************************************************************
dev_alexander 40:6f8744c366c2 136 * BLE Instatiation and Related Functions
dev_alexander 40:6f8744c366c2 137 **************************************************************************/
dev_alexander 40:6f8744c366c2 138 #if defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway
dev_alexander 40:6f8744c366c2 139 #include "ble/BLE.h"
dev_alexander 40:6f8744c366c2 140 //#include "ble/Gap.h"
dev_alexander 40:6f8744c366c2 141 #include "UARTService_custom.h"
dev_alexander 40:6f8744c366c2 142 #include <events/mbed_events.h>
dev_alexander 40:6f8744c366c2 143
dev_alexander 40:6f8744c366c2 144 DigitalOut led2(LED2);
dev_alexander 40:6f8744c366c2 145 UARTService *uart;
dev_alexander 40:6f8744c366c2 146
dev_alexander 40:6f8744c366c2 147 #define NEED_CONSOLE_OUTPUT 1 /* Set this if you need debug messages on the console;
dev_alexander 40:6f8744c366c2 148 * it will have an impact on code-size and power consumption. */
dev_alexander 40:6f8744c366c2 149
dev_alexander 40:6f8744c366c2 150 #if NEED_CONSOLE_OUTPUT
dev_alexander 40:6f8744c366c2 151 #define DEBUG(STR) { if (uart) uart->write(STR, strlen(STR)); }
dev_alexander 40:6f8744c366c2 152 #define READ(STR) { if (uart) uart->read(STR, strlen(STR)); }
dev_alexander 40:6f8744c366c2 153
dev_alexander 40:6f8744c366c2 154 #else
dev_alexander 40:6f8744c366c2 155 #define DEBUG(...) /* nothing */
dev_alexander 40:6f8744c366c2 156 #endif /* #if NEED_CONSOLE_OUTPUT */
dev_alexander 40:6f8744c366c2 157
dev_alexander 40:6f8744c366c2 158 //Triggered when the robot is disconnected from the mobile app.
dev_alexander 40:6f8744c366c2 159 void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
dev_alexander 40:6f8744c366c2 160 {
dev_alexander 40:6f8744c366c2 161 BLE &ble = BLE::Instance();
dev_alexander 40:6f8744c366c2 162 DEBUG("Disconnected!\n\r");
dev_alexander 40:6f8744c366c2 163 DEBUG("Restarting the advertising process\n\r");
dev_alexander 40:6f8744c366c2 164 ble.gap().startAdvertising();
dev_alexander 40:6f8744c366c2 165 }
dev_alexander 40:6f8744c366c2 166
dev_alexander 40:6f8744c366c2 167 /* This pointer is needed to reference data in the main program when filling
dev_alexander 40:6f8744c366c2 168 * with data from the BLE
dev_alexander 40:6f8744c366c2 169 */
dev_alexander 40:6f8744c366c2 170 uint8_t * onDataWritten_curr_ble_to_slave;
dev_alexander 40:6f8744c366c2 171
dev_alexander 40:6f8744c366c2 172 // Triggered when there is data written
dev_alexander 40:6f8744c366c2 173 void onDataWritten(const GattWriteCallbackParams *params)
dev_alexander 40:6f8744c366c2 174 {
dev_alexander 40:6f8744c366c2 175 //LED1 will be off when button is pressed, and on when button is released.
dev_alexander 40:6f8744c366c2 176 led2 = !led2;
dev_alexander 40:6f8744c366c2 177 uint8_t button_state;
dev_alexander 40:6f8744c366c2 178 uint8_t direction;
dev_alexander 40:6f8744c366c2 179
dev_alexander 40:6f8744c366c2 180 /* If there is a valid data sent by the mobile app */
dev_alexander 40:6f8744c366c2 181 if ((uart != NULL) && (params->handle == uart ->getTXCharacteristicHandle())) {
dev_alexander 40:6f8744c366c2 182 const uint8_t *packet = params->data;
dev_alexander 40:6f8744c366c2 183 button_state = packet[3];
dev_alexander 40:6f8744c366c2 184 direction = packet[2];
dev_alexander 40:6f8744c366c2 185
dev_alexander 40:6f8744c366c2 186 // make parameter to send over Lora
dev_alexander 40:6f8744c366c2 187 onDataWritten_curr_ble_to_slave[0] = direction;
dev_alexander 40:6f8744c366c2 188 onDataWritten_curr_ble_to_slave[1] = button_state;
dev_alexander 40:6f8744c366c2 189
dev_alexander 40:6f8744c366c2 190 //dprintf("direction: %d\n", direction);
dev_alexander 40:6f8744c366c2 191 //dprintf("button_state: %d\n", button_state);
dev_alexander 40:6f8744c366c2 192 }
dev_alexander 40:6f8744c366c2 193 }
dev_alexander 40:6f8744c366c2 194 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 195 // No BLE chip on the MAX32620FTHR so this is not needed
dev_alexander 23:f74a50977593 196 #endif
dev_alexander 40:6f8744c366c2 197
dev_alexander 40:6f8744c366c2 198 /***************************************************************************
dev_alexander 40:6f8744c366c2 199 * Motor Controller Instatiation and Related Functions
dev_alexander 40:6f8744c366c2 200 **************************************************************************/
dev_alexander 40:6f8744c366c2 201 #if defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway
dev_alexander 42:911770814147 202 // There is no motor controller on this device.
dev_alexander 40:6f8744c366c2 203 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 204 /* This is a port of a library that was developed by Adafruit for the Arduino.
dev_alexander 40:6f8744c366c2 205 * This port was done by mbed user syundo0730. */
dev_alexander 40:6f8744c366c2 206 #include "Adafruit_MotorShield.h"
dev_alexander 40:6f8744c366c2 207 #include "Adafruit_PWMServoDriver.h"
dev_alexander 40:6f8744c366c2 208
dev_alexander 40:6f8744c366c2 209 // These are the defined speeds that are selected out of the number range (0, 255).
dev_alexander 40:6f8744c366c2 210 #define MOTOR_OFF 0
dev_alexander 40:6f8744c366c2 211 #define MOTOR_FORWARD 150
dev_alexander 40:6f8744c366c2 212 #define MOTOR_BACKWARD 150
dev_alexander 40:6f8744c366c2 213 #define MOTOR_TURN 100
dev_alexander 40:6f8744c366c2 214
dev_alexander 40:6f8744c366c2 215 // Create the motor shield object with the default I2C address
dev_alexander 40:6f8744c366c2 216 Adafruit_MotorShield AFMS = Adafruit_MotorShield(P3_4, P3_5, 0x60 << 1); // You have to shift it over by one due to how mbed does its I2C Addressing.
dev_alexander 40:6f8744c366c2 217 // Or, create it with a different I2C address (say for stacking)
dev_alexander 42:911770814147 218 // Adafruit_MotorShield AFMS = Adafruit_MotorShield(P3_4, P3_5, 0x61 << 1);
dev_alexander 40:6f8744c366c2 219 // Select which 'port' M1, M2, M3 or M4. In this case, M1
dev_alexander 40:6f8744c366c2 220 Adafruit_DCMotor *rightMotor = AFMS.getMotor(1);
dev_alexander 40:6f8744c366c2 221 // You can also make another motor on port M4
dev_alexander 40:6f8744c366c2 222 Adafruit_DCMotor *leftMotor = AFMS.getMotor(4);
dev_alexander 40:6f8744c366c2 223
dev_alexander 40:6f8744c366c2 224
dev_alexander 40:6f8744c366c2 225 void MotorController(uint8_t (BLE_data_server)[2])
dev_alexander 40:6f8744c366c2 226 {
dev_alexander 40:6f8744c366c2 227 uint8_t button_state;
dev_alexander 40:6f8744c366c2 228 uint8_t direction;
dev_alexander 40:6f8744c366c2 229 /*Set up constants for direction of motion */
dev_alexander 40:6f8744c366c2 230 const char FRONT = '5';
dev_alexander 40:6f8744c366c2 231 const char BACK = '6';
dev_alexander 40:6f8744c366c2 232 const char LEFT = '7';
dev_alexander 40:6f8744c366c2 233 const char RIGHT = '8';
dev_alexander 40:6f8744c366c2 234
dev_alexander 40:6f8744c366c2 235 /*Set up constants for button state */
dev_alexander 40:6f8744c366c2 236 const char PRESSED = '1';
dev_alexander 40:6f8744c366c2 237 const char RELEASED = '0';
dev_alexander 40:6f8744c366c2 238
dev_alexander 40:6f8744c366c2 239
dev_alexander 40:6f8744c366c2 240 button_state = BLE_data_server[1];
dev_alexander 40:6f8744c366c2 241 direction = BLE_data_server[0];
dev_alexander 40:6f8744c366c2 242
dev_alexander 40:6f8744c366c2 243 switch (button_state)
dev_alexander 40:6f8744c366c2 244 {
dev_alexander 40:6f8744c366c2 245 case PRESSED:
dev_alexander 40:6f8744c366c2 246 switch (direction)
dev_alexander 40:6f8744c366c2 247 {
dev_alexander 40:6f8744c366c2 248 case FRONT:
dev_alexander 40:6f8744c366c2 249 rightMotor->run(FORWARD);
dev_alexander 40:6f8744c366c2 250 leftMotor->run(FORWARD);
dev_alexander 40:6f8744c366c2 251 rightMotor->setSpeed(MOTOR_FORWARD);
dev_alexander 40:6f8744c366c2 252 leftMotor->setSpeed(MOTOR_FORWARD);
dev_alexander 40:6f8744c366c2 253 break;
dev_alexander 40:6f8744c366c2 254 case BACK:
dev_alexander 40:6f8744c366c2 255 rightMotor->run(BACKWARD);
dev_alexander 40:6f8744c366c2 256 leftMotor->run(BACKWARD);
dev_alexander 40:6f8744c366c2 257 rightMotor->setSpeed(MOTOR_BACKWARD);
dev_alexander 40:6f8744c366c2 258 leftMotor->setSpeed(MOTOR_BACKWARD);
dev_alexander 40:6f8744c366c2 259 break;
dev_alexander 40:6f8744c366c2 260 case LEFT:
dev_alexander 40:6f8744c366c2 261 rightMotor->run(FORWARD);
dev_alexander 40:6f8744c366c2 262 leftMotor->run(BACKWARD);
dev_alexander 40:6f8744c366c2 263 rightMotor->setSpeed(MOTOR_TURN);
dev_alexander 40:6f8744c366c2 264 leftMotor->setSpeed(MOTOR_TURN);
dev_alexander 40:6f8744c366c2 265 break;
dev_alexander 40:6f8744c366c2 266 case RIGHT:
dev_alexander 40:6f8744c366c2 267 rightMotor->run(BACKWARD);
dev_alexander 40:6f8744c366c2 268 leftMotor->run(FORWARD);
dev_alexander 40:6f8744c366c2 269 rightMotor->setSpeed(MOTOR_TURN);
dev_alexander 40:6f8744c366c2 270 leftMotor->setSpeed(MOTOR_TURN);
dev_alexander 40:6f8744c366c2 271 break;
dev_alexander 40:6f8744c366c2 272 }
dev_alexander 40:6f8744c366c2 273 break;
dev_alexander 40:6f8744c366c2 274 case RELEASED:
dev_alexander 40:6f8744c366c2 275 rightMotor->setSpeed(MOTOR_OFF);
dev_alexander 40:6f8744c366c2 276 leftMotor->setSpeed(MOTOR_OFF);
dev_alexander 40:6f8744c366c2 277 break;
dev_alexander 40:6f8744c366c2 278 }
dev_alexander 40:6f8744c366c2 279 }
dev_alexander 40:6f8744c366c2 280 #endif
dev_alexander 40:6f8744c366c2 281
dev_alexander 40:6f8744c366c2 282
dev_alexander 40:6f8744c366c2 283
dev_alexander 40:6f8744c366c2 284
dev_alexander 40:6f8744c366c2 285
dev_alexander 19:9f035b9e65ec 286
dev_alexander 23:f74a50977593 287 int main()
dev_alexander 23:f74a50977593 288 {
dev_alexander 32:b108ed6096b0 289 /* Setup begins here: */
dev_alexander 32:b108ed6096b0 290 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 32:b108ed6096b0 291 dprintf("MAX32630FTHR: Master");
dev_alexander 32:b108ed6096b0 292 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 32:b108ed6096b0 293 dprintf("MAX32620FTHR: Slave");
dev_alexander 32:b108ed6096b0 294 #endif
dev_alexander 32:b108ed6096b0 295
dev_alexander 32:b108ed6096b0 296
dev_alexander 32:b108ed6096b0 297 #if defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 32:b108ed6096b0 298 //Set Power Hold High for battery operation MAX77650 on MAX32620FTHR
dev_alexander 32:b108ed6096b0 299 pw_Hold = POWER_HOLD_ON;
dev_alexander 32:b108ed6096b0 300 #endif
dev_alexander 32:b108ed6096b0 301
Helmut64 17:98f2528e8399 302 /*
Helmut64 17:98f2528e8399 303 * inits the Serial or USBSerial when available (230400 baud).
Helmut64 17:98f2528e8399 304 * If the serial uart is not is not connected it swiches to USB Serial
Helmut64 17:98f2528e8399 305 * blinking LED means USBSerial detected, waiting for a connect.
Helmut64 17:98f2528e8399 306 * It waits up to 30 seconds for a USB terminal connections
Helmut64 17:98f2528e8399 307 */
Helmut64 17:98f2528e8399 308 InitSerial(30*1000, &myled);
Helmut64 17:98f2528e8399 309 dprintf("Welcome to the SX1276GenericLib");
Helmut64 18:d5527ce82e6b 310
Helmut64 17:98f2528e8399 311 dprintf("Starting a simple LoRa PingPong");
dev_alexander 23:f74a50977593 312
dev_alexander 23:f74a50977593 313
dev_alexander 23:f74a50977593 314 /***************************************************************************
dev_alexander 23:f74a50977593 315 * Grid Eye Sensor: Non-Buffer Program Variables
dev_alexander 23:f74a50977593 316 **************************************************************************/
dev_alexander 23:f74a50977593 317 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 23:f74a50977593 318 int frame_idx = 0;
dev_alexander 24:e8d03912f303 319 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 32:b108ed6096b0 320 #if defined(DEBUG_GRID_EYE_SLAVE)
dev_alexander 32:b108ed6096b0 321 int frame_idx = 0;
dev_alexander 32:b108ed6096b0 322 #endif
dev_alexander 23:f74a50977593 323 #endif
dev_alexander 23:f74a50977593 324
dev_alexander 23:f74a50977593 325
dev_alexander 28:0ed92c590607 326 /***************************************************************************
dev_alexander 28:0ed92c590607 327 * Combined Payload Buffers for LoRa Communications
dev_alexander 28:0ed92c590607 328 **************************************************************************/
dev_alexander 28:0ed92c590607 329 uint8_t BufferTx[BufferSizeTx];
dev_alexander 28:0ed92c590607 330 uint8_t BufferRx[BufferSizeRx];
dev_alexander 28:0ed92c590607 331
dev_alexander 28:0ed92c590607 332 /***************************************************************************
dev_alexander 32:b108ed6096b0 333 * Identification Buffers
dev_alexander 32:b108ed6096b0 334 **************************************************************************/
dev_alexander 32:b108ed6096b0 335 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 32:b108ed6096b0 336 uint8_t ID_of_slave[size_signature];
dev_alexander 32:b108ed6096b0 337 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 32:b108ed6096b0 338 uint8_t ID_of_master[size_signature];
dev_alexander 32:b108ed6096b0 339 #endif
dev_alexander 32:b108ed6096b0 340
dev_alexander 32:b108ed6096b0 341 /***************************************************************************
dev_alexander 28:0ed92c590607 342 * BLE Data Buffers
dev_alexander 28:0ed92c590607 343 **************************************************************************/
dev_alexander 28:0ed92c590607 344 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 31:f15747cffb20 345 uint8_t curr_ble_to_slave[size_of_ble];
dev_alexander 28:0ed92c590607 346 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 28:0ed92c590607 347 uint8_t curr_ble_from_master[size_of_ble];
dev_alexander 28:0ed92c590607 348 uint8_t prev_ble_from_master[size_of_ble];
dev_alexander 28:0ed92c590607 349 #endif
dev_alexander 28:0ed92c590607 350
dev_alexander 28:0ed92c590607 351 /***************************************************************************
dev_alexander 28:0ed92c590607 352 * Grid Eye Sensor Data Buffers
dev_alexander 28:0ed92c590607 353 **************************************************************************/
dev_alexander 28:0ed92c590607 354 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 28:0ed92c590607 355 char curr_raw_frame_from_slave[size_of_grid_eye];
dev_alexander 28:0ed92c590607 356 char prev_raw_frame_from_slave[size_of_grid_eye];
dev_alexander 28:0ed92c590607 357 int16_t conv_frame_from_slave[64];
dev_alexander 28:0ed92c590607 358 #elif defined(TARGET_MAX32620FTHR) // Client Device: LoRa Controlled Robot
dev_alexander 28:0ed92c590607 359 char curr_raw_frame_to_master[size_of_grid_eye];
dev_alexander 28:0ed92c590607 360 char prev_raw_frame_to_master[size_of_grid_eye];
dev_alexander 28:0ed92c590607 361 int16_t conv_frame_to_master[64];
dev_alexander 28:0ed92c590607 362 #endif
dev_alexander 28:0ed92c590607 363
dev_alexander 28:0ed92c590607 364 /***************************************************************************
dev_alexander 28:0ed92c590607 365 * GPS Data Buffers
dev_alexander 28:0ed92c590607 366 **************************************************************************/
dev_alexander 28:0ed92c590607 367 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 28:0ed92c590607 368 uint8_t curr_gps_from_slave[size_of_gps];
dev_alexander 28:0ed92c590607 369 uint8_t prev_gps_from_slave[size_of_gps];
dev_alexander 28:0ed92c590607 370 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 28:0ed92c590607 371 uint8_t curr_gps_to_master[size_of_gps];
dev_alexander 28:0ed92c590607 372 #endif
dev_alexander 28:0ed92c590607 373
dev_alexander 28:0ed92c590607 374 /***************************************************************************
dev_alexander 28:0ed92c590607 375 * MAX17055 Data Buffers
dev_alexander 28:0ed92c590607 376 **************************************************************************/
dev_alexander 28:0ed92c590607 377 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 41:1381a49e019e 378 union max17055_u
dev_alexander 41:1381a49e019e 379 {
dev_alexander 41:1381a49e019e 380 uint8_t curr_MAX17055_from_slave[size_of_MAX17055];
dev_alexander 41:1381a49e019e 381 struct battery
dev_alexander 41:1381a49e019e 382 {
dev_alexander 41:1381a49e019e 383 uint8_t soc_FG; // in Battery Percent
dev_alexander 41:1381a49e019e 384 uint8_t avg_soc_FG; // in Battery Percent
dev_alexander 41:1381a49e019e 385 float tte_FG; // in seconds
dev_alexander 41:1381a49e019e 386 float ttf_FG; // in seconds
dev_alexander 41:1381a49e019e 387 int vcell_FG; // in 78.125uV per bit
dev_alexander 41:1381a49e019e 388 int curr_FG; // in uAmps
dev_alexander 41:1381a49e019e 389 int avg_curr_FG; // in uAmps
dev_alexander 41:1381a49e019e 390 } battery;
dev_alexander 41:1381a49e019e 391 } max17055_u;
dev_alexander 28:0ed92c590607 392 uint8_t prev_MAX17055_from_slave[size_of_MAX17055];
dev_alexander 40:6f8744c366c2 393
dev_alexander 28:0ed92c590607 394 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 41:1381a49e019e 395 union max17055_u
dev_alexander 41:1381a49e019e 396 {
dev_alexander 41:1381a49e019e 397 uint8_t curr_MAX17055_to_master[size_of_MAX17055];
dev_alexander 41:1381a49e019e 398 struct battery
dev_alexander 41:1381a49e019e 399 {
dev_alexander 41:1381a49e019e 400 uint8_t soc_FG; // in Battery Percent
dev_alexander 41:1381a49e019e 401 uint8_t avg_soc_FG; // in Battery Percent
dev_alexander 41:1381a49e019e 402 float tte_FG; // in seconds
dev_alexander 41:1381a49e019e 403 float ttf_FG; // in seconds
dev_alexander 41:1381a49e019e 404 int vcell_FG; // in 78.125uV per bit
dev_alexander 41:1381a49e019e 405 int curr_FG; // in uAmps
dev_alexander 41:1381a49e019e 406 int avg_curr_FG; // in uAmps
dev_alexander 41:1381a49e019e 407 } battery;
dev_alexander 41:1381a49e019e 408 } max17055_u;
dev_alexander 28:0ed92c590607 409 #endif
dev_alexander 28:0ed92c590607 410
dev_alexander 28:0ed92c590607 411 /***************************************************************************
dev_alexander 28:0ed92c590607 412 * MAX77650 Data Buffers
dev_alexander 28:0ed92c590607 413 **************************************************************************/
dev_alexander 28:0ed92c590607 414 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 28:0ed92c590607 415 uint8_t curr_MAX77650_from_slave[size_of_MAX77650];
dev_alexander 28:0ed92c590607 416 uint8_t prev_MAX77650_from_slave[size_of_MAX77650];
dev_alexander 41:1381a49e019e 417 bool chrg_status = false;; //True = ON False = OFF
dev_alexander 28:0ed92c590607 418 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 28:0ed92c590607 419 uint8_t curr_MAX77650_to_master[size_of_MAX77650];
dev_alexander 41:1381a49e019e 420 bool chrg_status = false; //True = ON False = OFF
dev_alexander 28:0ed92c590607 421 #endif
dev_alexander 40:6f8744c366c2 422
dev_alexander 28:0ed92c590607 423
dev_alexander 28:0ed92c590607 424 /***************************************************************************
dev_alexander 28:0ed92c590607 425 * Finish Setting up LoRa Radios: This passes in pointers to Buffers to send
dev_alexander 28:0ed92c590607 426 **************************************************************************/
dev_alexander 28:0ed92c590607 427 SX1276PingPongSetup(BufferTx, BufferRx);
dev_alexander 28:0ed92c590607 428
dev_alexander 32:b108ed6096b0 429 /***************************************************************************
dev_alexander 32:b108ed6096b0 430 * Finish Setting up BLE Radio on the MAX32630FTHR: Only on the Master Device
dev_alexander 32:b108ed6096b0 431 **************************************************************************/
dev_alexander 32:b108ed6096b0 432 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 32:b108ed6096b0 433 BLE &ble = BLE::Instance();
dev_alexander 32:b108ed6096b0 434 /* Create alias for the BLE data to be saved in function above that
dev_alexander 32:b108ed6096b0 435 * writes data to this buffer when function onDataWritten is called
dev_alexander 32:b108ed6096b0 436 */
dev_alexander 32:b108ed6096b0 437 onDataWritten_curr_ble_to_slave = curr_ble_to_slave;
dev_alexander 32:b108ed6096b0 438
dev_alexander 32:b108ed6096b0 439 /* Initialize BLE */
dev_alexander 32:b108ed6096b0 440 ble.init();
dev_alexander 32:b108ed6096b0 441 ble.gap().onDisconnection(disconnectionCallback);
dev_alexander 32:b108ed6096b0 442 ble.gattServer().onDataWritten(onDataWritten);
dev_alexander 32:b108ed6096b0 443 uart = new UARTService(ble);
dev_alexander 32:b108ed6096b0 444 /* setup advertising */
dev_alexander 32:b108ed6096b0 445 ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED);
dev_alexander 32:b108ed6096b0 446 ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
dev_alexander 32:b108ed6096b0 447 ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME,
dev_alexander 32:b108ed6096b0 448 (const uint8_t *)"BLE UART", sizeof("BLE UART") - 1);
dev_alexander 32:b108ed6096b0 449 ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS,
dev_alexander 32:b108ed6096b0 450 (const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed));
dev_alexander 32:b108ed6096b0 451 ble.gap().setAdvertisingInterval(160); /* 100ms; in multiples of 0.625ms. */
dev_alexander 32:b108ed6096b0 452 ble.gap().startAdvertising();
dev_alexander 32:b108ed6096b0 453 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 32:b108ed6096b0 454 /* There is no BLE device that is integrated into the MAX32620FTHR. Also
dev_alexander 32:b108ed6096b0 455 * Also this program is meant to use the BLE gateway on the MAX32630FTHR
dev_alexander 32:b108ed6096b0 456 */
dev_alexander 32:b108ed6096b0 457 #endif
dev_alexander 32:b108ed6096b0 458
dev_alexander 32:b108ed6096b0 459 /***************************************************************************
dev_alexander 40:6f8744c366c2 460 * Finish Setting up the MAX77650 on the MAX32620FTHR: Only on the Slave Device
dev_alexander 40:6f8744c366c2 461 **************************************************************************/
dev_alexander 40:6f8744c366c2 462 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 40:6f8744c366c2 463 // No MAX77650 on the MAX32630FTHR
dev_alexander 40:6f8744c366c2 464 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 465 //Set Power Hold High for battery operation MAX77650 on MAX32620FTHR
dev_alexander 40:6f8744c366c2 466 pw_Hold = POWER_HOLD_ON;
dev_alexander 40:6f8744c366c2 467 //Simo Pmic MAX77650 init
dev_alexander 40:6f8744c366c2 468 simo_pmic.initCharger();
dev_alexander 40:6f8744c366c2 469 simoIRQ.fall( &charger_Detect );
dev_alexander 40:6f8744c366c2 470 simo_pmic.enCharger();
dev_alexander 40:6f8744c366c2 471 #endif
dev_alexander 40:6f8744c366c2 472 /***************************************************************************
dev_alexander 40:6f8744c366c2 473 * Finish Setting up the MAX17650 on the MAX32620FTHR: Only on the Slave Device
dev_alexander 40:6f8744c366c2 474 **************************************************************************/
dev_alexander 40:6f8744c366c2 475 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 40:6f8744c366c2 476 // No MAX17055 on the MAX32630FTHR
dev_alexander 40:6f8744c366c2 477 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 478 //rsense 5mOhm for MAX32620FTHR
dev_alexander 41:1381a49e019e 479 design_param.designcap = 2200; //Design Battery Capacity mAh
dev_alexander 40:6f8744c366c2 480 design_param.ichgterm = 0x0016; // Charge Termination Current for the Battery
dev_alexander 40:6f8744c366c2 481 design_param.vempty = 0x9B00; // Battery Empty Voltage
dev_alexander 40:6f8744c366c2 482 design_param.vcharge = 4200; // Battery Charge Voltage can be obtained from MAX77650 configuration
dev_alexander 40:6f8744c366c2 483 design_param.rsense = 5; //5mOhms
dev_alexander 40:6f8744c366c2 484
dev_alexander 42:911770814147 485 int oper_f1, volt_mod_FG;
dev_alexander 42:911770814147 486 int status; // stores return value of the status of setting up the MAX17055
dev_alexander 41:1381a49e019e 487
dev_alexander 40:6f8744c366c2 488 //serial.printf("Test Init and Temp Functions \r\n");
dev_alexander 40:6f8744c366c2 489 //status = fuelGauge.forcedExitHyberMode();
dev_alexander 40:6f8744c366c2 490 status = fuelGauge.init(design_param);
dev_alexander 40:6f8744c366c2 491 pc.printf("Init FuelGauge Function Status= %X \r\n",status);
dev_alexander 40:6f8744c366c2 492 #endif
dev_alexander 40:6f8744c366c2 493
dev_alexander 40:6f8744c366c2 494 /***************************************************************************
dev_alexander 40:6f8744c366c2 495 * Finish Setting up the SSD1306 OLED on the MAX32630FTHR: Only on the Master Device
dev_alexander 40:6f8744c366c2 496 **************************************************************************/
dev_alexander 40:6f8744c366c2 497 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 40:6f8744c366c2 498 displayOled.setTextColor(1);
dev_alexander 40:6f8744c366c2 499 displayOled.setTextSize(1);
dev_alexander 40:6f8744c366c2 500 displayOled.setTextWrap(false);
dev_alexander 40:6f8744c366c2 501
dev_alexander 40:6f8744c366c2 502 displayOled.clearDisplay();
dev_alexander 41:1381a49e019e 503 displayOled.printf("%ux%u Please Check Connection to Robot!!\r\n", displayOled.width(), displayOled.height());
dev_alexander 40:6f8744c366c2 504 //displayOled.drawBitmap(0,0,maximLarge,128,32,1);
dev_alexander 40:6f8744c366c2 505 displayOled.display();
dev_alexander 40:6f8744c366c2 506 displayOled.display();
dev_alexander 40:6f8744c366c2 507 wait(1.0);
dev_alexander 40:6f8744c366c2 508
dev_alexander 40:6f8744c366c2 509 displayOled.startscrollright(0x00, 0x0F);
dev_alexander 42:911770814147 510
dev_alexander 42:911770814147 511
dev_alexander 42:911770814147 512 uint32_t OLED_COUNT;
dev_alexander 42:911770814147 513
dev_alexander 40:6f8744c366c2 514 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 40:6f8744c366c2 515 // No oled on the MAX32620FTHR
dev_alexander 40:6f8744c366c2 516 #endif
dev_alexander 40:6f8744c366c2 517
dev_alexander 40:6f8744c366c2 518 /***************************************************************************
dev_alexander 32:b108ed6096b0 519 * Finish Setting up the motor controller on the MAX32620FTHR: Only on the Slave Device
dev_alexander 32:b108ed6096b0 520 **************************************************************************/
dev_alexander 32:b108ed6096b0 521 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 32:b108ed6096b0 522 // No setup on the master device
dev_alexander 32:b108ed6096b0 523 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 32:b108ed6096b0 524 AFMS.begin(); // create with the default frequency 1.6KHz
dev_alexander 32:b108ed6096b0 525 //AFMS.begin(1000); // OR with a different frequency, say 1KHz
dev_alexander 32:b108ed6096b0 526
dev_alexander 32:b108ed6096b0 527 // Set the speed to start, from 0 (off) to 255 (max speed)
dev_alexander 32:b108ed6096b0 528 rightMotor->setSpeed(150);
dev_alexander 32:b108ed6096b0 529 rightMotor->run(FORWARD);
dev_alexander 32:b108ed6096b0 530 // turn on motor
dev_alexander 32:b108ed6096b0 531 rightMotor->run(RELEASE);
dev_alexander 32:b108ed6096b0 532
dev_alexander 32:b108ed6096b0 533 leftMotor->setSpeed(150);
dev_alexander 32:b108ed6096b0 534 leftMotor->run(FORWARD);
dev_alexander 32:b108ed6096b0 535 // turn on motor
dev_alexander 32:b108ed6096b0 536 leftMotor->run(RELEASE);
dev_alexander 32:b108ed6096b0 537 #endif
dev_alexander 32:b108ed6096b0 538
dev_alexander 32:b108ed6096b0 539
dev_alexander 22:abca9d17d13d 540 while(1)
dev_alexander 40:6f8744c366c2 541 {
dev_alexander 23:f74a50977593 542 /***************************************************************************
dev_alexander 30:66f9750cc44c 543 * BLE Radio Data
dev_alexander 30:66f9750cc44c 544 **************************************************************************/
dev_alexander 30:66f9750cc44c 545 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 30:66f9750cc44c 546 ble.waitForEvent();
dev_alexander 30:66f9750cc44c 547 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 32:b108ed6096b0 548 memcpy(curr_ble_from_master, prev_ble_from_master, sizeof(curr_ble_from_master));
dev_alexander 30:66f9750cc44c 549 #endif
dev_alexander 30:66f9750cc44c 550
dev_alexander 30:66f9750cc44c 551 /***************************************************************************
dev_alexander 23:f74a50977593 552 * Grid Eye Sensor
dev_alexander 23:f74a50977593 553 **************************************************************************/
dev_alexander 23:f74a50977593 554 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 28:0ed92c590607 555 // Check to see if the contents of the previous scan are the same. If they are different then continue with converting
dev_alexander 32:b108ed6096b0 556 #if defined(RASPBERRY_PI)
dev_alexander 32:b108ed6096b0 557 if( memcmp(prev_raw_frame_from_slave, curr_raw_frame_from_slave, sizeof(curr_raw_frame_from_slave)) != 0 )
dev_alexander 32:b108ed6096b0 558 {
dev_alexander 32:b108ed6096b0 559 char grid_eye_msg[130];
dev_alexander 32:b108ed6096b0 560 grid_eye_msg[0]=0x55;
dev_alexander 32:b108ed6096b0 561 grid_eye_msg[1]=0xaa;
dev_alexander 32:b108ed6096b0 562 for (int idx = 0; idx < 128; idx++)
dev_alexander 32:b108ed6096b0 563 grid_eye_msg[idx+2] = curr_raw_frame_from_slave[idx];
dev_alexander 32:b108ed6096b0 564 //pc.printf(grid_eye_msg);
dev_alexander 32:b108ed6096b0 565 for (int idx = 0; idx < 130; idx++)
dev_alexander 32:b108ed6096b0 566 pc.putc(grid_eye_msg[idx]);
dev_alexander 35:bae9b236070b 567 pc.printf("\r\n"); // seperate the lines
dev_alexander 32:b108ed6096b0 568 }
dev_alexander 35:bae9b236070b 569 #endif
dev_alexander 35:bae9b236070b 570 #if defined(DEBUG_GRID_EYE)
dev_alexander 32:b108ed6096b0 571 if( memcmp(prev_raw_frame_from_slave, curr_raw_frame_from_slave, sizeof(curr_raw_frame_from_slave)) != 0 )
dev_alexander 32:b108ed6096b0 572 {
dev_alexander 32:b108ed6096b0 573 // Convert raw data sent from slave to a 16 bit integer array by calling this
dev_alexander 32:b108ed6096b0 574 convRaw8x8Data2Point25degC(curr_raw_frame_from_slave, conv_frame_from_slave);
dev_alexander 32:b108ed6096b0 575
dev_alexander 32:b108ed6096b0 576 // Next Print off the Converted data
dev_alexander 32:b108ed6096b0 577 pc.printf("\r\nFrame %d data: \r\n", frame_idx);
dev_alexander 32:b108ed6096b0 578 uint8_t idx;
dev_alexander 32:b108ed6096b0 579 float pixel_data;
dev_alexander 32:b108ed6096b0 580 for (int y = 0; y < 8; y++) {
dev_alexander 32:b108ed6096b0 581 for (int x = 0; x < 8; x++) {
dev_alexander 32:b108ed6096b0 582 idx = y*8 + x;
dev_alexander 32:b108ed6096b0 583 pixel_data = ((float)conv_frame_from_slave[idx])/4.0;
dev_alexander 32:b108ed6096b0 584 pc.printf("%.2f \t", pixel_data);
dev_alexander 32:b108ed6096b0 585 }
dev_alexander 32:b108ed6096b0 586 pc.printf("\r\n\r\n");
dev_alexander 23:f74a50977593 587 }
dev_alexander 32:b108ed6096b0 588 pc.printf("\r\n");
dev_alexander 32:b108ed6096b0 589
dev_alexander 32:b108ed6096b0 590 // Increment frame counter
dev_alexander 32:b108ed6096b0 591 frame_idx = frame_idx +1;
dev_alexander 23:f74a50977593 592 }
dev_alexander 32:b108ed6096b0 593 #endif
dev_alexander 32:b108ed6096b0 594 /* Next copy in data received from current data into buffer used for
dev_alexander 32:b108ed6096b0 595 * comparison next time the memcmp above is called. This prevents the
dev_alexander 32:b108ed6096b0 596 * program from converting the same raw data aquired by the grid eye
dev_alexander 32:b108ed6096b0 597 * sensor on the slave device to the floating point array with the
dev_alexander 32:b108ed6096b0 598 * 0.25 degrees celsius precision level when there is not new data.
dev_alexander 32:b108ed6096b0 599 */
dev_alexander 32:b108ed6096b0 600
dev_alexander 28:0ed92c590607 601 memcpy(prev_raw_frame_from_slave, curr_raw_frame_from_slave, sizeof(curr_raw_frame_from_slave));
dev_alexander 24:e8d03912f303 602 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 23:f74a50977593 603 // Aquire raw data about 8x8 frame from the grid eye sensor in this function call
dev_alexander 28:0ed92c590607 604 gridEye.getRaw8x8FrameData(curr_raw_frame_to_master);
dev_alexander 35:bae9b236070b 605 #if defined(RASPBERRY_PI)
dev_alexander 35:bae9b236070b 606 if( memcmp(prev_raw_frame_to_master, curr_raw_frame_to_master, sizeof(curr_raw_frame_to_master)) != 0 )
dev_alexander 35:bae9b236070b 607 {
dev_alexander 35:bae9b236070b 608 char grid_eye_msg[130];
dev_alexander 35:bae9b236070b 609 grid_eye_msg[0]=0x55;
dev_alexander 35:bae9b236070b 610 grid_eye_msg[1]=0xaa;
dev_alexander 35:bae9b236070b 611 for (int idx = 0; idx < 128; idx++)
dev_alexander 35:bae9b236070b 612 grid_eye_msg[idx+2] = curr_raw_frame_to_master[idx];
dev_alexander 35:bae9b236070b 613 //pc.printf(grid_eye_msg);
dev_alexander 35:bae9b236070b 614 for (int idx = 0; idx < 130; idx++)
dev_alexander 35:bae9b236070b 615 pc.putc(grid_eye_msg[idx]);
dev_alexander 35:bae9b236070b 616 pc.printf("\r\n"); // seperate the lines
dev_alexander 35:bae9b236070b 617 }
dev_alexander 35:bae9b236070b 618 #endif
dev_alexander 35:bae9b236070b 619 #if defined(DEBUG_GRID_EYE)
dev_alexander 32:b108ed6096b0 620 if( memcmp(prev_raw_frame_to_master, curr_raw_frame_to_master, sizeof(curr_raw_frame_to_master)) != 0 )
dev_alexander 32:b108ed6096b0 621 {
dev_alexander 32:b108ed6096b0 622 // Convert raw data sent from slave to a 16 bit integer array by calling this
dev_alexander 32:b108ed6096b0 623 convRaw8x8Data2Point25degC(curr_raw_frame_to_master, conv_frame_to_master);
dev_alexander 32:b108ed6096b0 624
dev_alexander 32:b108ed6096b0 625
dev_alexander 32:b108ed6096b0 626 // Next Print off the Converted data
dev_alexander 32:b108ed6096b0 627 pc.printf("\r\nFrame %d data: \r\n", frame_idx);
dev_alexander 32:b108ed6096b0 628 uint8_t idx;
dev_alexander 32:b108ed6096b0 629 float pixel_data;
dev_alexander 32:b108ed6096b0 630 for (int y = 0; y < 8; y++) {
dev_alexander 32:b108ed6096b0 631 for (int x = 0; x < 8; x++) {
dev_alexander 32:b108ed6096b0 632 idx = y*8 + x;
dev_alexander 32:b108ed6096b0 633 pixel_data = ((float)conv_frame_to_master[idx])/4.0;
dev_alexander 32:b108ed6096b0 634 pc.printf("%.2f \t", pixel_data);
dev_alexander 32:b108ed6096b0 635 }
dev_alexander 32:b108ed6096b0 636 pc.printf("\r\n\r\n");
dev_alexander 25:1a031add188a 637 }
dev_alexander 32:b108ed6096b0 638 pc.printf("\r\n");
dev_alexander 32:b108ed6096b0 639
dev_alexander 32:b108ed6096b0 640 // Increment frame counter
dev_alexander 32:b108ed6096b0 641 frame_idx = frame_idx +1;
dev_alexander 25:1a031add188a 642 }
dev_alexander 32:b108ed6096b0 643 #endif
dev_alexander 33:52c898aca207 644 memcpy(prev_raw_frame_to_master, curr_raw_frame_to_master, sizeof(curr_raw_frame_to_master));
dev_alexander 31:f15747cffb20 645 #endif
dev_alexander 31:f15747cffb20 646
dev_alexander 31:f15747cffb20 647 /***************************************************************************
dev_alexander 31:f15747cffb20 648 * GPS Sensor
dev_alexander 31:f15747cffb20 649 **************************************************************************/
dev_alexander 31:f15747cffb20 650 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 41:1381a49e019e 651 // No gps sensor is applied
dev_alexander 31:f15747cffb20 652 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 31:f15747cffb20 653 // The testing hasnt been done yet for the GPS Module. Will do this when more parts come in.
dev_alexander 31:f15747cffb20 654 /*
dev_alexander 31:f15747cffb20 655 if(gps.sample()){
dev_alexander 31:f15747cffb20 656 pc.printf("%f\t%c\t%f\t%c\t%f\t%f\t%f\n\r",gps.longitude, gps.ns,gps.latitude,gps.ew, gps.alt, gps.geoid, gps.time);
dev_alexander 31:f15747cffb20 657 pc.printf("%d:%d:%d",gps.hour,gps.minute,gps.seconed);
dev_alexander 31:f15747cffb20 658 }
dev_alexander 31:f15747cffb20 659 */
dev_alexander 31:f15747cffb20 660 #endif
dev_alexander 28:0ed92c590607 661
dev_alexander 23:f74a50977593 662 /***************************************************************************
dev_alexander 41:1381a49e019e 663 * MAX17055 Fuel Gauge Sensor
dev_alexander 41:1381a49e019e 664 **************************************************************************/
dev_alexander 41:1381a49e019e 665 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 41:1381a49e019e 666 // Process the soc to see if the oled display needs to be updated or not.
dev_alexander 41:1381a49e019e 667 #if defined(DEBUG_MAX17055)
dev_alexander 41:1381a49e019e 668 pc.printf("soc_FG :%d\n" ,max17055_u.battery.soc_FG);
dev_alexander 41:1381a49e019e 669 pc.printf("avg_soc_FG :%d\n" ,max17055_u.battery.avg_soc_FG);
dev_alexander 41:1381a49e019e 670 pc.printf("tte_FG :%d\n" ,max17055_u.battery.tte_FG);
dev_alexander 41:1381a49e019e 671 pc.printf("ttf_FG :%d\n" ,max17055_u.battery.ttf_FG);
dev_alexander 41:1381a49e019e 672 pc.printf("vcell_FG :%d\n" ,max17055_u.battery.vcell_FG);
dev_alexander 41:1381a49e019e 673 pc.printf("curr_FG :%d\n" ,max17055_u.battery.curr_FG);
dev_alexander 41:1381a49e019e 674 pc.printf("avg_curr_FG :%d\n" ,max17055_u.battery.avg_curr_FG);
dev_alexander 41:1381a49e019e 675
dev_alexander 41:1381a49e019e 676 for (int idx = 0; idx < size_of_MAX17055; idx++)
dev_alexander 41:1381a49e019e 677 {
dev_alexander 41:1381a49e019e 678 pc.printf("Byte #%d is: %d\n", idx, max17055_u.curr_MAX17055_from_slave[idx]);
dev_alexander 41:1381a49e019e 679 }
dev_alexander 41:1381a49e019e 680 #endif
dev_alexander 42:911770814147 681 OLED_COUNT = OLED_COUNT + 1;
dev_alexander 42:911770814147 682 if( OLED_COUNT % OLED_FREQ == 0) {
dev_alexander 42:911770814147 683 if( memcmp(prev_MAX17055_from_slave, curr_MAX17055_from_slave, sizeof(curr_MAX17055_from_slave)) != 0 )
dev_alexander 42:911770814147 684 {
dev_alexander 42:911770814147 685 // Stop the scrolling to allow for a static image to be displayed on OLED
dev_alexander 42:911770814147 686 displayOled.stopscroll();
dev_alexander 42:911770814147 687
dev_alexander 42:911770814147 688 displayOled.clearDisplay();
dev_alexander 42:911770814147 689
dev_alexander 42:911770814147 690 // if ( chrg_status == false){
dev_alexander 42:911770814147 691 // if (max17055_u.battery.soc_FG >= 89)
dev_alexander 42:911770814147 692 // displayOled.drawBitmap(96,0,battFull,32,16,1);
dev_alexander 42:911770814147 693 // else if (max17055_u.battery.soc_FG >= 65 && max17055_u.battery.soc_FG < 89)
dev_alexander 42:911770814147 694 // displayOled.drawBitmap(96,0,batt75,32,16,1);
dev_alexander 42:911770814147 695 // else if (max17055_u.battery.soc_FG >= 45 && max17055_u.battery.soc_FG < 65)
dev_alexander 42:911770814147 696 // displayOled.drawBitmap(96,0,batt50,32,16,1);
dev_alexander 42:911770814147 697 // else if (max17055_u.battery.soc_FG >= 20 && max17055_u.battery.soc_FG < 45)
dev_alexander 42:911770814147 698 // displayOled.drawBitmap(96,0,batt25,32,16,1);
dev_alexander 42:911770814147 699 // else
dev_alexander 42:911770814147 700 // displayOled.drawBitmap(96,0,battEmpty,32,16,1);
dev_alexander 42:911770814147 701 // }
dev_alexander 42:911770814147 702
dev_alexander 42:911770814147 703 if (chrg_status == true){
dev_alexander 42:911770814147 704 displayOled.drawBitmap(96,0,battChrging,32,16,1);
dev_alexander 42:911770814147 705 }
dev_alexander 42:911770814147 706
dev_alexander 42:911770814147 707
dev_alexander 42:911770814147 708 //serial.printf("Time to Empty= %dsec \r\n",tte_FG);
dev_alexander 42:911770814147 709 int tte_minutes = (max17055_u.battery.tte_FG/60);
dev_alexander 42:911770814147 710 int ttf_minutes = (max17055_u.battery.tte_FG/60);
dev_alexander 42:911770814147 711 //serial.printf("Time to Empty= %dhours \r\n",tte_FG);
dev_alexander 42:911770814147 712 //serial.printf("Temp Function Status= %X \r\n",status);
dev_alexander 42:911770814147 713 //wait(1);
dev_alexander 42:911770814147 714 //serial.printf("SOC = %d %% \r\n",soc_FG);
dev_alexander 42:911770814147 715 //serial.printf("Temp Function Status= %X \r\n",status);
dev_alexander 42:911770814147 716 //serial.printf("Current = %d uamp \r\n",curr_FG);
dev_alexander 42:911770814147 717 // pc.printf("Voltage = %d uvolts \r\n",max17055_u.battery.vcell_FG);
dev_alexander 42:911770814147 718 int oper_f1 = max17055_u.battery.vcell_FG /1000000;
dev_alexander 42:911770814147 719 int volt_mod_FG = (max17055_u.battery.vcell_FG % 1000000)/1000;
dev_alexander 42:911770814147 720
dev_alexander 42:911770814147 721 // pc.printf("Voltage = %d V \r\n",max17055_u.battery.vcell_FG);
dev_alexander 42:911770814147 722 // pc.printf("Voltage = %d V \r\n",oper_f1);
dev_alexander 42:911770814147 723
dev_alexander 42:911770814147 724
dev_alexander 42:911770814147 725
dev_alexander 42:911770814147 726 displayOled.setTextCursor(0,0);
dev_alexander 42:911770814147 727 displayOled.setTextColor(1);
dev_alexander 42:911770814147 728 displayOled.setTextSize(1);
dev_alexander 42:911770814147 729 //displayOled.setTextWrap(true);
dev_alexander 42:911770814147 730 displayOled.printf("MAX17055");
dev_alexander 42:911770814147 731 displayOled.setTextCursor(0,8);
dev_alexander 42:911770814147 732 displayOled.printf("SOC = %d%% \r\n",max17055_u.battery.avg_soc_FG);
dev_alexander 41:1381a49e019e 733
dev_alexander 42:911770814147 734 displayOled.setTextCursor(0,16);
dev_alexander 42:911770814147 735 if (chrg_status == true){
dev_alexander 42:911770814147 736 displayOled.printf("TTF = %dmins \r\n",tte_minutes);
dev_alexander 42:911770814147 737 }else
dev_alexander 42:911770814147 738 displayOled.printf("TTE = %dmins \r\n",tte_minutes);
dev_alexander 42:911770814147 739 displayOled.setTextCursor(0,24);
dev_alexander 42:911770814147 740 // displayOled.printf("I=%dmA \r\n",max17055_u.battery.avg_curr_FG/1000);
dev_alexander 42:911770814147 741 // displayOled.setTextCursor(65,24);
dev_alexander 42:911770814147 742 if (volt_mod_FG > 99){
dev_alexander 42:911770814147 743 displayOled.printf("V=%d.%dV \r\n",oper_f1,volt_mod_FG);
dev_alexander 42:911770814147 744 }else if (volt_mod_FG < 100){
dev_alexander 42:911770814147 745 displayOled.printf("V=%d.0%dV \r\n",oper_f1,volt_mod_FG);
dev_alexander 42:911770814147 746 }
dev_alexander 42:911770814147 747
dev_alexander 42:911770814147 748 displayOled.display();
dev_alexander 42:911770814147 749 displayOled.display();
dev_alexander 41:1381a49e019e 750 }
dev_alexander 42:911770814147 751 }
dev_alexander 41:1381a49e019e 752 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 41:1381a49e019e 753 max17055_u.battery.soc_FG = fuelGauge.get_SOC();
dev_alexander 41:1381a49e019e 754 max17055_u.battery.avg_soc_FG = fuelGauge.get_atAvSOC();
dev_alexander 41:1381a49e019e 755 max17055_u.battery.tte_FG = fuelGauge.get_TTE();
dev_alexander 41:1381a49e019e 756 max17055_u.battery.ttf_FG = fuelGauge.get_TTF();
dev_alexander 41:1381a49e019e 757 max17055_u.battery.vcell_FG = fuelGauge.get_Vcell();
dev_alexander 41:1381a49e019e 758 max17055_u.battery.curr_FG = fuelGauge.get_Current(design_param);
dev_alexander 41:1381a49e019e 759 max17055_u.battery.avg_curr_FG = fuelGauge.get_AvgCurrent(design_param);
dev_alexander 41:1381a49e019e 760
dev_alexander 41:1381a49e019e 761 #if defined(DEBUG_MAX17055)
dev_alexander 41:1381a49e019e 762 pc.printf("soc_FG :%d\n" ,max17055_u.battery.soc_FG);
dev_alexander 41:1381a49e019e 763 pc.printf("avg_soc_FG :%d\n" ,max17055_u.battery.avg_soc_FG);
dev_alexander 41:1381a49e019e 764 pc.printf("tte_FG :%d\n" ,max17055_u.battery.tte_FG);
dev_alexander 41:1381a49e019e 765 pc.printf("ttf_FG :%d\n" ,max17055_u.battery.ttf_FG);
dev_alexander 41:1381a49e019e 766 pc.printf("vcell_FG :%d\n" ,max17055_u.battery.vcell_FG);
dev_alexander 41:1381a49e019e 767 pc.printf("curr_FG :%d\n" ,max17055_u.battery.curr_FG);
dev_alexander 41:1381a49e019e 768 pc.printf("avg_curr_FG :%d\n" ,max17055_u.battery.avg_curr_FG);
dev_alexander 41:1381a49e019e 769
dev_alexander 41:1381a49e019e 770 for (int idx = 0; idx < size_of_MAX17055; idx++)
dev_alexander 41:1381a49e019e 771 {
dev_alexander 41:1381a49e019e 772 pc.printf("Byte #%d is: %d\n", idx, max17055_u.curr_MAX17055_to_master[idx]);
dev_alexander 41:1381a49e019e 773 }
dev_alexander 41:1381a49e019e 774 #endif
dev_alexander 41:1381a49e019e 775 #endif
dev_alexander 41:1381a49e019e 776
dev_alexander 41:1381a49e019e 777 /***************************************************************************
dev_alexander 42:911770814147 778 * Fill Payload Buffer With Data From Main Program Buffers for next LoRa Transmition
dev_alexander 28:0ed92c590607 779 **************************************************************************/
dev_alexander 28:0ed92c590607 780 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 28:0ed92c590607 781 memcpy(&BufferTx[tx_idx_signature], PingMsg, size_signature);
dev_alexander 28:0ed92c590607 782 memcpy(&BufferTx[tx_idx_ble], curr_ble_to_slave, size_of_ble);
dev_alexander 28:0ed92c590607 783 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 28:0ed92c590607 784 memcpy(&BufferTx[tx_idx_signature], PongMsg, size_signature);
dev_alexander 28:0ed92c590607 785 memcpy(&BufferTx[tx_idx_grid_eye], curr_raw_frame_to_master, size_of_grid_eye);
dev_alexander 28:0ed92c590607 786 memcpy(&BufferTx[tx_idx_gps], curr_gps_to_master, size_of_gps);
dev_alexander 41:1381a49e019e 787 memcpy(&BufferTx[tx_idx_MAX17055], max17055_u.curr_MAX17055_to_master, size_of_MAX17055);
dev_alexander 28:0ed92c590607 788 memcpy(&BufferTx[tx_idx_MAX77650], curr_MAX77650_to_master, size_of_MAX77650);
dev_alexander 28:0ed92c590607 789 #endif
dev_alexander 28:0ed92c590607 790
dev_alexander 42:911770814147 791
dev_alexander 28:0ed92c590607 792 /***************************************************************************
dev_alexander 28:0ed92c590607 793 * Lora Communications
dev_alexander 28:0ed92c590607 794 **************************************************************************/
dev_alexander 22:abca9d17d13d 795 SX1276PingPong();
dev_alexander 28:0ed92c590607 796
dev_alexander 28:0ed92c590607 797 /***************************************************************************
dev_alexander 42:911770814147 798 * Fill Main Program Buffers With Data From Received Payload Buffer
dev_alexander 28:0ed92c590607 799 **************************************************************************/
dev_alexander 28:0ed92c590607 800 /* The master and slave devices will have different requirements for offloading payload */
dev_alexander 28:0ed92c590607 801 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 32:b108ed6096b0 802 memcpy(ID_of_slave, &BufferRx[rx_idx_signature], size_signature);
dev_alexander 32:b108ed6096b0 803 memcpy(curr_raw_frame_from_slave, &BufferRx[rx_idx_grid_eye], size_of_grid_eye);
dev_alexander 32:b108ed6096b0 804 memcpy(curr_gps_from_slave, &BufferRx[rx_idx_gps], size_of_gps);
dev_alexander 41:1381a49e019e 805 memcpy(max17055_u.curr_MAX17055_from_slave, &BufferRx[rx_idx_MAX17055], size_of_MAX17055);
dev_alexander 32:b108ed6096b0 806 memcpy(curr_MAX77650_from_slave, &BufferRx[rx_idx_MAX77650], size_of_MAX77650);
dev_alexander 28:0ed92c590607 807 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 32:b108ed6096b0 808 memcpy(ID_of_master, &BufferRx[rx_idx_signature], size_signature);
dev_alexander 32:b108ed6096b0 809 memcpy(curr_ble_from_master, &BufferRx[rx_idx_ble], size_of_ble);
dev_alexander 28:0ed92c590607 810 #endif
dev_alexander 23:f74a50977593 811
dev_alexander 32:b108ed6096b0 812 /***************************************************************************
dev_alexander 32:b108ed6096b0 813 * Motor Controller controlls go here
dev_alexander 32:b108ed6096b0 814 **************************************************************************/
dev_alexander 32:b108ed6096b0 815 #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway
dev_alexander 32:b108ed6096b0 816 // No motor controller on master
dev_alexander 32:b108ed6096b0 817 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 42:911770814147 818 /* This helps prevent devices such as robots that are connected over
dev_alexander 42:911770814147 819 * LoRa from not receiving a stop message. This can help prevent
dev_alexander 42:911770814147 820 * situations where a robot received a command to move in a dirrection
dev_alexander 42:911770814147 821 * but then moved to an area where it cant reliably receive communications.
dev_alexander 42:911770814147 822 * This situation would prevent a robot from stopping if it cant receive
dev_alexander 42:911770814147 823 * communications. So this is used to stop the current movement if the
dev_alexander 42:911770814147 824 * robot is still moving after x amount of RxTimeouts have happened
dev_alexander 42:911770814147 825 * in the LoRa communications.
dev_alexander 42:911770814147 826 */
dev_alexander 42:911770814147 827 if (numOfRxTimeouts() >= NUM_TIMEOUTS_TO_STOP_ROBOT)
dev_alexander 42:911770814147 828 {
dev_alexander 42:911770814147 829 uint8_t simulate_release_button[2];
dev_alexander 42:911770814147 830 simulate_release_button[0] = curr_ble_from_master[0];
dev_alexander 42:911770814147 831 simulate_release_button[1] = 0;
dev_alexander 42:911770814147 832 MotorController(simulate_release_button);
dev_alexander 42:911770814147 833 }
dev_alexander 42:911770814147 834
dev_alexander 32:b108ed6096b0 835 // Check to see if the contents of the previous ble sdata received are the same. If they are different then change motor controllers registers
dev_alexander 42:911770814147 836 else if( memcmp(prev_ble_from_master, curr_ble_from_master, sizeof(curr_ble_from_master)) != 0 )
dev_alexander 32:b108ed6096b0 837 {
dev_alexander 32:b108ed6096b0 838 MotorController(curr_ble_from_master);
dev_alexander 42:911770814147 839 memcpy(prev_ble_from_master, curr_ble_from_master, sizeof(curr_ble_from_master));
dev_alexander 32:b108ed6096b0 840 }
dev_alexander 42:911770814147 841
dev_alexander 42:911770814147 842 #endif
dev_alexander 42:911770814147 843 }
dev_alexander 42:911770814147 844 }
dev_alexander 42:911770814147 845
dev_alexander 42:911770814147 846
dev_alexander 42:911770814147 847 /***************************************************************************
dev_alexander 42:911770814147 848 * MAX77650 Additional Functions
dev_alexander 42:911770814147 849 **************************************************************************/
dev_alexander 42:911770814147 850 #if defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway
dev_alexander 42:911770814147 851 // No MAX77650 PMIC on this board
dev_alexander 42:911770814147 852 #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot
dev_alexander 42:911770814147 853 void charger_Detect()
dev_alexander 42:911770814147 854 {
dev_alexander 42:911770814147 855 uint8_t int_chr_value,temp, int_chr_MASK = 0x04;
dev_alexander 42:911770814147 856 int status;
dev_alexander 42:911770814147 857 pc.printf("Charger Detected \n");
dev_alexander 42:911770814147 858 status = simo_pmic.readReg(MAX77650::INT_CHG, int_chr_value);
dev_alexander 42:911770814147 859 pc.printf("INT_CHR val= %X \n", int_chr_value);
dev_alexander 42:911770814147 860 if (status == 1){
dev_alexander 42:911770814147 861 temp = int_chr_value & int_chr_MASK;
dev_alexander 42:911770814147 862 pc.printf("INT_CHR anded= %X \n", temp);
dev_alexander 42:911770814147 863 if (temp == 4)
dev_alexander 42:911770814147 864 {
dev_alexander 42:911770814147 865 pc.printf("enable charger \n");
dev_alexander 42:911770814147 866 simo_pmic.enCharger();
dev_alexander 42:911770814147 867 }
dev_alexander 42:911770814147 868 }
dev_alexander 22:abca9d17d13d 869 }
dev_alexander 22:abca9d17d13d 870
dev_alexander 42:911770814147 871 bool chrg_State_fn()
dev_alexander 42:911770814147 872 {
dev_alexander 42:911770814147 873 uint8_t status_chr_value,temp, chr_status_MASK = 0x02;
dev_alexander 42:911770814147 874 int status;
dev_alexander 42:911770814147 875 pc.printf("Charger State \n");
dev_alexander 42:911770814147 876 status = simo_pmic.readReg(MAX77650::STAT_CHG_B, status_chr_value);
dev_alexander 42:911770814147 877 pc.printf("STAR_CHG_B val= %X \n", status_chr_value);
dev_alexander 42:911770814147 878 if (status == 1)
dev_alexander 42:911770814147 879 {
dev_alexander 42:911770814147 880 temp = status_chr_value & chr_status_MASK;
dev_alexander 42:911770814147 881 pc.printf("STAR_CHG_B val= %X \n", temp);
dev_alexander 42:911770814147 882 if (temp == 2){
dev_alexander 42:911770814147 883 return true;
dev_alexander 42:911770814147 884 }
dev_alexander 42:911770814147 885 return false;
dev_alexander 42:911770814147 886 }
dev_alexander 42:911770814147 887 return false;
dev_alexander 42:911770814147 888 }
dev_alexander 42:911770814147 889
dev_alexander 42:911770814147 890 #endif