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@36:09e8b51fc91d, 2018-07-31 (annotated)
- Committer:
- dev_alexander
- Date:
- Tue Jul 31 22:39:49 2018 +0000
- Revision:
- 36:09e8b51fc91d
- Parent:
- 35:bae9b236070b
- Child:
- 37:f0fcc0341654
- Child:
- 39:df7c8bd2212e
This is a stable revision that has the ability to communicate information over LoRa reliably at 174 frames received per second. This is the Revision before OLED Capabilities are introduced.
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
Helmut64 | 0:c43b6919ae15 | 1 | /* |
Helmut64 | 17:98f2528e8399 | 2 | * Copyright (c) 2018 HELIOS Software GmbH |
Helmut64 | 0:c43b6919ae15 | 3 | * 30826 Garbsen (Hannover) Germany |
Helmut64 | 0:c43b6919ae15 | 4 | * Licensed under the Apache License, Version 2.0); |
Helmut64 | 0:c43b6919ae15 | 5 | */ |
dev_alexander | 21:1b92cabe8a3b | 6 | |
dev_alexander | 21:1b92cabe8a3b | 7 | /* |
dev_alexander | 21:1b92cabe8a3b | 8 | * For Wiring Instructions, please visit the link below: |
dev_alexander | 21:1b92cabe8a3b | 9 | * https://www.hackster.io/DevinAlex64/getting-started-with-the-max32620fthr-and-lora-f9d8dd\ |
dev_alexander | 21:1b92cabe8a3b | 10 | */ |
dev_alexander | 21:1b92cabe8a3b | 11 | |
dev_alexander | 30:66f9750cc44c | 12 | #include "main.h" |
dev_alexander | 30:66f9750cc44c | 13 | #include "global_buffers.h" |
dev_alexander | 30:66f9750cc44c | 14 | #include "GridEye.h" |
dev_alexander | 32:b108ed6096b0 | 15 | |
dev_alexander | 35:bae9b236070b | 16 | //#define DEBUG_GRID_EYE |
dev_alexander | 32:b108ed6096b0 | 17 | #define RASPBERRY_PI |
dev_alexander | 32:b108ed6096b0 | 18 | |
dev_alexander | 23:f74a50977593 | 19 | |
dev_alexander | 23:f74a50977593 | 20 | /* If the board that is compiled is the master device (BLE enabled MAX32630FTHR), |
dev_alexander | 23:f74a50977593 | 21 | * then it needs this library and needs to be configed in order for the device to |
dev_alexander | 23:f74a50977593 | 22 | * work with a 3.3volt output instead of a 1.8 volt output. |
dev_alexander | 23:f74a50977593 | 23 | * |
dev_alexander | 23:f74a50977593 | 24 | * This is only needed for the MAX32630FTHR. The MAX325620FTHR is exampt from this |
dev_alexander | 23:f74a50977593 | 25 | * additional setup in the main program. |
dev_alexander | 23:f74a50977593 | 26 | */ |
dev_alexander | 31:f15747cffb20 | 27 | |
dev_alexander | 31:f15747cffb20 | 28 | #if defined(TARGET_MAX32620FTHR) |
dev_alexander | 32:b108ed6096b0 | 29 | // Definitions for running board off of battery |
dev_alexander | 32:b108ed6096b0 | 30 | #define POWER_HOLD_ON 1 |
dev_alexander | 32:b108ed6096b0 | 31 | #define POWER_HOLD_OFF 0 |
dev_alexander | 32:b108ed6096b0 | 32 | |
dev_alexander | 32:b108ed6096b0 | 33 | // MAX77650 |
dev_alexander | 32:b108ed6096b0 | 34 | DigitalOut pw_Hold(P2_2, POWER_HOLD_ON); |
dev_alexander | 32:b108ed6096b0 | 35 | |
dev_alexander | 32:b108ed6096b0 | 36 | // Initialize GPS |
dev_alexander | 32:b108ed6096b0 | 37 | #include "GPS.h" |
dev_alexander | 31:f15747cffb20 | 38 | GPS gps(P0_1, P0_0, 115200); |
dev_alexander | 32:b108ed6096b0 | 39 | |
dev_alexander | 32:b108ed6096b0 | 40 | // Motor Driver initialization |
dev_alexander | 32:b108ed6096b0 | 41 | #include "Adafruit_MotorShield.h" |
dev_alexander | 32:b108ed6096b0 | 42 | #include "Adafruit_PWMServoDriver.h" |
dev_alexander | 32:b108ed6096b0 | 43 | |
dev_alexander | 32:b108ed6096b0 | 44 | #define MOTOR_OFF 0 |
dev_alexander | 32:b108ed6096b0 | 45 | #define MOTOR_FORWARD 150 |
dev_alexander | 32:b108ed6096b0 | 46 | #define MOTOR_BACKWARD 150 |
dev_alexander | 32:b108ed6096b0 | 47 | #define MOTOR_TURN 100 |
dev_alexander | 32:b108ed6096b0 | 48 | |
dev_alexander | 32:b108ed6096b0 | 49 | |
dev_alexander | 32:b108ed6096b0 | 50 | // Create the motor shield object with the default I2C address |
dev_alexander | 32:b108ed6096b0 | 51 | //Adafruit_MotorShield AFMS = Adafruit_MotorShield(p9, p10, 0x60 << 1); |
dev_alexander | 32:b108ed6096b0 | 52 | Adafruit_MotorShield AFMS = Adafruit_MotorShield(P3_4, P3_5, 0x60 << 1); |
dev_alexander | 32:b108ed6096b0 | 53 | // Or, create it with a different I2C address (say for stacking) |
dev_alexander | 32:b108ed6096b0 | 54 | // Adafruit_MotorShield AFMS = Adafruit_MotorShield(0x61); |
dev_alexander | 32:b108ed6096b0 | 55 | |
dev_alexander | 32:b108ed6096b0 | 56 | // Select which 'port' M1, M2, M3 or M4. In this case, M1 |
dev_alexander | 32:b108ed6096b0 | 57 | Adafruit_DCMotor *rightMotor = AFMS.getMotor(1); |
dev_alexander | 32:b108ed6096b0 | 58 | Adafruit_DCMotor *leftMotor = AFMS.getMotor(4); |
dev_alexander | 32:b108ed6096b0 | 59 | // You can also make another motor on port M2 |
dev_alexander | 32:b108ed6096b0 | 60 | //Adafruit_DCMotor *myOtherMotor = AFMS.getMotor(2); |
dev_alexander | 32:b108ed6096b0 | 61 | |
dev_alexander | 32:b108ed6096b0 | 62 | #endif |
dev_alexander | 32:b108ed6096b0 | 63 | |
dev_alexander | 32:b108ed6096b0 | 64 | #if defined(TARGET_MAX32620FTHR) |
dev_alexander | 32:b108ed6096b0 | 65 | void MotorController(uint8_t (BLE_data_server)[2]) |
dev_alexander | 32:b108ed6096b0 | 66 | { |
dev_alexander | 32:b108ed6096b0 | 67 | uint8_t button_state; |
dev_alexander | 32:b108ed6096b0 | 68 | uint8_t direction; |
dev_alexander | 32:b108ed6096b0 | 69 | /*Set up constants for direction of motion */ |
dev_alexander | 32:b108ed6096b0 | 70 | const char FRONT = '5'; |
dev_alexander | 32:b108ed6096b0 | 71 | const char BACK = '6'; |
dev_alexander | 32:b108ed6096b0 | 72 | const char LEFT = '7'; |
dev_alexander | 32:b108ed6096b0 | 73 | const char RIGHT = '8'; |
dev_alexander | 32:b108ed6096b0 | 74 | |
dev_alexander | 32:b108ed6096b0 | 75 | /*Set up constants for button state */ |
dev_alexander | 32:b108ed6096b0 | 76 | const char PRESSED = '1'; |
dev_alexander | 32:b108ed6096b0 | 77 | const char RELEASED = '0'; |
dev_alexander | 32:b108ed6096b0 | 78 | |
dev_alexander | 32:b108ed6096b0 | 79 | |
dev_alexander | 32:b108ed6096b0 | 80 | button_state = BLE_data_server[1]; |
dev_alexander | 32:b108ed6096b0 | 81 | direction = BLE_data_server[0]; |
dev_alexander | 32:b108ed6096b0 | 82 | |
dev_alexander | 32:b108ed6096b0 | 83 | switch (button_state) |
dev_alexander | 32:b108ed6096b0 | 84 | { |
dev_alexander | 32:b108ed6096b0 | 85 | case PRESSED: |
dev_alexander | 32:b108ed6096b0 | 86 | //md_left_pwm = static_cast<float>(20/100.0F); |
dev_alexander | 32:b108ed6096b0 | 87 | //md_right_pwm = static_cast<float>(20/100.0F); |
dev_alexander | 32:b108ed6096b0 | 88 | |
dev_alexander | 32:b108ed6096b0 | 89 | switch (direction) |
dev_alexander | 32:b108ed6096b0 | 90 | { |
dev_alexander | 32:b108ed6096b0 | 91 | case FRONT: |
dev_alexander | 32:b108ed6096b0 | 92 | rightMotor->run(FORWARD); |
dev_alexander | 32:b108ed6096b0 | 93 | leftMotor->run(FORWARD); |
dev_alexander | 32:b108ed6096b0 | 94 | rightMotor->setSpeed(MOTOR_FORWARD); |
dev_alexander | 32:b108ed6096b0 | 95 | leftMotor->setSpeed(MOTOR_FORWARD); |
dev_alexander | 32:b108ed6096b0 | 96 | break; |
dev_alexander | 32:b108ed6096b0 | 97 | case BACK: |
dev_alexander | 32:b108ed6096b0 | 98 | rightMotor->run(BACKWARD); |
dev_alexander | 32:b108ed6096b0 | 99 | leftMotor->run(BACKWARD); |
dev_alexander | 32:b108ed6096b0 | 100 | rightMotor->setSpeed(MOTOR_BACKWARD); |
dev_alexander | 32:b108ed6096b0 | 101 | leftMotor->setSpeed(MOTOR_BACKWARD); |
dev_alexander | 32:b108ed6096b0 | 102 | break; |
dev_alexander | 32:b108ed6096b0 | 103 | case LEFT: |
dev_alexander | 32:b108ed6096b0 | 104 | rightMotor->run(FORWARD); |
dev_alexander | 32:b108ed6096b0 | 105 | leftMotor->run(BACKWARD); |
dev_alexander | 32:b108ed6096b0 | 106 | rightMotor->setSpeed(MOTOR_TURN); |
dev_alexander | 32:b108ed6096b0 | 107 | leftMotor->setSpeed(MOTOR_TURN); |
dev_alexander | 32:b108ed6096b0 | 108 | break; |
dev_alexander | 32:b108ed6096b0 | 109 | case RIGHT: |
dev_alexander | 32:b108ed6096b0 | 110 | rightMotor->run(BACKWARD); |
dev_alexander | 32:b108ed6096b0 | 111 | leftMotor->run(FORWARD); |
dev_alexander | 32:b108ed6096b0 | 112 | rightMotor->setSpeed(MOTOR_TURN); |
dev_alexander | 32:b108ed6096b0 | 113 | leftMotor->setSpeed(MOTOR_TURN); |
dev_alexander | 32:b108ed6096b0 | 114 | break; |
dev_alexander | 32:b108ed6096b0 | 115 | } |
dev_alexander | 32:b108ed6096b0 | 116 | break; |
dev_alexander | 32:b108ed6096b0 | 117 | case RELEASED: |
dev_alexander | 32:b108ed6096b0 | 118 | rightMotor->setSpeed(MOTOR_OFF); |
dev_alexander | 32:b108ed6096b0 | 119 | leftMotor->setSpeed(MOTOR_OFF); |
dev_alexander | 32:b108ed6096b0 | 120 | break; |
dev_alexander | 32:b108ed6096b0 | 121 | } |
dev_alexander | 32:b108ed6096b0 | 122 | } |
dev_alexander | 29:f7a0e49b826b | 123 | #endif |
Helmut64 | 0:c43b6919ae15 | 124 | |
dev_alexander | 31:f15747cffb20 | 125 | #if defined(TARGET_MAX32630FTHR) |
dev_alexander | 31:f15747cffb20 | 126 | #include "max32630fthr.h" |
dev_alexander | 31:f15747cffb20 | 127 | MAX32630FTHR pegasus(MAX32630FTHR::VIO_3V3); |
dev_alexander | 31:f15747cffb20 | 128 | |
dev_alexander | 31:f15747cffb20 | 129 | #define COMPILE_BLE |
dev_alexander | 31:f15747cffb20 | 130 | |
dev_alexander | 31:f15747cffb20 | 131 | #if defined(COMPILE_BLE) |
dev_alexander | 31:f15747cffb20 | 132 | /* BLE Related MAX32630FTHR Specific stuff */ |
dev_alexander | 31:f15747cffb20 | 133 | #include "ble/BLE.h" |
dev_alexander | 31:f15747cffb20 | 134 | //#include "ble/Gap.h" |
dev_alexander | 31:f15747cffb20 | 135 | #include "UARTService_custom.h" |
dev_alexander | 31:f15747cffb20 | 136 | #include <events/mbed_events.h> |
dev_alexander | 31:f15747cffb20 | 137 | |
dev_alexander | 31:f15747cffb20 | 138 | DigitalOut led2(LED2); |
dev_alexander | 31:f15747cffb20 | 139 | UARTService *uart; |
dev_alexander | 30:66f9750cc44c | 140 | |
dev_alexander | 31:f15747cffb20 | 141 | #define NEED_CONSOLE_OUTPUT 1 /* Set this if you need debug messages on the console; |
dev_alexander | 31:f15747cffb20 | 142 | * it will have an impact on code-size and power consumption. */ |
dev_alexander | 31:f15747cffb20 | 143 | |
dev_alexander | 31:f15747cffb20 | 144 | #if NEED_CONSOLE_OUTPUT |
dev_alexander | 31:f15747cffb20 | 145 | #define DEBUG(STR) { if (uart) uart->write(STR, strlen(STR)); } |
dev_alexander | 31:f15747cffb20 | 146 | #define READ(STR) { if (uart) uart->read(STR, strlen(STR)); } |
dev_alexander | 31:f15747cffb20 | 147 | |
dev_alexander | 31:f15747cffb20 | 148 | #else |
dev_alexander | 31:f15747cffb20 | 149 | #define DEBUG(...) /* nothing */ |
dev_alexander | 31:f15747cffb20 | 150 | #endif /* #if NEED_CONSOLE_OUTPUT */ |
dev_alexander | 31:f15747cffb20 | 151 | |
dev_alexander | 31:f15747cffb20 | 152 | //Triggered when the robot is disconnected from the mobile app. |
dev_alexander | 31:f15747cffb20 | 153 | void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params) |
dev_alexander | 31:f15747cffb20 | 154 | { |
dev_alexander | 31:f15747cffb20 | 155 | BLE &ble = BLE::Instance(); |
dev_alexander | 31:f15747cffb20 | 156 | DEBUG("Disconnected!\n\r"); |
dev_alexander | 31:f15747cffb20 | 157 | DEBUG("Restarting the advertising process\n\r"); |
dev_alexander | 31:f15747cffb20 | 158 | ble.gap().startAdvertising(); |
dev_alexander | 31:f15747cffb20 | 159 | } |
dev_alexander | 31:f15747cffb20 | 160 | |
dev_alexander | 31:f15747cffb20 | 161 | /* This pointer is needed to reference data in the main program when filling |
dev_alexander | 31:f15747cffb20 | 162 | * with data from the BLE |
dev_alexander | 31:f15747cffb20 | 163 | */ |
dev_alexander | 31:f15747cffb20 | 164 | uint8_t * onDataWritten_curr_ble_to_slave; |
dev_alexander | 30:66f9750cc44c | 165 | |
dev_alexander | 31:f15747cffb20 | 166 | // Triggered when there is data written |
dev_alexander | 31:f15747cffb20 | 167 | void onDataWritten(const GattWriteCallbackParams *params) |
dev_alexander | 31:f15747cffb20 | 168 | { |
dev_alexander | 31:f15747cffb20 | 169 | //LED1 will be off when button is pressed, and on when button is released. |
dev_alexander | 31:f15747cffb20 | 170 | led2 = !led2; |
dev_alexander | 31:f15747cffb20 | 171 | uint8_t button_state; |
dev_alexander | 31:f15747cffb20 | 172 | uint8_t direction; |
dev_alexander | 32:b108ed6096b0 | 173 | |
dev_alexander | 31:f15747cffb20 | 174 | /* If there is a valid data sent by the mobile app */ |
dev_alexander | 31:f15747cffb20 | 175 | if ((uart != NULL) && (params->handle == uart ->getTXCharacteristicHandle())) { |
dev_alexander | 31:f15747cffb20 | 176 | const uint8_t *packet = params->data; |
dev_alexander | 31:f15747cffb20 | 177 | button_state = packet[3]; |
dev_alexander | 31:f15747cffb20 | 178 | direction = packet[2]; |
dev_alexander | 31:f15747cffb20 | 179 | |
dev_alexander | 31:f15747cffb20 | 180 | // make parameter to send over Lora |
dev_alexander | 31:f15747cffb20 | 181 | onDataWritten_curr_ble_to_slave[0] = direction; |
dev_alexander | 31:f15747cffb20 | 182 | onDataWritten_curr_ble_to_slave[1] = button_state; |
dev_alexander | 31:f15747cffb20 | 183 | |
dev_alexander | 33:52c898aca207 | 184 | //dprintf("direction: %d\n", direction); |
dev_alexander | 33:52c898aca207 | 185 | //dprintf("button_state: %d\n", button_state); |
dev_alexander | 30:66f9750cc44c | 186 | } |
dev_alexander | 30:66f9750cc44c | 187 | } |
dev_alexander | 31:f15747cffb20 | 188 | #endif |
dev_alexander | 30:66f9750cc44c | 189 | #endif |
dev_alexander | 30:66f9750cc44c | 190 | |
Helmut64 | 17:98f2528e8399 | 191 | DigitalOut myled(LED); |
Helmut64 | 0:c43b6919ae15 | 192 | |
dev_alexander | 28:0ed92c590607 | 193 | Serial pc(USBTX, USBRX); |
dev_alexander | 25:1a031add188a | 194 | |
Helmut64 | 0:c43b6919ae15 | 195 | |
dev_alexander | 23:f74a50977593 | 196 | #if defined(TARGET_MAX32630FTHR) // Master Device: MAX32630FTHR BLE-to-LoRa Gateway |
dev_alexander | 23:f74a50977593 | 197 | /* No grid eye object needed. The function the master uses to convert the raw |
dev_alexander | 23:f74a50977593 | 198 | * data that is sent over from the slave deevice that contains the data from the |
dev_alexander | 23:f74a50977593 | 199 | * actual grid eye sensor is actually a function that is not part of the grid eye |
dev_alexander | 23:f74a50977593 | 200 | * class. this is due to the fact that the grid eye class requires n i2c bus to |
dev_alexander | 23:f74a50977593 | 201 | * be assigned to a phyiscal sensor. In this case, the library for the Grid Eye |
dev_alexander | 32:b108ed6096b0 | 202 | * sensor has a support function that is used to convert data that is aquired from |
dev_alexander | 23:f74a50977593 | 203 | * the grid eye sensor. So it is not supposed to be a class specific function. |
dev_alexander | 23:f74a50977593 | 204 | */ |
dev_alexander | 32:b108ed6096b0 | 205 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 23:f74a50977593 | 206 | //Init I2C communications in default I2C bus I2C #1 |
dev_alexander | 32:b108ed6096b0 | 207 | // I2C i2cGridEye(SDA,SCL); |
dev_alexander | 32:b108ed6096b0 | 208 | //I2C i2cGridEye(P3_4,P3_5); |
dev_alexander | 32:b108ed6096b0 | 209 | I2C i2cGridEye(P1_6,P1_7); |
dev_alexander | 23:f74a50977593 | 210 | GridEye gridEye(i2cGridEye); |
dev_alexander | 23:f74a50977593 | 211 | #endif |
dev_alexander | 19:9f035b9e65ec | 212 | |
dev_alexander | 23:f74a50977593 | 213 | int main() |
dev_alexander | 23:f74a50977593 | 214 | { |
dev_alexander | 32:b108ed6096b0 | 215 | /* Setup begins here: */ |
dev_alexander | 32:b108ed6096b0 | 216 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 32:b108ed6096b0 | 217 | dprintf("MAX32630FTHR: Master"); |
dev_alexander | 32:b108ed6096b0 | 218 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 32:b108ed6096b0 | 219 | dprintf("MAX32620FTHR: Slave"); |
dev_alexander | 32:b108ed6096b0 | 220 | #endif |
dev_alexander | 32:b108ed6096b0 | 221 | |
dev_alexander | 32:b108ed6096b0 | 222 | |
dev_alexander | 32:b108ed6096b0 | 223 | #if defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 32:b108ed6096b0 | 224 | //Set Power Hold High for battery operation MAX77650 on MAX32620FTHR |
dev_alexander | 32:b108ed6096b0 | 225 | pw_Hold = POWER_HOLD_ON; |
dev_alexander | 32:b108ed6096b0 | 226 | #endif |
dev_alexander | 32:b108ed6096b0 | 227 | |
Helmut64 | 17:98f2528e8399 | 228 | /* |
Helmut64 | 17:98f2528e8399 | 229 | * inits the Serial or USBSerial when available (230400 baud). |
Helmut64 | 17:98f2528e8399 | 230 | * If the serial uart is not is not connected it swiches to USB Serial |
Helmut64 | 17:98f2528e8399 | 231 | * blinking LED means USBSerial detected, waiting for a connect. |
Helmut64 | 17:98f2528e8399 | 232 | * It waits up to 30 seconds for a USB terminal connections |
Helmut64 | 17:98f2528e8399 | 233 | */ |
Helmut64 | 17:98f2528e8399 | 234 | InitSerial(30*1000, &myled); |
Helmut64 | 17:98f2528e8399 | 235 | dprintf("Welcome to the SX1276GenericLib"); |
Helmut64 | 18:d5527ce82e6b | 236 | |
Helmut64 | 17:98f2528e8399 | 237 | dprintf("Starting a simple LoRa PingPong"); |
dev_alexander | 23:f74a50977593 | 238 | |
dev_alexander | 32:b108ed6096b0 | 239 | |
dev_alexander | 26:69aba05f010f | 240 | |
dev_alexander | 23:f74a50977593 | 241 | |
dev_alexander | 23:f74a50977593 | 242 | /*************************************************************************** |
dev_alexander | 23:f74a50977593 | 243 | * Grid Eye Sensor: Non-Buffer Program Variables |
dev_alexander | 23:f74a50977593 | 244 | **************************************************************************/ |
dev_alexander | 23:f74a50977593 | 245 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 23:f74a50977593 | 246 | int frame_idx = 0; |
dev_alexander | 24:e8d03912f303 | 247 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 32:b108ed6096b0 | 248 | #if defined(DEBUG_GRID_EYE_SLAVE) |
dev_alexander | 32:b108ed6096b0 | 249 | int frame_idx = 0; |
dev_alexander | 32:b108ed6096b0 | 250 | #endif |
dev_alexander | 23:f74a50977593 | 251 | #endif |
dev_alexander | 23:f74a50977593 | 252 | |
dev_alexander | 23:f74a50977593 | 253 | |
dev_alexander | 28:0ed92c590607 | 254 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 255 | * Combined Payload Buffers for LoRa Communications |
dev_alexander | 28:0ed92c590607 | 256 | **************************************************************************/ |
dev_alexander | 28:0ed92c590607 | 257 | uint8_t BufferTx[BufferSizeTx]; |
dev_alexander | 28:0ed92c590607 | 258 | uint8_t BufferRx[BufferSizeRx]; |
dev_alexander | 28:0ed92c590607 | 259 | |
dev_alexander | 28:0ed92c590607 | 260 | /*************************************************************************** |
dev_alexander | 32:b108ed6096b0 | 261 | * Identification Buffers |
dev_alexander | 32:b108ed6096b0 | 262 | **************************************************************************/ |
dev_alexander | 32:b108ed6096b0 | 263 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 32:b108ed6096b0 | 264 | uint8_t ID_of_slave[size_signature]; |
dev_alexander | 32:b108ed6096b0 | 265 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 32:b108ed6096b0 | 266 | uint8_t ID_of_master[size_signature]; |
dev_alexander | 32:b108ed6096b0 | 267 | #endif |
dev_alexander | 32:b108ed6096b0 | 268 | |
dev_alexander | 32:b108ed6096b0 | 269 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 270 | * BLE Data Buffers |
dev_alexander | 28:0ed92c590607 | 271 | **************************************************************************/ |
dev_alexander | 28:0ed92c590607 | 272 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 31:f15747cffb20 | 273 | uint8_t curr_ble_to_slave[size_of_ble]; |
dev_alexander | 28:0ed92c590607 | 274 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 28:0ed92c590607 | 275 | uint8_t curr_ble_from_master[size_of_ble]; |
dev_alexander | 28:0ed92c590607 | 276 | uint8_t prev_ble_from_master[size_of_ble]; |
dev_alexander | 28:0ed92c590607 | 277 | #endif |
dev_alexander | 28:0ed92c590607 | 278 | |
dev_alexander | 28:0ed92c590607 | 279 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 280 | * Grid Eye Sensor Data Buffers |
dev_alexander | 28:0ed92c590607 | 281 | **************************************************************************/ |
dev_alexander | 28:0ed92c590607 | 282 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 28:0ed92c590607 | 283 | char curr_raw_frame_from_slave[size_of_grid_eye]; |
dev_alexander | 28:0ed92c590607 | 284 | char prev_raw_frame_from_slave[size_of_grid_eye]; |
dev_alexander | 28:0ed92c590607 | 285 | int16_t conv_frame_from_slave[64]; |
dev_alexander | 28:0ed92c590607 | 286 | #elif defined(TARGET_MAX32620FTHR) // Client Device: LoRa Controlled Robot |
dev_alexander | 28:0ed92c590607 | 287 | char curr_raw_frame_to_master[size_of_grid_eye]; |
dev_alexander | 28:0ed92c590607 | 288 | char prev_raw_frame_to_master[size_of_grid_eye]; |
dev_alexander | 28:0ed92c590607 | 289 | int16_t conv_frame_to_master[64]; |
dev_alexander | 28:0ed92c590607 | 290 | #endif |
dev_alexander | 28:0ed92c590607 | 291 | |
dev_alexander | 28:0ed92c590607 | 292 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 293 | * GPS Data Buffers |
dev_alexander | 28:0ed92c590607 | 294 | **************************************************************************/ |
dev_alexander | 28:0ed92c590607 | 295 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 28:0ed92c590607 | 296 | uint8_t curr_gps_from_slave[size_of_gps]; |
dev_alexander | 28:0ed92c590607 | 297 | uint8_t prev_gps_from_slave[size_of_gps]; |
dev_alexander | 28:0ed92c590607 | 298 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 28:0ed92c590607 | 299 | uint8_t curr_gps_to_master[size_of_gps]; |
dev_alexander | 28:0ed92c590607 | 300 | #endif |
dev_alexander | 28:0ed92c590607 | 301 | |
dev_alexander | 28:0ed92c590607 | 302 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 303 | * MAX17055 Data Buffers |
dev_alexander | 28:0ed92c590607 | 304 | **************************************************************************/ |
dev_alexander | 28:0ed92c590607 | 305 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 28:0ed92c590607 | 306 | uint8_t curr_MAX17055_from_slave[size_of_MAX17055]; |
dev_alexander | 28:0ed92c590607 | 307 | uint8_t prev_MAX17055_from_slave[size_of_MAX17055]; |
dev_alexander | 28:0ed92c590607 | 308 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 28:0ed92c590607 | 309 | uint8_t curr_MAX17055_to_master[size_of_MAX17055]; |
dev_alexander | 28:0ed92c590607 | 310 | #endif |
dev_alexander | 28:0ed92c590607 | 311 | |
dev_alexander | 28:0ed92c590607 | 312 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 313 | * MAX77650 Data Buffers |
dev_alexander | 28:0ed92c590607 | 314 | **************************************************************************/ |
dev_alexander | 28:0ed92c590607 | 315 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 28:0ed92c590607 | 316 | uint8_t curr_MAX77650_from_slave[size_of_MAX77650]; |
dev_alexander | 28:0ed92c590607 | 317 | uint8_t prev_MAX77650_from_slave[size_of_MAX77650]; |
dev_alexander | 28:0ed92c590607 | 318 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 28:0ed92c590607 | 319 | uint8_t curr_MAX77650_to_master[size_of_MAX77650]; |
dev_alexander | 28:0ed92c590607 | 320 | #endif |
dev_alexander | 28:0ed92c590607 | 321 | |
dev_alexander | 28:0ed92c590607 | 322 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 323 | * Finish Setting up LoRa Radios: This passes in pointers to Buffers to send |
dev_alexander | 28:0ed92c590607 | 324 | **************************************************************************/ |
dev_alexander | 28:0ed92c590607 | 325 | SX1276PingPongSetup(BufferTx, BufferRx); |
dev_alexander | 28:0ed92c590607 | 326 | |
dev_alexander | 32:b108ed6096b0 | 327 | /*************************************************************************** |
dev_alexander | 32:b108ed6096b0 | 328 | * Finish Setting up BLE Radio on the MAX32630FTHR: Only on the Master Device |
dev_alexander | 32:b108ed6096b0 | 329 | **************************************************************************/ |
dev_alexander | 32:b108ed6096b0 | 330 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 32:b108ed6096b0 | 331 | BLE &ble = BLE::Instance(); |
dev_alexander | 32:b108ed6096b0 | 332 | /* Create alias for the BLE data to be saved in function above that |
dev_alexander | 32:b108ed6096b0 | 333 | * writes data to this buffer when function onDataWritten is called |
dev_alexander | 32:b108ed6096b0 | 334 | */ |
dev_alexander | 32:b108ed6096b0 | 335 | onDataWritten_curr_ble_to_slave = curr_ble_to_slave; |
dev_alexander | 32:b108ed6096b0 | 336 | |
dev_alexander | 32:b108ed6096b0 | 337 | /* Initialize BLE */ |
dev_alexander | 32:b108ed6096b0 | 338 | ble.init(); |
dev_alexander | 32:b108ed6096b0 | 339 | ble.gap().onDisconnection(disconnectionCallback); |
dev_alexander | 32:b108ed6096b0 | 340 | ble.gattServer().onDataWritten(onDataWritten); |
dev_alexander | 32:b108ed6096b0 | 341 | uart = new UARTService(ble); |
dev_alexander | 32:b108ed6096b0 | 342 | /* setup advertising */ |
dev_alexander | 32:b108ed6096b0 | 343 | ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED); |
dev_alexander | 32:b108ed6096b0 | 344 | ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED); |
dev_alexander | 32:b108ed6096b0 | 345 | ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME, |
dev_alexander | 32:b108ed6096b0 | 346 | (const uint8_t *)"BLE UART", sizeof("BLE UART") - 1); |
dev_alexander | 32:b108ed6096b0 | 347 | ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS, |
dev_alexander | 32:b108ed6096b0 | 348 | (const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed)); |
dev_alexander | 32:b108ed6096b0 | 349 | ble.gap().setAdvertisingInterval(160); /* 100ms; in multiples of 0.625ms. */ |
dev_alexander | 32:b108ed6096b0 | 350 | ble.gap().startAdvertising(); |
dev_alexander | 32:b108ed6096b0 | 351 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 32:b108ed6096b0 | 352 | /* There is no BLE device that is integrated into the MAX32620FTHR. Also |
dev_alexander | 32:b108ed6096b0 | 353 | * Also this program is meant to use the BLE gateway on the MAX32630FTHR |
dev_alexander | 32:b108ed6096b0 | 354 | */ |
dev_alexander | 32:b108ed6096b0 | 355 | #endif |
dev_alexander | 32:b108ed6096b0 | 356 | |
dev_alexander | 32:b108ed6096b0 | 357 | /*************************************************************************** |
dev_alexander | 32:b108ed6096b0 | 358 | * Finish Setting up the motor controller on the MAX32620FTHR: Only on the Slave Device |
dev_alexander | 32:b108ed6096b0 | 359 | **************************************************************************/ |
dev_alexander | 32:b108ed6096b0 | 360 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 32:b108ed6096b0 | 361 | // No setup on the master device |
dev_alexander | 32:b108ed6096b0 | 362 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 32:b108ed6096b0 | 363 | AFMS.begin(); // create with the default frequency 1.6KHz |
dev_alexander | 32:b108ed6096b0 | 364 | //AFMS.begin(1000); // OR with a different frequency, say 1KHz |
dev_alexander | 32:b108ed6096b0 | 365 | |
dev_alexander | 32:b108ed6096b0 | 366 | // Set the speed to start, from 0 (off) to 255 (max speed) |
dev_alexander | 32:b108ed6096b0 | 367 | rightMotor->setSpeed(150); |
dev_alexander | 32:b108ed6096b0 | 368 | rightMotor->run(FORWARD); |
dev_alexander | 32:b108ed6096b0 | 369 | // turn on motor |
dev_alexander | 32:b108ed6096b0 | 370 | rightMotor->run(RELEASE); |
dev_alexander | 32:b108ed6096b0 | 371 | |
dev_alexander | 32:b108ed6096b0 | 372 | leftMotor->setSpeed(150); |
dev_alexander | 32:b108ed6096b0 | 373 | leftMotor->run(FORWARD); |
dev_alexander | 32:b108ed6096b0 | 374 | // turn on motor |
dev_alexander | 32:b108ed6096b0 | 375 | leftMotor->run(RELEASE); |
dev_alexander | 32:b108ed6096b0 | 376 | #endif |
dev_alexander | 32:b108ed6096b0 | 377 | |
dev_alexander | 32:b108ed6096b0 | 378 | |
dev_alexander | 22:abca9d17d13d | 379 | while(1) |
dev_alexander | 28:0ed92c590607 | 380 | { |
dev_alexander | 23:f74a50977593 | 381 | /*************************************************************************** |
dev_alexander | 30:66f9750cc44c | 382 | * BLE Radio Data |
dev_alexander | 30:66f9750cc44c | 383 | **************************************************************************/ |
dev_alexander | 30:66f9750cc44c | 384 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 30:66f9750cc44c | 385 | #if defined(COMPILE_BLE) |
dev_alexander | 30:66f9750cc44c | 386 | ble.waitForEvent(); |
dev_alexander | 30:66f9750cc44c | 387 | #endif |
dev_alexander | 30:66f9750cc44c | 388 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 32:b108ed6096b0 | 389 | memcpy(curr_ble_from_master, prev_ble_from_master, sizeof(curr_ble_from_master)); |
dev_alexander | 30:66f9750cc44c | 390 | #endif |
dev_alexander | 30:66f9750cc44c | 391 | |
dev_alexander | 30:66f9750cc44c | 392 | /*************************************************************************** |
dev_alexander | 23:f74a50977593 | 393 | * Grid Eye Sensor |
dev_alexander | 23:f74a50977593 | 394 | **************************************************************************/ |
dev_alexander | 23:f74a50977593 | 395 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 28:0ed92c590607 | 396 | // 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 | 397 | #if defined(RASPBERRY_PI) |
dev_alexander | 32:b108ed6096b0 | 398 | if( memcmp(prev_raw_frame_from_slave, curr_raw_frame_from_slave, sizeof(curr_raw_frame_from_slave)) != 0 ) |
dev_alexander | 32:b108ed6096b0 | 399 | { |
dev_alexander | 32:b108ed6096b0 | 400 | char grid_eye_msg[130]; |
dev_alexander | 32:b108ed6096b0 | 401 | grid_eye_msg[0]=0x55; |
dev_alexander | 32:b108ed6096b0 | 402 | grid_eye_msg[1]=0xaa; |
dev_alexander | 32:b108ed6096b0 | 403 | for (int idx = 0; idx < 128; idx++) |
dev_alexander | 32:b108ed6096b0 | 404 | grid_eye_msg[idx+2] = curr_raw_frame_from_slave[idx]; |
dev_alexander | 32:b108ed6096b0 | 405 | //pc.printf(grid_eye_msg); |
dev_alexander | 32:b108ed6096b0 | 406 | for (int idx = 0; idx < 130; idx++) |
dev_alexander | 32:b108ed6096b0 | 407 | pc.putc(grid_eye_msg[idx]); |
dev_alexander | 35:bae9b236070b | 408 | pc.printf("\r\n"); // seperate the lines |
dev_alexander | 32:b108ed6096b0 | 409 | } |
dev_alexander | 35:bae9b236070b | 410 | #endif |
dev_alexander | 35:bae9b236070b | 411 | #if defined(DEBUG_GRID_EYE) |
dev_alexander | 32:b108ed6096b0 | 412 | if( memcmp(prev_raw_frame_from_slave, curr_raw_frame_from_slave, sizeof(curr_raw_frame_from_slave)) != 0 ) |
dev_alexander | 32:b108ed6096b0 | 413 | { |
dev_alexander | 32:b108ed6096b0 | 414 | // Convert raw data sent from slave to a 16 bit integer array by calling this |
dev_alexander | 32:b108ed6096b0 | 415 | convRaw8x8Data2Point25degC(curr_raw_frame_from_slave, conv_frame_from_slave); |
dev_alexander | 32:b108ed6096b0 | 416 | |
dev_alexander | 32:b108ed6096b0 | 417 | // Next Print off the Converted data |
dev_alexander | 32:b108ed6096b0 | 418 | pc.printf("\r\nFrame %d data: \r\n", frame_idx); |
dev_alexander | 32:b108ed6096b0 | 419 | uint8_t idx; |
dev_alexander | 32:b108ed6096b0 | 420 | float pixel_data; |
dev_alexander | 32:b108ed6096b0 | 421 | for (int y = 0; y < 8; y++) { |
dev_alexander | 32:b108ed6096b0 | 422 | for (int x = 0; x < 8; x++) { |
dev_alexander | 32:b108ed6096b0 | 423 | idx = y*8 + x; |
dev_alexander | 32:b108ed6096b0 | 424 | pixel_data = ((float)conv_frame_from_slave[idx])/4.0; |
dev_alexander | 32:b108ed6096b0 | 425 | pc.printf("%.2f \t", pixel_data); |
dev_alexander | 32:b108ed6096b0 | 426 | } |
dev_alexander | 32:b108ed6096b0 | 427 | pc.printf("\r\n\r\n"); |
dev_alexander | 23:f74a50977593 | 428 | } |
dev_alexander | 32:b108ed6096b0 | 429 | pc.printf("\r\n"); |
dev_alexander | 32:b108ed6096b0 | 430 | |
dev_alexander | 32:b108ed6096b0 | 431 | // Increment frame counter |
dev_alexander | 32:b108ed6096b0 | 432 | frame_idx = frame_idx +1; |
dev_alexander | 23:f74a50977593 | 433 | } |
dev_alexander | 32:b108ed6096b0 | 434 | #endif |
dev_alexander | 32:b108ed6096b0 | 435 | /* Next copy in data received from current data into buffer used for |
dev_alexander | 32:b108ed6096b0 | 436 | * comparison next time the memcmp above is called. This prevents the |
dev_alexander | 32:b108ed6096b0 | 437 | * program from converting the same raw data aquired by the grid eye |
dev_alexander | 32:b108ed6096b0 | 438 | * sensor on the slave device to the floating point array with the |
dev_alexander | 32:b108ed6096b0 | 439 | * 0.25 degrees celsius precision level when there is not new data. |
dev_alexander | 32:b108ed6096b0 | 440 | */ |
dev_alexander | 32:b108ed6096b0 | 441 | |
dev_alexander | 28:0ed92c590607 | 442 | memcpy(prev_raw_frame_from_slave, curr_raw_frame_from_slave, sizeof(curr_raw_frame_from_slave)); |
dev_alexander | 24:e8d03912f303 | 443 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 23:f74a50977593 | 444 | // Aquire raw data about 8x8 frame from the grid eye sensor in this function call |
dev_alexander | 28:0ed92c590607 | 445 | gridEye.getRaw8x8FrameData(curr_raw_frame_to_master); |
dev_alexander | 36:09e8b51fc91d | 446 | // wait_ms( 10 ); |
dev_alexander | 35:bae9b236070b | 447 | #if defined(RASPBERRY_PI) |
dev_alexander | 35:bae9b236070b | 448 | if( memcmp(prev_raw_frame_to_master, curr_raw_frame_to_master, sizeof(curr_raw_frame_to_master)) != 0 ) |
dev_alexander | 35:bae9b236070b | 449 | { |
dev_alexander | 35:bae9b236070b | 450 | char grid_eye_msg[130]; |
dev_alexander | 35:bae9b236070b | 451 | grid_eye_msg[0]=0x55; |
dev_alexander | 35:bae9b236070b | 452 | grid_eye_msg[1]=0xaa; |
dev_alexander | 35:bae9b236070b | 453 | for (int idx = 0; idx < 128; idx++) |
dev_alexander | 35:bae9b236070b | 454 | grid_eye_msg[idx+2] = curr_raw_frame_to_master[idx]; |
dev_alexander | 35:bae9b236070b | 455 | //pc.printf(grid_eye_msg); |
dev_alexander | 35:bae9b236070b | 456 | for (int idx = 0; idx < 130; idx++) |
dev_alexander | 35:bae9b236070b | 457 | pc.putc(grid_eye_msg[idx]); |
dev_alexander | 35:bae9b236070b | 458 | pc.printf("\r\n"); // seperate the lines |
dev_alexander | 35:bae9b236070b | 459 | } |
dev_alexander | 35:bae9b236070b | 460 | #endif |
dev_alexander | 35:bae9b236070b | 461 | #if defined(DEBUG_GRID_EYE) |
dev_alexander | 32:b108ed6096b0 | 462 | if( memcmp(prev_raw_frame_to_master, curr_raw_frame_to_master, sizeof(curr_raw_frame_to_master)) != 0 ) |
dev_alexander | 32:b108ed6096b0 | 463 | { |
dev_alexander | 32:b108ed6096b0 | 464 | // Convert raw data sent from slave to a 16 bit integer array by calling this |
dev_alexander | 32:b108ed6096b0 | 465 | convRaw8x8Data2Point25degC(curr_raw_frame_to_master, conv_frame_to_master); |
dev_alexander | 32:b108ed6096b0 | 466 | |
dev_alexander | 32:b108ed6096b0 | 467 | |
dev_alexander | 32:b108ed6096b0 | 468 | // Next Print off the Converted data |
dev_alexander | 32:b108ed6096b0 | 469 | pc.printf("\r\nFrame %d data: \r\n", frame_idx); |
dev_alexander | 32:b108ed6096b0 | 470 | uint8_t idx; |
dev_alexander | 32:b108ed6096b0 | 471 | float pixel_data; |
dev_alexander | 32:b108ed6096b0 | 472 | for (int y = 0; y < 8; y++) { |
dev_alexander | 32:b108ed6096b0 | 473 | for (int x = 0; x < 8; x++) { |
dev_alexander | 32:b108ed6096b0 | 474 | idx = y*8 + x; |
dev_alexander | 32:b108ed6096b0 | 475 | pixel_data = ((float)conv_frame_to_master[idx])/4.0; |
dev_alexander | 32:b108ed6096b0 | 476 | pc.printf("%.2f \t", pixel_data); |
dev_alexander | 32:b108ed6096b0 | 477 | } |
dev_alexander | 32:b108ed6096b0 | 478 | pc.printf("\r\n\r\n"); |
dev_alexander | 25:1a031add188a | 479 | } |
dev_alexander | 32:b108ed6096b0 | 480 | pc.printf("\r\n"); |
dev_alexander | 32:b108ed6096b0 | 481 | |
dev_alexander | 32:b108ed6096b0 | 482 | // Increment frame counter |
dev_alexander | 32:b108ed6096b0 | 483 | frame_idx = frame_idx +1; |
dev_alexander | 25:1a031add188a | 484 | } |
dev_alexander | 32:b108ed6096b0 | 485 | #endif |
dev_alexander | 36:09e8b51fc91d | 486 | // wait_ms( 10 ); |
dev_alexander | 33:52c898aca207 | 487 | memcpy(prev_raw_frame_to_master, curr_raw_frame_to_master, sizeof(curr_raw_frame_to_master)); |
dev_alexander | 31:f15747cffb20 | 488 | #endif |
dev_alexander | 31:f15747cffb20 | 489 | |
dev_alexander | 31:f15747cffb20 | 490 | /*************************************************************************** |
dev_alexander | 31:f15747cffb20 | 491 | * GPS Sensor |
dev_alexander | 31:f15747cffb20 | 492 | **************************************************************************/ |
dev_alexander | 31:f15747cffb20 | 493 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 31:f15747cffb20 | 494 | //None yet |
dev_alexander | 31:f15747cffb20 | 495 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 31:f15747cffb20 | 496 | // The testing hasnt been done yet for the GPS Module. Will do this when more parts come in. |
dev_alexander | 31:f15747cffb20 | 497 | /* |
dev_alexander | 31:f15747cffb20 | 498 | if(gps.sample()){ |
dev_alexander | 31:f15747cffb20 | 499 | 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 | 500 | pc.printf("%d:%d:%d",gps.hour,gps.minute,gps.seconed); |
dev_alexander | 31:f15747cffb20 | 501 | } |
dev_alexander | 31:f15747cffb20 | 502 | */ |
dev_alexander | 31:f15747cffb20 | 503 | #endif |
dev_alexander | 28:0ed92c590607 | 504 | |
dev_alexander | 23:f74a50977593 | 505 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 506 | * Fill Payload Buffer With Data From Sensors for LoRa Transmition |
dev_alexander | 28:0ed92c590607 | 507 | **************************************************************************/ |
dev_alexander | 28:0ed92c590607 | 508 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 28:0ed92c590607 | 509 | memcpy(&BufferTx[tx_idx_signature], PingMsg, size_signature); |
dev_alexander | 28:0ed92c590607 | 510 | memcpy(&BufferTx[tx_idx_ble], curr_ble_to_slave, size_of_ble); |
dev_alexander | 28:0ed92c590607 | 511 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 28:0ed92c590607 | 512 | memcpy(&BufferTx[tx_idx_signature], PongMsg, size_signature); |
dev_alexander | 28:0ed92c590607 | 513 | memcpy(&BufferTx[tx_idx_grid_eye], curr_raw_frame_to_master, size_of_grid_eye); |
dev_alexander | 28:0ed92c590607 | 514 | memcpy(&BufferTx[tx_idx_gps], curr_gps_to_master, size_of_gps); |
dev_alexander | 28:0ed92c590607 | 515 | memcpy(&BufferTx[tx_idx_MAX17055], curr_MAX17055_to_master, size_of_MAX17055); |
dev_alexander | 28:0ed92c590607 | 516 | memcpy(&BufferTx[tx_idx_MAX77650], curr_MAX77650_to_master, size_of_MAX77650); |
dev_alexander | 28:0ed92c590607 | 517 | #endif |
dev_alexander | 28:0ed92c590607 | 518 | |
dev_alexander | 28:0ed92c590607 | 519 | |
dev_alexander | 28:0ed92c590607 | 520 | |
dev_alexander | 32:b108ed6096b0 | 521 | |
dev_alexander | 28:0ed92c590607 | 522 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 523 | * Lora Communications |
dev_alexander | 28:0ed92c590607 | 524 | **************************************************************************/ |
dev_alexander | 36:09e8b51fc91d | 525 | // wait_ms( 10 ); |
dev_alexander | 22:abca9d17d13d | 526 | SX1276PingPong(); |
dev_alexander | 28:0ed92c590607 | 527 | |
dev_alexander | 28:0ed92c590607 | 528 | /*************************************************************************** |
dev_alexander | 28:0ed92c590607 | 529 | * Fill Global Buffers With Data From Received Payload Buffer |
dev_alexander | 28:0ed92c590607 | 530 | **************************************************************************/ |
dev_alexander | 28:0ed92c590607 | 531 | /* The master and slave devices will have different requirements for offloading payload */ |
dev_alexander | 28:0ed92c590607 | 532 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 32:b108ed6096b0 | 533 | memcpy(ID_of_slave, &BufferRx[rx_idx_signature], size_signature); |
dev_alexander | 32:b108ed6096b0 | 534 | memcpy(curr_raw_frame_from_slave, &BufferRx[rx_idx_grid_eye], size_of_grid_eye); |
dev_alexander | 32:b108ed6096b0 | 535 | memcpy(curr_gps_from_slave, &BufferRx[rx_idx_gps], size_of_gps); |
dev_alexander | 32:b108ed6096b0 | 536 | memcpy(curr_MAX17055_from_slave, &BufferRx[rx_idx_MAX17055], size_of_MAX17055); |
dev_alexander | 32:b108ed6096b0 | 537 | memcpy(curr_MAX77650_from_slave, &BufferRx[rx_idx_MAX77650], size_of_MAX77650); |
dev_alexander | 28:0ed92c590607 | 538 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 32:b108ed6096b0 | 539 | memcpy(ID_of_master, &BufferRx[rx_idx_signature], size_signature); |
dev_alexander | 32:b108ed6096b0 | 540 | memcpy(curr_ble_from_master, &BufferRx[rx_idx_ble], size_of_ble); |
dev_alexander | 28:0ed92c590607 | 541 | #endif |
dev_alexander | 23:f74a50977593 | 542 | |
dev_alexander | 32:b108ed6096b0 | 543 | /*************************************************************************** |
dev_alexander | 32:b108ed6096b0 | 544 | * Motor Controller controlls go here |
dev_alexander | 32:b108ed6096b0 | 545 | **************************************************************************/ |
dev_alexander | 32:b108ed6096b0 | 546 | #if defined(TARGET_MAX32630FTHR) // Master Device: BLE-to-LoRa Gateway |
dev_alexander | 32:b108ed6096b0 | 547 | // No motor controller on master |
dev_alexander | 32:b108ed6096b0 | 548 | #elif defined(TARGET_MAX32620FTHR) // Slave Device: LoRa Controlled Robot |
dev_alexander | 32:b108ed6096b0 | 549 | // 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 | 32:b108ed6096b0 | 550 | if( memcmp(prev_ble_from_master, curr_ble_from_master, sizeof(curr_ble_from_master)) != 0 ) |
dev_alexander | 32:b108ed6096b0 | 551 | { |
dev_alexander | 32:b108ed6096b0 | 552 | MotorController(curr_ble_from_master); |
dev_alexander | 32:b108ed6096b0 | 553 | } |
dev_alexander | 32:b108ed6096b0 | 554 | #endif |
dev_alexander | 23:f74a50977593 | 555 | |
dev_alexander | 23:f74a50977593 | 556 | |
dev_alexander | 23:f74a50977593 | 557 | |
dev_alexander | 22:abca9d17d13d | 558 | } |
dev_alexander | 22:abca9d17d13d | 559 | |
Helmut64 | 0:c43b6919ae15 | 560 | } |