LP Long Distance IR Vision Robot
Dependencies: max77650_charger_sample BufferedSerial SX1276GenericLib Adafruit-MotorShield NEO-6m-GPS MAX17055_EZconfig Adafruit_GFX USBDeviceHT Adafruit-PWM-Servo-Driver
main.cpp@42:911770814147, 2018-08-15 (annotated)
- Committer:
- dev_alexander
- Date:
- Wed Aug 15 04:06:09 2018 +0000
- Revision:
- 42:911770814147
- Parent:
- 41:1381a49e019e
- Child:
- 44:8be011a3fba0
This version has replaced the MAX77650 Library with a publicly available library.
Who changed what in which revision?
User | Revision | Line number | New 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 |