NM500 / Mbed 2 deprecated NeuroShield_andIMU

NM500 NeuroShield and MPU6050 IMU Test Example

Dependencies:   mbed NeuroShield

main.cpp@2:28290f9caf51, 2020-02-11 (annotated)

Committer:
nepes_ai
Date:
Tue Feb 11 00:57:21 2020 +0000
Revision:
2:28290f9caf51
Parent:
1:fb672eb52bd6 
Release version 1.1.5

Who changed what in which revision?

UserRevisionLine numberNew contents of line
nepes_ai 0:123b50ed3ad9 1 /******************************************************************************
nepes_ai 1:fb672eb52bd6 2 * NM500 NeuroShield Board and mpu6050 imu Test example
nepes_ai 2:28290f9caf51 3 * revision 1.1.5, 2020/02/11
nepes_ai 0:123b50ed3ad9 4 * Copyright (c) 2017 nepes inc.
nepes_ai 1:fb672eb52bd6 5 *
nepes_ai 2:28290f9caf51 6 * Please use the NeuroShield library v1.1.4 or later
nepes_ai 0:123b50ed3ad9 7 ******************************************************************************/
nepes_ai 0:123b50ed3ad9 8
nepes_ai 0:123b50ed3ad9 9 #include "mbed.h"
nepes_ai 0:123b50ed3ad9 10 #include <NeuroShield.h>
nepes_ai 0:123b50ed3ad9 11 #include <NeuroShieldSPI.h>
nepes_ai 0:123b50ed3ad9 12 #include <mpu6050.h>
nepes_ai 0:123b50ed3ad9 13
nepes_ai 0:123b50ed3ad9 14 // for NM500
nepes_ai 0:123b50ed3ad9 15 #define MOTION_REPEAT_COUNT 3 // number of samples to assemble a vector
nepes_ai 0:123b50ed3ad9 16 #define MOTION_SIGNAL_COUNT 8 // d_ax, d_ay, d_az, d_gx, d_gy, d_gz, da, dg
nepes_ai 0:123b50ed3ad9 17 #define MOTION_CAPTURE_COUNT 20
nepes_ai 0:123b50ed3ad9 18
nepes_ai 0:123b50ed3ad9 19 #define DEFAULT_MAXIF 500
nepes_ai 0:123b50ed3ad9 20
nepes_ai 0:123b50ed3ad9 21 NeuroShield hnn;
nepes_ai 0:123b50ed3ad9 22 MPU6050 mpu(0x68, PB_9, PB_8); // SDA:(D14=PB_9) SCL(D15=PB_8) <= SB143/SB138 must close for I2C on A4/A5 and SB147/SB157 must open!!!
nepes_ai 0:123b50ed3ad9 23 Serial pc(USBTX, USBRX);
nepes_ai 0:123b50ed3ad9 24
nepes_ai 0:123b50ed3ad9 25 DigitalOut sdcard_ss(D6); // SDCARD_SSn
nepes_ai 0:123b50ed3ad9 26 DigitalOut arduino_con(D5); // SPI_SEL
nepes_ai 0:123b50ed3ad9 27
nepes_ai 0:123b50ed3ad9 28 int16_t ax, ay, az, gx, gy, gz;
nepes_ai 0:123b50ed3ad9 29
nepes_ai 0:123b50ed3ad9 30 uint8_t learn_cat = 0; // category to learn
nepes_ai 0:123b50ed3ad9 31 uint8_t prev_cat = 0; // previously recognized category
nepes_ai 0:123b50ed3ad9 32 uint16_t dist, cat, nid, nsr, ncount; // response from the neurons
nepes_ai 0:123b50ed3ad9 33 uint16_t prev_ncount = 0;
nepes_ai 1:fb672eb52bd6 34 uint16_t fpga_version;
nepes_ai 0:123b50ed3ad9 35
nepes_ai 0:123b50ed3ad9 36 int16_t min_a = 0xFFFF, max_a = 0, min_g = 0xFFFF, max_g = 0, da = 0, dg = 0; // reset, or not, at each feature extraction
nepes_ai 0:123b50ed3ad9 37
nepes_ai 0:123b50ed3ad9 38 uint8_t vector[MOTION_REPEAT_COUNT * MOTION_SIGNAL_COUNT]; // vector holding the pattern to learn or recognize
nepes_ai 0:123b50ed3ad9 39
nepes_ai 0:123b50ed3ad9 40 void mpu6050Calibration()
nepes_ai 0:123b50ed3ad9 41 {
nepes_ai 0:123b50ed3ad9 42 int i, j;
nepes_ai 0:123b50ed3ad9 43 long sum_ax = 0, sum_ay = 0, sum_az = 0, sum_gx = 0, sum_gy = 0, sum_gz = 0;
nepes_ai 0:123b50ed3ad9 44 int mean_ax, mean_ay, mean_az, mean_gx, mean_gy, mean_gz;
nepes_ai 0:123b50ed3ad9 45 int ax_offset, ay_offset, az_offset, gx_offset, gy_offset, gz_offset;
nepes_ai 0:123b50ed3ad9 46
nepes_ai 0:123b50ed3ad9 47 for (i = 0; i < 100; i++) {
nepes_ai 0:123b50ed3ad9 48 mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
nepes_ai 0:123b50ed3ad9 49 }
nepes_ai 0:123b50ed3ad9 50
nepes_ai 0:123b50ed3ad9 51 for (j = 0; j < 5; j++) {
nepes_ai 0:123b50ed3ad9 52 for (i = 0; i < 100; i++) {
nepes_ai 0:123b50ed3ad9 53 mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
nepes_ai 0:123b50ed3ad9 54 sum_ax += ax;
nepes_ai 0:123b50ed3ad9 55 sum_ay += ay;
nepes_ai 0:123b50ed3ad9 56 sum_az += az;
nepes_ai 0:123b50ed3ad9 57 sum_gx += gx;
nepes_ai 0:123b50ed3ad9 58 sum_gy += gy;
nepes_ai 0:123b50ed3ad9 59 sum_gz += gz;
nepes_ai 0:123b50ed3ad9 60 }
nepes_ai 0:123b50ed3ad9 61
nepes_ai 0:123b50ed3ad9 62 mean_ax = sum_ax / 100;
nepes_ai 0:123b50ed3ad9 63 mean_ay = sum_ay / 100;
nepes_ai 0:123b50ed3ad9 64 mean_az = sum_az / 100;
nepes_ai 0:123b50ed3ad9 65 mean_gx = sum_gx / 100;
nepes_ai 0:123b50ed3ad9 66 mean_gy = sum_gy / 100;
nepes_ai 0:123b50ed3ad9 67 mean_gz = sum_gz / 100;
nepes_ai 0:123b50ed3ad9 68
nepes_ai 0:123b50ed3ad9 69 // MPU6050_GYRO_FS_1000 : offset = (-1) * mean_g
nepes_ai 0:123b50ed3ad9 70 // MPU6050_ACCEL_FS_8 : offset = (-0.5) * mean_a
nepes_ai 0:123b50ed3ad9 71 ax_offset = (-mean_ax) / 2;
nepes_ai 0:123b50ed3ad9 72 ay_offset = (-mean_ay) / 2;
nepes_ai 0:123b50ed3ad9 73 az_offset = (-mean_az) / 2;
nepes_ai 0:123b50ed3ad9 74 gx_offset = -mean_gx;
nepes_ai 0:123b50ed3ad9 75 gy_offset = -mean_gy;
nepes_ai 0:123b50ed3ad9 76 gz_offset = -mean_gz;
nepes_ai 0:123b50ed3ad9 77
nepes_ai 0:123b50ed3ad9 78 // set
nepes_ai 0:123b50ed3ad9 79 mpu.setXAccelOffset(ax_offset);
nepes_ai 0:123b50ed3ad9 80 mpu.setYAccelOffset(ay_offset);
nepes_ai 0:123b50ed3ad9 81 mpu.setZAccelOffset(az_offset);
nepes_ai 0:123b50ed3ad9 82 mpu.setXGyroOffset(gx_offset);
nepes_ai 0:123b50ed3ad9 83 mpu.setYGyroOffset(gy_offset);
nepes_ai 0:123b50ed3ad9 84 mpu.setZGyroOffset(gz_offset);
nepes_ai 0:123b50ed3ad9 85 }
nepes_ai 0:123b50ed3ad9 86 }
nepes_ai 0:123b50ed3ad9 87
nepes_ai 0:123b50ed3ad9 88 void extractFeatureVector()
nepes_ai 0:123b50ed3ad9 89 {
nepes_ai 0:123b50ed3ad9 90 int i;
nepes_ai 0:123b50ed3ad9 91 int16_t min_ax, min_ay, min_az, max_ax, max_ay, max_az;
nepes_ai 0:123b50ed3ad9 92 int16_t min_gx, min_gy, min_gz, max_gx, max_gy, max_gz;
nepes_ai 0:123b50ed3ad9 93 uint32_t norm_ax, norm_ay, norm_az, norm_gx, norm_gy, norm_gz;
nepes_ai 0:123b50ed3ad9 94 int32_t d_ax, d_ay, d_az, d_gx, d_gy, d_gz;
nepes_ai 0:123b50ed3ad9 95 int32_t da_local, dg_local;
nepes_ai 0:123b50ed3ad9 96
nepes_ai 0:123b50ed3ad9 97 mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
nepes_ai 0:123b50ed3ad9 98
nepes_ai 0:123b50ed3ad9 99 max_ax = min_ax = ax;
nepes_ai 0:123b50ed3ad9 100 max_ay = min_ay = ay;
nepes_ai 0:123b50ed3ad9 101 max_az = min_az = az;
nepes_ai 0:123b50ed3ad9 102 max_gx = min_gx = gx;
nepes_ai 0:123b50ed3ad9 103 max_gy = min_gy = gy;
nepes_ai 0:123b50ed3ad9 104 max_gz = min_gz = gz;
nepes_ai 0:123b50ed3ad9 105
nepes_ai 0:123b50ed3ad9 106 for (i = 0; i < MOTION_CAPTURE_COUNT; i++) {
nepes_ai 0:123b50ed3ad9 107 mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
nepes_ai 0:123b50ed3ad9 108
nepes_ai 0:123b50ed3ad9 109 if (ax < min_ax)
nepes_ai 0:123b50ed3ad9 110 min_ax = ax;
nepes_ai 0:123b50ed3ad9 111 else if (ax > max_ax)
nepes_ai 0:123b50ed3ad9 112 max_ax = ax;
nepes_ai 0:123b50ed3ad9 113
nepes_ai 0:123b50ed3ad9 114 if (ay < min_ay)
nepes_ai 0:123b50ed3ad9 115 min_ay = ay;
nepes_ai 0:123b50ed3ad9 116 else if(ay > max_ay)
nepes_ai 0:123b50ed3ad9 117 max_ay = ay;
nepes_ai 0:123b50ed3ad9 118
nepes_ai 0:123b50ed3ad9 119 if (az < min_az)
nepes_ai 0:123b50ed3ad9 120 min_az = az;
nepes_ai 0:123b50ed3ad9 121 else if (az > max_az)
nepes_ai 0:123b50ed3ad9 122 max_az = az;
nepes_ai 0:123b50ed3ad9 123
nepes_ai 0:123b50ed3ad9 124 if (gx < min_gx)
nepes_ai 0:123b50ed3ad9 125 min_gx = gx;
nepes_ai 0:123b50ed3ad9 126 else if (gx > max_gx)
nepes_ai 0:123b50ed3ad9 127 max_gx = gx;
nepes_ai 0:123b50ed3ad9 128
nepes_ai 0:123b50ed3ad9 129 if (gy < min_gy)
nepes_ai 0:123b50ed3ad9 130 min_gy = gy;
nepes_ai 0:123b50ed3ad9 131 else if (gy > max_gy)
nepes_ai 0:123b50ed3ad9 132 max_gy = gy;
nepes_ai 0:123b50ed3ad9 133
nepes_ai 0:123b50ed3ad9 134 if (gz < min_gz)
nepes_ai 0:123b50ed3ad9 135 min_gz = gz;
nepes_ai 0:123b50ed3ad9 136 else if (gz > max_gz)
nepes_ai 0:123b50ed3ad9 137 max_gz = gz;
nepes_ai 0:123b50ed3ad9 138 }
nepes_ai 0:123b50ed3ad9 139
nepes_ai 0:123b50ed3ad9 140 d_ax = max_ax - min_ax;
nepes_ai 0:123b50ed3ad9 141 d_ay = max_ay - min_ay;
nepes_ai 0:123b50ed3ad9 142 d_az = max_az - min_az;
nepes_ai 0:123b50ed3ad9 143
nepes_ai 0:123b50ed3ad9 144 d_gx = max_gx - min_gx;
nepes_ai 0:123b50ed3ad9 145 d_gy = max_gy - min_gy;
nepes_ai 0:123b50ed3ad9 146 d_gz = max_gz - min_gz;
nepes_ai 0:123b50ed3ad9 147
nepes_ai 0:123b50ed3ad9 148 da_local = d_ax;
nepes_ai 0:123b50ed3ad9 149 if (d_ay > da_local)
nepes_ai 0:123b50ed3ad9 150 da_local = d_ay;
nepes_ai 0:123b50ed3ad9 151 if (d_az > da_local)
nepes_ai 0:123b50ed3ad9 152 da_local = d_az;
nepes_ai 0:123b50ed3ad9 153
nepes_ai 0:123b50ed3ad9 154 dg_local = d_gx;
nepes_ai 0:123b50ed3ad9 155 if (d_gy > dg_local)
nepes_ai 0:123b50ed3ad9 156 dg_local = d_gy;
nepes_ai 0:123b50ed3ad9 157 if (d_gz > dg_local)
nepes_ai 0:123b50ed3ad9 158 dg_local = d_gz;
nepes_ai 0:123b50ed3ad9 159
nepes_ai 0:123b50ed3ad9 160 norm_ax = d_ax; norm_ax = norm_ax * 255 / da_local;
nepes_ai 0:123b50ed3ad9 161 norm_ay = d_ay; norm_ay = norm_ay * 255 / da_local;
nepes_ai 0:123b50ed3ad9 162 norm_az = d_az; norm_az = norm_az * 255 / da_local;
nepes_ai 0:123b50ed3ad9 163
nepes_ai 0:123b50ed3ad9 164 norm_gx = d_gx; norm_gx = norm_gx * 255 / dg_local;
nepes_ai 0:123b50ed3ad9 165 norm_gy = d_gy; norm_gy = norm_gy * 255 / dg_local;
nepes_ai 0:123b50ed3ad9 166 norm_gz = d_gz; norm_gz = norm_gz * 255 / dg_local;
nepes_ai 0:123b50ed3ad9 167
nepes_ai 0:123b50ed3ad9 168 for (i = 0; i < MOTION_REPEAT_COUNT; i++) {
nepes_ai 0:123b50ed3ad9 169 vector[i * MOTION_SIGNAL_COUNT] = norm_ax & 0x00ff;
nepes_ai 0:123b50ed3ad9 170 vector[(i * MOTION_SIGNAL_COUNT) + 1] = norm_ay & 0x00ff;
nepes_ai 0:123b50ed3ad9 171 vector[(i * MOTION_SIGNAL_COUNT) + 2] = norm_az & 0x00ff;
nepes_ai 0:123b50ed3ad9 172 vector[(i * MOTION_SIGNAL_COUNT) + 3] = norm_gx & 0x00ff;
nepes_ai 0:123b50ed3ad9 173 vector[(i * MOTION_SIGNAL_COUNT) + 4] = norm_gy & 0x00ff;
nepes_ai 0:123b50ed3ad9 174 vector[(i * MOTION_SIGNAL_COUNT) + 5] = norm_gz & 0x00ff;
nepes_ai 0:123b50ed3ad9 175 if (da_local >= 4096)
nepes_ai 0:123b50ed3ad9 176 vector[(i * MOTION_SIGNAL_COUNT) + 6] = 0xff;
nepes_ai 0:123b50ed3ad9 177 else
nepes_ai 0:123b50ed3ad9 178 vector[(i * MOTION_SIGNAL_COUNT) + 6] = ((da_local >> 4) & 0x00ff);
nepes_ai 0:123b50ed3ad9 179 if (dg_local >= 4096)
nepes_ai 0:123b50ed3ad9 180 vector[(i * MOTION_SIGNAL_COUNT) + 7] = 0xff;
nepes_ai 0:123b50ed3ad9 181 else
nepes_ai 0:123b50ed3ad9 182 vector[(i * MOTION_SIGNAL_COUNT) + 7] = ((dg_local >> 4) & 0x00ff);
nepes_ai 0:123b50ed3ad9 183 }
nepes_ai 0:123b50ed3ad9 184 }
nepes_ai 0:123b50ed3ad9 185
nepes_ai 0:123b50ed3ad9 186 int main()
nepes_ai 0:123b50ed3ad9 187 {
nepes_ai 2:28290f9caf51 188 int input_key[2];
nepes_ai 0:123b50ed3ad9 189
nepes_ai 0:123b50ed3ad9 190 arduino_con = LOW;
nepes_ai 0:123b50ed3ad9 191 sdcard_ss = HIGH;
nepes_ai 0:123b50ed3ad9 192 wait(0.5);
nepes_ai 0:123b50ed3ad9 193
nepes_ai 0:123b50ed3ad9 194 if (hnn.begin() != 0) {
nepes_ai 1:fb672eb52bd6 195 fpga_version = hnn.fpgaVersion();
nepes_ai 1:fb672eb52bd6 196 if ((fpga_version & 0xFF00) == 0x0000) {
nepes_ai 1:fb672eb52bd6 197 printf("\n\n#### NeuroShield Board (Board v%d.0 / FPGA v%d.0) ####\n", ((fpga_version >> 4) & 0x000F), (fpga_version & 0x000F));
nepes_ai 1:fb672eb52bd6 198 }
nepes_ai 1:fb672eb52bd6 199 else if ((fpga_version & 0xFF00) == 0x0100) {
nepes_ai 1:fb672eb52bd6 200 printf("\n\n#### Prodigy Board (Board v%d.0 / FPGA v%d.0) ####\n", ((fpga_version >> 4) & 0x000F), (fpga_version & 0x000F));
nepes_ai 1:fb672eb52bd6 201 }
nepes_ai 1:fb672eb52bd6 202 else {
nepes_ai 1:fb672eb52bd6 203 printf("\n\n#### Unknown Board (Board v%d.0 / FPGA v%d.0) ####\n", ((fpga_version >> 4) & 0x000F), (fpga_version & 0x000F));
nepes_ai 1:fb672eb52bd6 204 }
nepes_ai 2:28290f9caf51 205 printf("\nStart NM500 initialzation...\n");
nepes_ai 2:28290f9caf51 206 printf(" NM500 is initialized!\n");
nepes_ai 2:28290f9caf51 207 printf(" There are %d neurons\n", hnn.total_neurons);
nepes_ai 0:123b50ed3ad9 208 }
nepes_ai 0:123b50ed3ad9 209 else {
nepes_ai 2:28290f9caf51 210 printf("\n\nStart NM500 initialzation...\n");
nepes_ai 2:28290f9caf51 211 printf(" NM500 is not connected properly!!\n");
nepes_ai 2:28290f9caf51 212 printf(" Please check the connection and reboot!\n");
nepes_ai 0:123b50ed3ad9 213 while (1);
nepes_ai 0:123b50ed3ad9 214 }
nepes_ai 0:123b50ed3ad9 215
nepes_ai 0:123b50ed3ad9 216 // initialize mpu6050
nepes_ai 0:123b50ed3ad9 217 printf("\nStart MPU-6050 initialization...\n");
nepes_ai 0:123b50ed3ad9 218 mpu.initialize();
nepes_ai 0:123b50ed3ad9 219 // set gyro & accel range
nepes_ai 0:123b50ed3ad9 220 mpu.setFullScaleGyroRange(MPU6050_GYRO_FS_1000);
nepes_ai 0:123b50ed3ad9 221 mpu.setFullScaleAccelRange(MPU6050_ACCEL_FS_8);
nepes_ai 0:123b50ed3ad9 222
nepes_ai 0:123b50ed3ad9 223 // verify connection
nepes_ai 2:28290f9caf51 224 for (int i = 0; i < 10; i++) {
nepes_ai 0:123b50ed3ad9 225 if (mpu.testConnection()) {
nepes_ai 2:28290f9caf51 226 printf(" MPU-6050 is connected successfully\n");
nepes_ai 0:123b50ed3ad9 227 break;
nepes_ai 0:123b50ed3ad9 228 }
nepes_ai 0:123b50ed3ad9 229 else if (i == 9) {
nepes_ai 0:123b50ed3ad9 230 printf(" MPU-6050 connection failed\n");
nepes_ai 2:28290f9caf51 231 printf(" Please check the connection and reboot!\n");
nepes_ai 0:123b50ed3ad9 232 while (1);
nepes_ai 0:123b50ed3ad9 233 }
nepes_ai 0:123b50ed3ad9 234 wait(0.1);
nepes_ai 0:123b50ed3ad9 235 }
nepes_ai 0:123b50ed3ad9 236
nepes_ai 0:123b50ed3ad9 237 // wait for ready
nepes_ai 2:28290f9caf51 238 printf(" Trying to calibrate. Make sure the board is stable and upright\n");
nepes_ai 0:123b50ed3ad9 239 // reset offsets
nepes_ai 0:123b50ed3ad9 240 mpu.setXAccelOffset(0);
nepes_ai 0:123b50ed3ad9 241 mpu.setYAccelOffset(0);
nepes_ai 0:123b50ed3ad9 242 mpu.setZAccelOffset(0);
nepes_ai 0:123b50ed3ad9 243 mpu.setXGyroOffset(0);
nepes_ai 0:123b50ed3ad9 244 mpu.setYGyroOffset(0);
nepes_ai 0:123b50ed3ad9 245 mpu.setZGyroOffset(0);
nepes_ai 0:123b50ed3ad9 246 mpu6050Calibration();
nepes_ai 0:123b50ed3ad9 247 // end message
nepes_ai 2:28290f9caf51 248 printf(" MPU-6050 calibration is complete!!\n\n");
nepes_ai 0:123b50ed3ad9 249
nepes_ai 2:28290f9caf51 250 printf("Move the board horizontally or vertically...\n");
nepes_ai 2:28290f9caf51 251 printf("Type '1' and enter, to learn up <-> down motion\n");
nepes_ai 2:28290f9caf51 252 printf("Type '2' and enter, to learn left <-> right motion\n");
nepes_ai 2:28290f9caf51 253 printf("Type '0' and enter, to learn by category 0\n");
nepes_ai 0:123b50ed3ad9 254
nepes_ai 0:123b50ed3ad9 255 // main loop
nepes_ai 0:123b50ed3ad9 256 while (1) {
nepes_ai 0:123b50ed3ad9 257 if (pc.readable()) {
nepes_ai 0:123b50ed3ad9 258 input_key[0] = input_key[1];
nepes_ai 0:123b50ed3ad9 259 input_key[1] = pc.getc();
nepes_ai 0:123b50ed3ad9 260 if (input_key[1] == 0x0D) { // enter key
nepes_ai 0:123b50ed3ad9 261 learn_cat = input_key[0] - '0';
nepes_ai 2:28290f9caf51 262 if (learn_cat < 3) {
nepes_ai 0:123b50ed3ad9 263 printf("Learning motion category %d\n", learn_cat);
nepes_ai 0:123b50ed3ad9 264 for (int i = 0; i < 5; i++) {
nepes_ai 0:123b50ed3ad9 265 extractFeatureVector();
nepes_ai 0:123b50ed3ad9 266 ncount = hnn.learn(vector, MOTION_REPEAT_COUNT * MOTION_SIGNAL_COUNT, learn_cat);
nepes_ai 0:123b50ed3ad9 267 if (ncount != prev_ncount) {
nepes_ai 0:123b50ed3ad9 268 prev_cat = learn_cat;
nepes_ai 0:123b50ed3ad9 269 prev_ncount = ncount;
nepes_ai 0:123b50ed3ad9 270 }
nepes_ai 0:123b50ed3ad9 271 }
nepes_ai 0:123b50ed3ad9 272 printf("Neurons=%d\n", ncount);
nepes_ai 0:123b50ed3ad9 273 }
nepes_ai 0:123b50ed3ad9 274 }
nepes_ai 0:123b50ed3ad9 275 }
nepes_ai 0:123b50ed3ad9 276 else { // recognize
nepes_ai 0:123b50ed3ad9 277 extractFeatureVector();
nepes_ai 0:123b50ed3ad9 278 hnn.classify(vector, MOTION_REPEAT_COUNT * MOTION_SIGNAL_COUNT, &dist, &cat, &nid);
nepes_ai 0:123b50ed3ad9 279 if (cat != 0xFFFF) {
nepes_ai 0:123b50ed3ad9 280 prev_cat = cat;
nepes_ai 0:123b50ed3ad9 281 if (cat & 0x8000)
nepes_ai 0:123b50ed3ad9 282 printf("Motion #%d (degenerated)\n", (cat & 0x7FFF));
nepes_ai 0:123b50ed3ad9 283 else
nepes_ai 0:123b50ed3ad9 284 printf("Motion #%d \n", cat);
nepes_ai 0:123b50ed3ad9 285 }
nepes_ai 0:123b50ed3ad9 286 else if (prev_cat != 0xFFFF) {
nepes_ai 0:123b50ed3ad9 287 prev_cat = cat;
nepes_ai 0:123b50ed3ad9 288 }
nepes_ai 0:123b50ed3ad9 289 }
nepes_ai 0:123b50ed3ad9 290 }
nepes_ai 0:123b50ed3ad9 291 }