begriffs open source - cmsis-driver-validation/blob

1 /*

3 *

4 * SPDX-License-Identifier: Apache-2.0

5 *

6 * Licensed under the Apache License, Version 2.0 (the License); you may

7 * not use this file except in compliance with the License.

8 * You may obtain a copy of the License at

9 *

10 * www.apache.org/licenses/LICENSE-2.0

11 *

12 * Unless required by applicable law or agreed to in writing, software

13 * distributed under the License is distributed on an AS IS BASIS, WITHOUT

14 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

15 * See the License for the specific language governing permissions and

16 * limitations under the License.

17 *

18 * -----------------------------------------------------------------------------

19 *

20 * Project: CMSIS-Driver Validation

21 * Title: Controller Area Network (CAN) Driver Validation tests

22 *

23 * -----------------------------------------------------------------------------

24 */

25

26

27 #include "cmsis_dv.h"

28 #include "DV_CAN_Config.h"

29 #include "DV_Framework.h"

30 #include "Driver_CAN.h"

31 #include <stdio.h>

32 #include <stdlib.h>

33 #include <string.h>

34

35 #define CAN_MSG_SIZE 8U // CAN data size bytes

36 #define CAN_MSG_SIZE_FD 64U // CAN FD data size bytes

37

38 // CAN frame format according to BOSCH "CAN with Flexible Data-Rate" Specification Version 1.0

39 // released April 17th 2012

40

41 // CAN extended frame format bits (without datafield)

42 // SOF BASEID SRR IDE IDEXT RTR r1 r0 DLC DATA CRC CRCDEL ACK EOF

43 #define CAN_EXT_FRAME_BITS ( 1 +11 +1 +1 +18 +1 +1 +1 +4 +21 +1 +2 +7 )

44

45 // CAN FD extended frame format bits sent at NOMINAL bitrate

46 // SOF BASEID SRR IDE IDEXT r1 EDL r0 BRS ESI DLC DATA CRC CRCDEL ACK EOF

47 #define CAN_EXT_FRAME_BITS_NOMINAL ( 1 +11 +1 +1 +18 +1 +1 +1 +1 +2 +7 )

48

49 // CAN FD extended frame format bits sent at FD_DATA bitrate (without datafield)

50 // SOF BASEID SRR IDE IDEXT r1 EDL r0 BRS ESI DLC DATA CRC CRCDEL ACK EOF

51 #define CAN_EXT_FRAME_BITS_FD_DATA ( +1 +4 +21 +1 )

52

53 // CAN buffer pointers

54 static uint8_t *buffer_out;

55 static uint8_t *buffer_in;

56

57 // CAN bitrates

58 const uint32_t CAN_BR[] = {

59 #if (CAN_BR_1>0)

60 CAN_BR_1,

61 #endif

62 #if (CAN_BR_2>0)

63 CAN_BR_2,

64 #endif

65 #if (CAN_BR_3>0)

66 CAN_BR_3,

67 #endif

68 #if (CAN_BR_4>0)

69 CAN_BR_4,

70 #endif

71 #if (CAN_BR_5>0)

72 CAN_BR_5,

73 #endif

74 #if (CAN_BR_6>0)

75 CAN_BR_6,

76 #endif

77 };

78 const uint32_t CAN_BR_NUM = ARRAY_SIZE(CAN_BR);

79

80 // Register Driver_CAN#

81 extern ARM_DRIVER_CAN CREATE_SYMBOL(Driver_CAN, DRV_CAN);

82 static ARM_DRIVER_CAN *drv = &CREATE_SYMBOL(Driver_CAN, DRV_CAN);

83 static ARM_CAN_CAPABILITIES capab;

84 static ARM_CAN_OBJ_CAPABILITIES obj_capab;

85

86 static char str[128];

87

88 // Event flags

89 static uint32_t volatile Event;

90

91 // Object index

92 uint32_t Obj_idx;

93

94 // CAN Signal Unit Event Callback

95 void CAN_SignalUnitEvent (uint32_t event) {

96

97 switch (event) {

98 case ARM_CAN_EVENT_UNIT_ACTIVE:

99 break;

100 case ARM_CAN_EVENT_UNIT_WARNING:

101 break;

102 case ARM_CAN_EVENT_UNIT_PASSIVE:

103 break;

104 case ARM_CAN_EVENT_UNIT_BUS_OFF:

105 break;

106 }

107 }

108

109 // CAN Signal Object Event Callback

110 void CAN_SignalObjectEvent (uint32_t obj_idx, uint32_t event) {

111 Obj_idx = obj_idx;

112 Event = event;

113 }

114

115 // CAN transfer

116 int8_t CAN_RunTransfer (uint32_t tx_obj_idx, ARM_CAN_MSG_INFO *tx_msg_info, const uint8_t *tx_data,

117 uint32_t rx_obj_idx, ARM_CAN_MSG_INFO *rx_msg_info, uint8_t *rx_data,

118 uint8_t size) {

119 uint32_t tick;

120

121 Event &= ~ARM_CAN_EVENT_RECEIVE;

122 drv->MessageSend(tx_obj_idx, tx_msg_info, tx_data, size);

123

124 tick = GET_SYSTICK();

125 do {

126 if ((Event & ARM_CAN_EVENT_RECEIVE)&&(Obj_idx == rx_obj_idx)) {

127 drv->MessageRead(rx_obj_idx, rx_msg_info, rx_data, size);

128 return 0;

129 }

130 }

131 while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(CAN_TRANSFER_TIMEOUT));

132 return -1;

133 }

134

135

136 /*-----------------------------------------------------------------------------

137 * Tests

138 *----------------------------------------------------------------------------*/

139

140 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/

141 /**

142 \defgroup dv_can CAN Validation

143 \brief CAN driver validation

144 \details

145 The CAN validation test checks the API interface compliance.

146

147 \defgroup can_tests Tests

148 \ingroup dv_can

149

150 @{

151 */

152

153 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/

154 /**

155 \brief Function: CAN_GetCapabilities

156 \details

157 The test function \b CAN_GetCapabilities verifies the function \b GetCapabilities.

158 */

159 void CAN_GetCapabilities (void) {

160 /* Get CAN capabilities */

161 capab = drv->GetCapabilities();

162 TEST_ASSERT(&capab != NULL);

163 /* Check number of available objects */

164 if (capab.num_objects < 2U) {

165 TEST_FAIL_MESSAGE("[FAILED] Driver has less than 2 objects available");

166 }

167 }

168

169 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/

170 /**

171 \brief Function: CAN_Initialization

172 \details

173 The test function \b CAN_Initialization verifies the CAN functions with the sequence:

174 - Initialize without callback

175 - Uninitialize

176 - Initialize with callback

177 - Uninitialize

178 */

179 void CAN_Initialization (void) {

180

181 /* Initialize without callback */

182 TEST_ASSERT(drv->Initialize(NULL, NULL) == ARM_DRIVER_OK);

183

184 /* Uninitialize */

185 TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);

186

187 /* Initialize with callback */

188 TEST_ASSERT(drv->Initialize(CAN_SignalUnitEvent, CAN_SignalObjectEvent) == ARM_DRIVER_OK);

189

190 /* Uninitialize */

191 TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);

192 }

193

194 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/

195 /**

196 \brief Function: CAN_CheckInvalidInit

197 \details

198 The test function \b CAN_CheckInvalidInit verifies the driver behaviour when receiving an invalid initialization sequence:

199 - Uninitialize

200 - PowerControl with Power off

201 - PowerControl with Power on

202 - Set Mode

203 - PowerControl with Power off

204 - Uninitialize

205 */

206 void CAN_CheckInvalidInit (void) {

207

208 /* Uninitialize */

209 TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);

210

211 /* Power off */

212 TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);

213

214 /* Try to power on */

215 TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) != ARM_DRIVER_OK);

216

217 /* Try to set mode */

218 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_INITIALIZATION) != ARM_DRIVER_OK);

219

220 /* Power off */

221 TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);

222

223 /* Uninitialize */

224 TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);

225 }

226

227 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/

228 /**

229 \brief Function: CAN_PowerControl

230 \details

231 The test function \b CAN_PowerControl verifies the \b PowerControl function with the sequence:

232 - Initialize

233 - Power on

234 - Power low

235 - Power off

236 - Uninitialize

237 */

238 void CAN_PowerControl (void) {

239 int32_t val;

240

241 /* Initialize with callback */

242 TEST_ASSERT(drv->Initialize(CAN_SignalUnitEvent, CAN_SignalObjectEvent) == ARM_DRIVER_OK);

243

244 /* Power on */

245 TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);

246

247 /* Power low */

248 val = drv->PowerControl (ARM_POWER_LOW);

249 if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Low power is not supported"); }

250 else { TEST_ASSERT(val == ARM_DRIVER_OK); }

251

252 /* Power off */

253 TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);

254

255 /* Uninitialize */

256 TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);

257 }

258

259 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/

260 /**

261 \brief Function: CAN_Loopback_CheckBitrate

262 \details

263 The test function \b CAN_Loopback_CheckBitrate verifies different bitrates with the sequence:

264 - Initialize

265 - Power on

266 - Change bitrate

267 - Transfer and measure transfer time

268 - Check received data against sent data

269 - Power off

270 - Uninitialize

271 */

272 void CAN_Loopback_CheckBitrate (void) {

273 int32_t val, i;

274 uint32_t bitrate, clock;

275

276 ARM_CAN_MSG_INFO tx_data_msg_info;

277 ARM_CAN_MSG_INFO rx_data_msg_info;

278 uint32_t tx_obj_idx = 0xFFFFFFFFU;

279 uint32_t rx_obj_idx = 0xFFFFFFFFU;

280

281 uint32_t ticks_measured;

282 uint32_t ticks_expected;

283 double rate;

284

285 /* Initialize with callback */

286 TEST_ASSERT(drv->Initialize(CAN_SignalUnitEvent, CAN_SignalObjectEvent) == ARM_DRIVER_OK);

287

288 /* Power on */

289 TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);

290

291 /* Check if loopback is available */

292 capab = drv->GetCapabilities();

293 if ((capab.external_loopback == 0U) && (capab.internal_loopback == 0U)) {

294 TEST_FAIL_MESSAGE("[FAILED] Driver does not support loopback mode");

295 } else {

296

297 /* Allocate buffer */

298 buffer_out = (uint8_t*) malloc(CAN_MSG_SIZE*sizeof(uint8_t));

299 TEST_ASSERT(buffer_out != NULL);

300 buffer_in = (uint8_t*) malloc(CAN_MSG_SIZE*sizeof(uint8_t));

301 TEST_ASSERT(buffer_in != NULL);

302

303 /* Find first available object for receive and transmit */

304 for (i = 0U; i < capab.num_objects; i++) {

305 obj_capab = drv->ObjectGetCapabilities (i);

306 if ((tx_obj_idx == 0xFFFFFFFFU) && (obj_capab.tx == 1U)) { tx_obj_idx = i; }

307 else if ((rx_obj_idx == 0xFFFFFFFFU) && (obj_capab.rx == 1U)) { rx_obj_idx = i; }

308 }

309

310 /* Set output buffer with all data = 0x55 to avoid CAN bit stuffing */

311 memset(buffer_out,0x55U,CAN_MSG_SIZE);

312

313 /* Get clock */

314 clock = drv->GetClock();

315

316 for (bitrate=0; bitrate<CAN_BR_NUM; bitrate++) {

317

318 /* Activate initialization mode */

319 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_INITIALIZATION) == ARM_DRIVER_OK);

320

321 val = ARM_DRIVER_ERROR;

322 if ((clock % (5U*(CAN_BR[bitrate]*1000U))) == 0U) { // If CAN base clock is divisible by 5 * nominal bitrate without remainder

323 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

324 CAN_BR[bitrate]*1000U, // Set nominal bitrate to configured constant value

325 ARM_CAN_BIT_PROP_SEG (2U) | // Set propagation segment to 2 time quanta

326 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 80% of bit time)

327 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 5 time quanta long)

328 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

329 }

330 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

331 if ((clock % (6U*(CAN_BR[bitrate]*1000U))) == 0U) { // If CAN base clock is divisible by 6 * nominal bitrate without remainder

332 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

333 CAN_BR[bitrate]*1000U, // Set nominal bitrate to configured constant value

334 ARM_CAN_BIT_PROP_SEG (3U) | // Set propagation segment to 3 time quanta

335 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 83.3% of bit time)

336 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 6 time quanta long)

337 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

338 }

339 }

340 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

341 if ((clock % (8U*(CAN_BR[bitrate]*1000U))) == 0U) { // If CAN base clock is divisible by 8 * nominal bitrate without remainder

342 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

343 CAN_BR[bitrate]*1000U, // Set nominal bitrate to configured constant value

344 ARM_CAN_BIT_PROP_SEG (5U) | // Set propagation segment to 5 time quanta

345 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 87.5% of bit time)

346 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 8 time quanta long)

347 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

348 }

349 }

350 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

351 if ((clock % (10U*(CAN_BR[bitrate]*1000U))) == 0U) { // If CAN base clock is divisible by 10 * nominal bitrate without remainder

352 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

353 CAN_BR[bitrate]*1000U, // Set nominal bitrate to configured constant value

354 ARM_CAN_BIT_PROP_SEG (6U) | // Set propagation segment to 6 time quanta

355 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 70% of bit time)

356 ARM_CAN_BIT_PHASE_SEG2(2U) | // Set phase segment 2 to 2 time quantum (total bit is 10 time quanta long)

357 ARM_CAN_BIT_SJW (2U)); // Resynchronization jump width is same as phase segment 2

358 }

359 }

360 if (val != ARM_DRIVER_OK) {

361 snprintf(str,sizeof(str),"[WARNING] Invalid bitrate: %dkbit/s, clock %dMHz", CAN_BR[bitrate], clock/1000000U);

362 TEST_MESSAGE(str);

363 } else TEST_PASS();

364

365 if (val == ARM_DRIVER_OK) {

366

367 if (capab.external_loopback == 1U) {

368 // Activate loopback external mode

369 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_LOOPBACK_EXTERNAL) == ARM_DRIVER_OK );

370 } else if (capab.internal_loopback == 1U) {

371 // Activate loopback internal mode

372 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_LOOPBACK_INTERNAL) == ARM_DRIVER_OK );

373 }

374

375 /* ObjectSetFilter add extended exact ID 0x15555555 */

376 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_ADD, ARM_CAN_EXTENDED_ID(0x15555555U), 0U) == ARM_DRIVER_OK );

377

378 /* ObjectConfigure for tx and rx objects */

379 TEST_ASSERT(drv->ObjectConfigure(tx_obj_idx, ARM_CAN_OBJ_TX) == ARM_DRIVER_OK );

380 TEST_ASSERT(drv->ObjectConfigure(rx_obj_idx, ARM_CAN_OBJ_RX) == ARM_DRIVER_OK );

381

382 /* Clear input buffer */

383 memset(buffer_in,0,CAN_MSG_SIZE);

384

385 memset(&tx_data_msg_info, 0U, sizeof(ARM_CAN_MSG_INFO));

386 tx_data_msg_info.id = ARM_CAN_EXTENDED_ID(0x15555555U);

387

388 /* Measure transfer time */

389 ticks_measured = GET_SYSTICK();

390 CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out, rx_obj_idx, &rx_data_msg_info, buffer_in, CAN_MSG_SIZE);

391 ticks_measured = GET_SYSTICK() - ticks_measured;

392 ticks_expected = SYSTICK_MICROSEC((((CAN_MSG_SIZE * 8U) + CAN_EXT_FRAME_BITS) * 1000) / CAN_BR[bitrate]);

393

394 rate = (double)ticks_measured/ticks_expected;

395

396 if ((rate>(1.0+(double)MIN_BITRATE/100))||(rate<(1.0-(double)MIN_BITRATE/100))) {

397 snprintf(str,sizeof(str),"[WARNING] At %dkbit/s: measured time is %f x expected time", CAN_BR[bitrate], rate);

398 TEST_MESSAGE(str);

399 } else TEST_PASS();

400

401 /* Check received data against sent data*/

402 if (memcmp(buffer_in, buffer_out, CAN_MSG_SIZE)!=0) {

403 snprintf(str,sizeof(str),"[FAILED] At %dkbit/s: fail to check block of %d bytes", CAN_BR[bitrate], CAN_MSG_SIZE);

404 TEST_FAIL_MESSAGE(str);

405 } else TEST_PASS();

406

407 /* ObjectSetFilter remove extended exact ID 0x15555555 */

408 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_REMOVE, ARM_CAN_EXTENDED_ID(0x15555555U), 0U) == ARM_DRIVER_OK );

409 }

410 }

411

412 /* Free buffer */

413 free(buffer_out);

414 free(buffer_in);

415 }

416

417 /* Power off and uninitialize*/

418 TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);

419 TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);

420 }

421

422 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/

423 /**

424 \brief Function: CAN_Loopback_CheckBitrateFD

425 \details

426 The test function \b CAN_Loopback_CheckBitrateFD verifies different bitrates with the sequence:

427 - Initialize

428 - Power on

429 - Change bitrate

430 - Transfer and measure transfer time

431 - Check received data against sent data

432 - Power off

433 - Uninitialize

434 */

435 void CAN_Loopback_CheckBitrateFD (void) {

436 int32_t val, i;

437 uint32_t bitrate, clock;

438

439 ARM_CAN_MSG_INFO tx_data_msg_info;

440 ARM_CAN_MSG_INFO rx_data_msg_info;

441 uint32_t tx_obj_idx = 0xFFFFFFFFU;

442 uint32_t rx_obj_idx = 0xFFFFFFFFU;

443

444 uint32_t ticks_measured;

445 uint32_t ticks_expected;

446 double rate;

447

448 /* Initialize with callback */

449 TEST_ASSERT(drv->Initialize(CAN_SignalUnitEvent, CAN_SignalObjectEvent) == ARM_DRIVER_OK);

450

451 /* Power on */

452 TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);

453

454 /* Test FD mode */

455 capab = drv->GetCapabilities();

456 if (capab.fd_mode == 0U) {

457 TEST_FAIL_MESSAGE("[FAILED] Driver does not support FD mode");

458 } else {

459

460 /* Check if loopback is available */

461 if ((capab.external_loopback == 0U) && (capab.internal_loopback == 0U)) {

462 TEST_FAIL_MESSAGE("[FAILED] Driver does not support loopback mode");

463 } else {

464

465 /* Allocate buffer */

466 buffer_out = (uint8_t*) malloc(CAN_MSG_SIZE_FD*sizeof(uint8_t));

467 TEST_ASSERT(buffer_out != NULL);

468 buffer_in = (uint8_t*) malloc(CAN_MSG_SIZE_FD*sizeof(uint8_t));

469 TEST_ASSERT(buffer_in != NULL);

470

471 /* Find first available object for receive and transmit */

472 for (i = 0U; i < capab.num_objects; i++) {

473 obj_capab = drv->ObjectGetCapabilities (i);

474 if ((tx_obj_idx == 0xFFFFFFFFU) && (obj_capab.tx == 1U)) { tx_obj_idx = i; }

475 else if ((rx_obj_idx == 0xFFFFFFFFU) && (obj_capab.rx == 1U)) { rx_obj_idx = i; }

476 }

477

478 /* Set output buffer with all data = 0x55 to avoid CAN bit stuffing */

479 memset(buffer_out,0x55U,CAN_MSG_SIZE_FD);

480

481 /* Get clock */

482 clock = drv->GetClock();

483

484 for (bitrate=0; bitrate<CAN_BR_NUM; bitrate++) {

485

486 /* Activate initialization mode */

487 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_INITIALIZATION) == ARM_DRIVER_OK);

488

489 val = ARM_DRIVER_ERROR;

490 if ((clock % (5U*(CAN_BR[bitrate]*1000U*CAN_DATA_ARB_RATIO))) == 0U) { // If CAN base clock is divisible by 5 * nominal bitrate without remainder

491 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

492 CAN_BR[bitrate]*1000U, // Set nominal bitrate to configured constant value

493 ARM_CAN_BIT_PROP_SEG (2U) | // Set propagation segment to 2 time quanta

494 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 80% of bit time)

495 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 5 time quanta long)

496 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

497 if (val == ARM_DRIVER_OK) val = drv->SetBitrate (ARM_CAN_BITRATE_FD_DATA, // Set FD data phase bitrate

498 CAN_BR[bitrate]*1000U*CAN_DATA_ARB_RATIO, // Set FD data phase bitrate to configured constant value

499 ARM_CAN_BIT_PROP_SEG (2U) | // Set propagation segment to 2 time quanta

500 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 80% of bit time)

501 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 5 time quanta long)

502 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

503 }

504 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

505 if ((clock % (6U*(CAN_BR[bitrate]*1000U*CAN_DATA_ARB_RATIO))) == 0U) { // If CAN base clock is divisible by 6 * nominal bitrate without remainder

506 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

507 CAN_BR[bitrate]*1000U, // Set nominal bitrate to configured constant value

508 ARM_CAN_BIT_PROP_SEG (3U) | // Set propagation segment to 3 time quanta

509 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 83.3% of bit time)

510 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 6 time quanta long)

511 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

512 if (val == ARM_DRIVER_OK) val = drv->SetBitrate (ARM_CAN_BITRATE_FD_DATA, // Set FD data phase bitrate

513 CAN_BR[bitrate]*1000U*CAN_DATA_ARB_RATIO, // Set FD data phase bitrate to configured constant value

514 ARM_CAN_BIT_PROP_SEG (3U) | // Set propagation segment to 3 time quanta

515 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 83.3% of bit time)

516 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 6 time quanta long)

517 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

518 }

519 }

520 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

521 if ((clock % (8U*(CAN_BR[bitrate]*1000U*CAN_DATA_ARB_RATIO))) == 0U) { // If CAN base clock is divisible by 8 * nominal bitrate without remainder

522 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

523 CAN_BR[bitrate]*1000U, // Set nominal bitrate to configured constant value

524 ARM_CAN_BIT_PROP_SEG (5U) | // Set propagation segment to 5 time quanta

525 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 87.5% of bit time)

526 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 8 time quanta long)

527 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

528 if (val == ARM_DRIVER_OK) val = drv->SetBitrate (ARM_CAN_BITRATE_FD_DATA, // Set FD data phase bitrate

529 CAN_BR[bitrate]*1000U*CAN_DATA_ARB_RATIO, // Set FD data phase bitrate to configured constant value

530 ARM_CAN_BIT_PROP_SEG (5U) | // Set propagation segment to 5 time quanta

531 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 87.5% of bit time)

532 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 8 time quanta long)

533 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

534 }

535 }

536 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

537 if ((clock % (10U*(CAN_BR[bitrate]*1000U*CAN_DATA_ARB_RATIO))) == 0U) {// If CAN base clock is divisible by 10 * nominal bitrate without remainder

538 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

539 CAN_BR[bitrate]*1000U, // Set nominal bitrate to configured constant value

540 ARM_CAN_BIT_PROP_SEG (6U) | // Set propagation segment to 6 time quanta

541 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 70% of bit time)

542 ARM_CAN_BIT_PHASE_SEG2(2U) | // Set phase segment 2 to 2 time quantum (total bit is 10 time quanta long)

543 ARM_CAN_BIT_SJW (2U)); // Resynchronization jump width is same as phase segment 2

544 if (val == ARM_DRIVER_OK) val = drv->SetBitrate (ARM_CAN_BITRATE_FD_DATA, // Set FD data phase bitrate

545 CAN_BR[bitrate]*1000U*CAN_DATA_ARB_RATIO, // Set FD data phase bitrate to configured constant value

546 ARM_CAN_BIT_PROP_SEG (6U) | // Set propagation segment to 6 time quanta

547 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 70% of bit time)

548 ARM_CAN_BIT_PHASE_SEG2(2U) | // Set phase segment 2 to 2 time quantum (total bit is 10 time quanta long)

549 ARM_CAN_BIT_SJW (2U)); // Resynchronization jump width is same as phase segment 2

550 }

551 }

552 if (val != ARM_DRIVER_OK) {

553 snprintf(str,sizeof(str),"[WARNING] Invalid FD bitrate: %dkbit/s, clock %dMHz", CAN_BR[bitrate]*CAN_DATA_ARB_RATIO, clock/1000000U);

554 TEST_MESSAGE(str);

555 } else TEST_PASS();

556

557 if (val == ARM_DRIVER_OK) {

558

559 if (capab.external_loopback == 1U) {

560 // Activate loopback external mode

561 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_LOOPBACK_EXTERNAL) == ARM_DRIVER_OK );

562 } else if (capab.internal_loopback == 1U) {

563 // Activate loopback internal mode

564 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_LOOPBACK_INTERNAL) == ARM_DRIVER_OK );

565 }

566

567 /* Set FD mode */

568 TEST_ASSERT(drv->Control (ARM_CAN_SET_FD_MODE, 1) == ARM_DRIVER_OK);

569

570 /* ObjectSetFilter add extended exact ID 0x15555555 */

571 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_ADD, ARM_CAN_EXTENDED_ID(0x15555555U), 0U) == ARM_DRIVER_OK );

572

573 /* ObjectConfigure for tx and rx objects */

574 TEST_ASSERT(drv->ObjectConfigure(tx_obj_idx, ARM_CAN_OBJ_TX) == ARM_DRIVER_OK );

575 TEST_ASSERT(drv->ObjectConfigure(rx_obj_idx, ARM_CAN_OBJ_RX) == ARM_DRIVER_OK );

576

577 /* Clear input buffer */

578 memset(buffer_in,0,CAN_MSG_SIZE_FD);

579

580 memset(&tx_data_msg_info, 0U, sizeof(ARM_CAN_MSG_INFO));

581 tx_data_msg_info.id = ARM_CAN_EXTENDED_ID(0x15555555U);

582

583 /* Measure transfer time */

584 ticks_measured = GET_SYSTICK();

585 CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out, rx_obj_idx, &rx_data_msg_info, buffer_in, CAN_MSG_SIZE_FD);

586 ticks_measured = GET_SYSTICK() - ticks_measured;

587 ticks_expected = SYSTICK_MICROSEC((((((CAN_MSG_SIZE_FD * 8U) + CAN_EXT_FRAME_BITS_FD_DATA) * 1000) / (CAN_BR[bitrate] * CAN_DATA_ARB_RATIO)) +

588 (((CAN_EXT_FRAME_BITS_NOMINAL) * 1000) / CAN_BR[bitrate] ) ));

589

590 rate = (double)ticks_measured/ticks_expected;

591

592 if ((rate>(1.0+(double)MIN_BITRATE/100))||(rate<(1.0-(double)MIN_BITRATE/100))) {

593 snprintf(str,sizeof(str),"[WARNING] At FD bitrate %dkbit/s: measured time is %f x expected time", CAN_BR[bitrate]*CAN_DATA_ARB_RATIO, rate);

594 TEST_MESSAGE(str);

595 } else TEST_PASS();

596

597 /* Check received data against sent data*/

598 if (memcmp(buffer_in, buffer_out, CAN_MSG_SIZE_FD)!=0) {

599 snprintf(str,sizeof(str),"[FAILED] At FD bitrate %dkbit/s: fail to check block of %d bytes", CAN_BR[bitrate]*CAN_DATA_ARB_RATIO, CAN_MSG_SIZE_FD);

600 TEST_FAIL_MESSAGE(str);

601 } else TEST_PASS();

602

603 /* ObjectSetFilter remove extended exact ID 0x15555555 */

604 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_REMOVE, ARM_CAN_EXTENDED_ID(0x15555555U), 0U) == ARM_DRIVER_OK );

605 }

606 }

607

608 /* Free buffer */

609 free(buffer_out);

610 free(buffer_in);

611 }

612 }

613

614 /* Power off and uninitialize*/

615 TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);

616 TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);

617 }

618

619 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/

620 /**

621 \brief Function: CAN_Loopback_Transfer

622 \details

623 The test function \b CAN_Loopback_Transfer verifies the data transfers with the sequence:

624 - Initialize

625 - Power on

626 - Set filter with standard ID

627 - Transfer and check received data against sent data

628 - Check filter with standard ID and remove it

629 - Set filter with extended ID

630 - Transfer and check received data against sent data

631 - Check filter with extended ID and remove it

632 - Power off

633 - Uninitialize

634 */

635 void CAN_Loopback_Transfer (void) {

636 int32_t val;

637 uint32_t i, cnt, clock;

638

639 ARM_CAN_MSG_INFO tx_data_msg_info;

640 ARM_CAN_MSG_INFO rx_data_msg_info;

641 uint32_t tx_obj_idx = 0xFFFFFFFFU;

642 uint32_t rx_obj_idx = 0xFFFFFFFFU;

643

644 /* Initialize with callback */

645 TEST_ASSERT(drv->Initialize(CAN_SignalUnitEvent, CAN_SignalObjectEvent) == ARM_DRIVER_OK);

646

647 /* Power on */

648 TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);

649

650 /* Check if loopback is available */

651 capab = drv->GetCapabilities();

652 if ((capab.external_loopback == 0U) && (capab.internal_loopback == 0U)) {

653 TEST_FAIL_MESSAGE("[FAILED] Driver does not support loopback mode");

654 } else {

655

656 /* Allocate buffer */

657 buffer_out = (uint8_t*) malloc(CAN_MSG_SIZE*sizeof(uint8_t));

658 TEST_ASSERT(buffer_out != NULL);

659 buffer_in = (uint8_t*) malloc(CAN_MSG_SIZE*sizeof(uint8_t));

660 TEST_ASSERT(buffer_in != NULL);

661

662 /* Find first available object for receive and transmit */

663 for (i = 0U; i < capab.num_objects; i++) {

664 obj_capab = drv->ObjectGetCapabilities (i);

665 if ((tx_obj_idx == 0xFFFFFFFFU) && (obj_capab.tx == 1U)) { tx_obj_idx = i; }

666 else if ((rx_obj_idx == 0xFFFFFFFFU) && (obj_capab.rx == 1U)) { rx_obj_idx = i; }

667 }

668

669 /* Set output buffer with random data */

670 srand(GET_SYSTICK());

671 for (cnt = 0; cnt<CAN_MSG_SIZE; cnt++) {

672 buffer_out[cnt] = rand()%0x100U;

673 }

674

675 /* Activate initialization mode */

676 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_INITIALIZATION) == ARM_DRIVER_OK);

677

678 if (capab.external_loopback != 0U) {

679 // Activate loopback external mode

680 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_LOOPBACK_EXTERNAL) == ARM_DRIVER_OK );

681 } else if (capab.internal_loopback == 1U) {

682 // Activate loopback internal mode

683 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_LOOPBACK_INTERNAL) == ARM_DRIVER_OK );

684 }

685

686 /* Get clock */

687 clock = drv->GetClock();

688

689 val = ARM_DRIVER_ERROR;

690 if ((clock % (5U*(CAN_BR[0]*1000U))) == 0U) { // If CAN base clock is divisible by 5 * nominal bitrate without remainder

691 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

692 CAN_BR[0]*1000U, // Set nominal bitrate to configured constant value

693 ARM_CAN_BIT_PROP_SEG (2U) | // Set propagation segment to 2 time quanta

694 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 80% of bit time)

695 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 5 time quanta long)

696 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

697 }

698 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

699 if ((clock % (6U*(CAN_BR[0]*1000U))) == 0U) { // If CAN base clock is divisible by 6 * nominal bitrate without remainder

700 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

701 CAN_BR[0]*1000U, // Set nominal bitrate to configured constant value

702 ARM_CAN_BIT_PROP_SEG (3U) | // Set propagation segment to 3 time quanta

703 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 83.3% of bit time)

704 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 6 time quanta long)

705 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

706 }

707 }

708 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

709 if ((clock % (8U*(CAN_BR[0]*1000U))) == 0U) { // If CAN base clock is divisible by 8 * nominal bitrate without remainder

710 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

711 CAN_BR[0]*1000U, // Set nominal bitrate to configured constant value

712 ARM_CAN_BIT_PROP_SEG (5U) | // Set propagation segment to 5 time quanta

713 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 87.5% of bit time)

714 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 8 time quanta long)

715 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

716 }

717 }

718 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

719 if ((clock % (10U*(CAN_BR[0]*1000U))) == 0U) { // If CAN base clock is divisible by 10 * nominal bitrate without remainder

720 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

721 CAN_BR[0]*1000U, // Set nominal bitrate to configured constant value

722 ARM_CAN_BIT_PROP_SEG (6U) | // Set propagation segment to 6 time quanta

723 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 70% of bit time)

724 ARM_CAN_BIT_PHASE_SEG2(2U) | // Set phase segment 2 to 2 time quantum (total bit is 10 time quanta long)

725 ARM_CAN_BIT_SJW (2U)); // Resynchronization jump width is same as phase segment 2

726 }

727 }

728 if (val != ARM_DRIVER_OK) {

729 snprintf(str,sizeof(str),"[WARNING] Invalid bitrate: %dkbit/s, clock %dMHz", CAN_BR[0], clock/1000000U);

730 TEST_MESSAGE(str);

731 } else TEST_PASS();

732

733 /* ObjectSetFilter add standard exact ID 0x7FF */

734 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_ADD, ARM_CAN_STANDARD_ID(0x7FFU), 0U) == ARM_DRIVER_OK );

735

736 /* ObjectConfigure for tx and rx objects */

737 TEST_ASSERT(drv->ObjectConfigure(tx_obj_idx, ARM_CAN_OBJ_TX) == ARM_DRIVER_OK );

738 TEST_ASSERT(drv->ObjectConfigure(rx_obj_idx, ARM_CAN_OBJ_RX) == ARM_DRIVER_OK );

739

740 memset(&tx_data_msg_info, 0U, sizeof(ARM_CAN_MSG_INFO));

741 tx_data_msg_info.id = ARM_CAN_STANDARD_ID(0x7FFU);

742

743 /* Transfer data chunks */

744 for (cnt = 1; cnt <= CAN_MSG_SIZE; cnt++) {

745 /* Clear input buffer */

746 memset(buffer_in,0,CAN_MSG_SIZE);

747 if (CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out, rx_obj_idx, &rx_data_msg_info, buffer_in, cnt) != ARM_DRIVER_OK) {

748 snprintf(str,sizeof(str),"[FAILED] Fail to transfer block of %d bytes",cnt);

749 TEST_FAIL_MESSAGE(str);

750 } else TEST_PASS();

751 if (memcmp(buffer_in, buffer_out, cnt)!=0) {

752 snprintf(str,sizeof(str),"[FAILED] Fail to check block of %d bytes",cnt);

753 TEST_FAIL_MESSAGE(str);

754 } else TEST_PASS();

755 }

756

757 /* Check if a different random ID is filtered */

758 tx_data_msg_info.id = ARM_CAN_STANDARD_ID(rand()%0x7FFU);

759 memset(buffer_in,0,CAN_MSG_SIZE);

760 TEST_ASSERT(CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out,

761 rx_obj_idx, &rx_data_msg_info, buffer_in,

762 CAN_MSG_SIZE) != ARM_DRIVER_OK);

763

764 /* ObjectSetFilter remove standard exact ID 0x7FF */

765 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_REMOVE, ARM_CAN_STANDARD_ID(0x7FFU), 0U) == ARM_DRIVER_OK );

766

767

768 /* ObjectSetFilter add extended exact ID 0x1FFFFFFF */

769 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_ADD, ARM_CAN_EXTENDED_ID(0x1FFFFFFFU), 0U) == ARM_DRIVER_OK );

770

771 /* ObjectConfigure for tx and rx objects */

772 TEST_ASSERT(drv->ObjectConfigure(tx_obj_idx, ARM_CAN_OBJ_TX) == ARM_DRIVER_OK );

773 TEST_ASSERT(drv->ObjectConfigure(rx_obj_idx, ARM_CAN_OBJ_RX) == ARM_DRIVER_OK );

774

775 memset(&tx_data_msg_info, 0U, sizeof(ARM_CAN_MSG_INFO));

776 tx_data_msg_info.id = ARM_CAN_EXTENDED_ID(0x1FFFFFFFU);

777

778 /* Transfer data chunks */

779 for (cnt = 1; cnt <= CAN_MSG_SIZE; cnt++) {

780 /* Clear input buffer */

781 memset(buffer_in,0,CAN_MSG_SIZE);

782 if (CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out, rx_obj_idx, &rx_data_msg_info, buffer_in, cnt) != ARM_DRIVER_OK) {

783 snprintf(str,sizeof(str),"[FAILED] Fail to transfer block of %d bytes",cnt);

784 TEST_FAIL_MESSAGE(str);

785 } else TEST_PASS();

786 if (memcmp(buffer_in, buffer_out, cnt)!=0) {

787 snprintf(str,sizeof(str),"[FAILED] Fail to check block of %d bytes",cnt);

788 TEST_FAIL_MESSAGE(str);

789 } else TEST_PASS();

790 }

791

792 /* Check if a different random ID is filtered */

793 tx_data_msg_info.id = ARM_CAN_EXTENDED_ID(rand()%0x1FFFFFFFU);

794 memset(buffer_in,0,CAN_MSG_SIZE);

795 TEST_ASSERT(CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out,

796 rx_obj_idx, &rx_data_msg_info, buffer_in,

797 CAN_MSG_SIZE) != ARM_DRIVER_OK);

798

799 /* ObjectSetFilter remove extended exact ID 0x1FFFFFFF */

800 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_REMOVE, ARM_CAN_EXTENDED_ID(0x1FFFFFFFU), 0U) == ARM_DRIVER_OK );

801

802 /* Free buffer */

803 free(buffer_out);

804 free(buffer_in);

805 }

806

807 /* Power off and uninitialize*/

808 TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);

809 TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);

810 }

811

812 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/

813 /**

814 \brief Function: CAN_Loopback_TransferFD

815 \details

816 The test function \b CAN_Loopback_TransferFD verifies the data transfers with the sequence:

817 - Initialize

818 - Power on

819 - Set filter with standard ID

820 - Transfer and check received data against sent data

821 - Check filter with standard ID and remove it

822 - Set filter with extended ID

823 - Transfer and check received data against sent data

824 - Check filter with extended ID and remove it

825 - Power off

826 - Uninitialize

827 */

828 void CAN_Loopback_TransferFD (void) {

829 int32_t val;

830 uint32_t i, cnt, clock;

831

832 ARM_CAN_MSG_INFO tx_data_msg_info;

833 ARM_CAN_MSG_INFO rx_data_msg_info;

834 uint32_t tx_obj_idx = 0xFFFFFFFFU;

835 uint32_t rx_obj_idx = 0xFFFFFFFFU;

836

837 /* Initialize with callback */

838 TEST_ASSERT(drv->Initialize(CAN_SignalUnitEvent, CAN_SignalObjectEvent) == ARM_DRIVER_OK);

839

840 /* Power on */

841 TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);

842

843 /* Test FD mode */

844 capab = drv->GetCapabilities();

845 if (capab.fd_mode == 0U) {

846 TEST_FAIL_MESSAGE("[FAILED] Driver does not support FD mode");

847 } else {

848

849 /* Check if loopback is available */

850 if ((capab.external_loopback == 0U) && (capab.internal_loopback == 0U)) {

851 TEST_FAIL_MESSAGE("[FAILED] Driver does not support loopback mode");

852 } else {

853

854 /* Allocate buffer */

855 buffer_out = (uint8_t*) malloc(CAN_MSG_SIZE_FD*sizeof(uint8_t));

856 TEST_ASSERT(buffer_out != NULL);

857 buffer_in = (uint8_t*) malloc(CAN_MSG_SIZE_FD*sizeof(uint8_t));

858 TEST_ASSERT(buffer_in != NULL);

859

860 /* Find first available object for receive and transmit */

861 for (i = 0U; i < capab.num_objects; i++) {

862 obj_capab = drv->ObjectGetCapabilities (i);

863 if ((tx_obj_idx == 0xFFFFFFFFU) && (obj_capab.tx == 1U)) { tx_obj_idx = i; }

864 else if ((rx_obj_idx == 0xFFFFFFFFU) && (obj_capab.rx == 1U)) { rx_obj_idx = i; }

865 }

866

867 /* Set output buffer with random data */

868 srand(GET_SYSTICK());

869 for (cnt = 0; cnt<CAN_MSG_SIZE_FD; cnt++) {

870 buffer_out[cnt] = rand()%0x100;

871 }

872

873 /* Activate initialization mode */

874 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_INITIALIZATION) == ARM_DRIVER_OK);

875

876 if (capab.external_loopback != 0U) {

877 // Activate loopback external mode

878 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_LOOPBACK_EXTERNAL) == ARM_DRIVER_OK );

879 } else if (capab.internal_loopback == 1U) {

880 // Activate loopback internal mode

881 TEST_ASSERT(drv->SetMode (ARM_CAN_MODE_LOOPBACK_INTERNAL) == ARM_DRIVER_OK );

882 }

883

884 /* Get clock */

885 clock = drv->GetClock();

886

887 val = ARM_DRIVER_ERROR;

888 if ((clock % (5U*(CAN_BR[0]*1000U*CAN_DATA_ARB_RATIO))) == 0U) { // If CAN base clock is divisible by 5 * nominal bitrate without remainder

889 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

890 CAN_BR[0]*1000U, // Set nominal bitrate to configured constant value

891 ARM_CAN_BIT_PROP_SEG (2U) | // Set propagation segment to 2 time quanta

892 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 80% of bit time)

893 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 5 time quanta long)

894 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

895 if (val == ARM_DRIVER_OK) val = drv->SetBitrate (ARM_CAN_BITRATE_FD_DATA, // Set FD data phase bitrate

896 CAN_BR[0]*1000U*CAN_DATA_ARB_RATIO, // Set FD data phase bitrate to configured constant value

897 ARM_CAN_BIT_PROP_SEG (2U) | // Set propagation segment to 2 time quanta

898 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 80% of bit time)

899 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 5 time quanta long)

900 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

901 }

902 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

903 if ((clock % (6U*(CAN_BR[0]*1000U*CAN_DATA_ARB_RATIO))) == 0U) { // If CAN base clock is divisible by 6 * nominal bitrate without remainder

904 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

905 CAN_BR[0]*1000U, // Set nominal bitrate to configured constant value

906 ARM_CAN_BIT_PROP_SEG (3U) | // Set propagation segment to 3 time quanta

907 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 83.3% of bit time)

908 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 6 time quanta long)

909 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

910 if (val == ARM_DRIVER_OK) val = drv->SetBitrate (ARM_CAN_BITRATE_FD_DATA, // Set FD data phase bitrate

911 CAN_BR[0]*1000U*CAN_DATA_ARB_RATIO, // Set FD data phase bitrate to configured constant value

912 ARM_CAN_BIT_PROP_SEG (3U) | // Set propagation segment to 3 time quanta

913 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 83.3% of bit time)

914 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 6 time quanta long)

915 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

916 }

917 }

918 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

919 if ((clock % (8U*(CAN_BR[0]*1000U*CAN_DATA_ARB_RATIO))) == 0U) { // If CAN base clock is divisible by 8 * nominal bitrate without remainder

920 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

921 CAN_BR[0]*1000U, // Set nominal bitrate to configured constant value

922 ARM_CAN_BIT_PROP_SEG (5U) | // Set propagation segment to 5 time quanta

923 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 87.5% of bit time)

924 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 8 time quanta long)

925 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

926 if (val == ARM_DRIVER_OK) val = drv->SetBitrate (ARM_CAN_BITRATE_FD_DATA, // Set FD data phase bitrate

927 CAN_BR[0]*1000U*CAN_DATA_ARB_RATIO, // Set FD data phase bitrate to configured constant value

928 ARM_CAN_BIT_PROP_SEG (5U) | // Set propagation segment to 5 time quanta

929 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 87.5% of bit time)

930 ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 8 time quanta long)

931 ARM_CAN_BIT_SJW (1U)); // Resynchronization jump width is same as phase segment 2

932 }

933 }

934 if (val != ARM_DRIVER_OK) { // If previous SetBitrate failed try different bit settings

935 if ((clock % (10U*(CAN_BR[0]*1000U*CAN_DATA_ARB_RATIO))) == 0U) { // If CAN base clock is divisible by 10 * nominal bitrate without remainder

936 val = drv->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

937 CAN_BR[0]*1000U, // Set nominal bitrate to configured constant value

938 ARM_CAN_BIT_PROP_SEG (6U) | // Set propagation segment to 6 time quanta

939 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 70% of bit time)

940 ARM_CAN_BIT_PHASE_SEG2(2U) | // Set phase segment 2 to 2 time quantum (total bit is 10 time quanta long)

941 ARM_CAN_BIT_SJW (2U)); // Resynchronization jump width is same as phase segment 2

942 if (val == ARM_DRIVER_OK) val = drv->SetBitrate (ARM_CAN_BITRATE_FD_DATA, // Set FD data phase bitrate

943 CAN_BR[0]*1000U*CAN_DATA_ARB_RATIO, // Set FD data phase bitrate to configured constant value

944 ARM_CAN_BIT_PROP_SEG (6U) | // Set propagation segment to 6 time quanta

945 ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 70% of bit time)

946 ARM_CAN_BIT_PHASE_SEG2(2U) | // Set phase segment 2 to 2 time quantum (total bit is 10 time quanta long)

947 ARM_CAN_BIT_SJW (2U)); // Resynchronization jump width is same as phase segment 2

948 }

949 }

950 if (val != ARM_DRIVER_OK) {

951 snprintf(str,sizeof(str),"[WARNING] Invalid FD bitrate: %dkbit/s, clock %dMHz", CAN_BR[0]*CAN_DATA_ARB_RATIO, clock/1000000U);

952 TEST_MESSAGE(str);

953 } else TEST_PASS();

954

955 /* Set FD mode */

956 TEST_ASSERT(drv->Control (ARM_CAN_SET_FD_MODE, 1) == ARM_DRIVER_OK);

957

958 /* ObjectSetFilter add standard exact ID 0x7FF */

959 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_ADD, ARM_CAN_STANDARD_ID(0x7FFU), 0U) == ARM_DRIVER_OK );

960

961 /* ObjectConfigure for tx and rx objects */

962 TEST_ASSERT(drv->ObjectConfigure(tx_obj_idx, ARM_CAN_OBJ_TX) == ARM_DRIVER_OK );

963 TEST_ASSERT(drv->ObjectConfigure(rx_obj_idx, ARM_CAN_OBJ_RX) == ARM_DRIVER_OK );

964

965 memset(&tx_data_msg_info, 0U, sizeof(ARM_CAN_MSG_INFO));

966 tx_data_msg_info.id = ARM_CAN_STANDARD_ID(0x7FFU);

967

968 /* Transfer data chunks */

969 for (cnt = 1; cnt <= CAN_MSG_SIZE_FD; cnt++) {

970 /* Clear input buffer */

971 memset(buffer_in,0,CAN_MSG_SIZE_FD);

972 if (CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out, rx_obj_idx, &rx_data_msg_info, buffer_in, cnt) != ARM_DRIVER_OK) {

973 snprintf(str,sizeof(str),"[FAILED] Fail to transfer block of %d bytes",cnt);

974 TEST_FAIL_MESSAGE(str);

975 } else TEST_PASS();

976 if (memcmp(buffer_in, buffer_out, cnt)!=0) {

977 snprintf(str,sizeof(str),"[FAILED] Fail to check block of %d bytes",cnt);

978 TEST_FAIL_MESSAGE(str);

979 } else TEST_PASS();

980 }

981

982 /* Check if a different random ID is filtered */

983 tx_data_msg_info.id = ARM_CAN_STANDARD_ID(rand()%0x7FFU);

984 memset(buffer_in,0,CAN_MSG_SIZE_FD);

985 TEST_ASSERT(CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out,

986 rx_obj_idx, &rx_data_msg_info, buffer_in,

987 CAN_MSG_SIZE_FD) != ARM_DRIVER_OK);

988

989 /* ObjectSetFilter remove standard exact ID 0x7FF */

990 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_REMOVE, ARM_CAN_STANDARD_ID(0x7FFU), 0U) == ARM_DRIVER_OK );

991

992

993 /* ObjectSetFilter add extended exact ID 0x1FFFFFFF */

994 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_ADD, ARM_CAN_EXTENDED_ID(0x1FFFFFFFU), 0U) == ARM_DRIVER_OK );

995

996 /* ObjectConfigure for tx and rx objects */

997 TEST_ASSERT(drv->ObjectConfigure(tx_obj_idx, ARM_CAN_OBJ_TX) == ARM_DRIVER_OK );

998 TEST_ASSERT(drv->ObjectConfigure(rx_obj_idx, ARM_CAN_OBJ_RX) == ARM_DRIVER_OK );

999

1000 memset(&tx_data_msg_info, 0U, sizeof(ARM_CAN_MSG_INFO));

1001 tx_data_msg_info.id = ARM_CAN_EXTENDED_ID(0x1FFFFFFFU);

1002

1003 /* Transfer data chunks */

1004 for (cnt = 1; cnt <= CAN_MSG_SIZE_FD; cnt++) {

1005 /* Clear input buffer */

1006 memset(buffer_in,0,CAN_MSG_SIZE_FD);

1007 if (CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out, rx_obj_idx, &rx_data_msg_info, buffer_in, cnt) != ARM_DRIVER_OK) {

1008 snprintf(str,sizeof(str),"[FAILED] Fail to transfer block of %d bytes",cnt);

1009 TEST_FAIL_MESSAGE(str);

1010 } else TEST_PASS();

1011 if (memcmp(buffer_in, buffer_out, cnt)!=0) {

1012 snprintf(str,sizeof(str),"[FAILED] Fail to check block of %d bytes",cnt);

1013 TEST_FAIL_MESSAGE(str);

1014 } else TEST_PASS();

1015 }

1016

1017 /* Check if a different random ID is filtered */

1018 tx_data_msg_info.id = ARM_CAN_EXTENDED_ID(rand()%0x1FFFFFFFU);

1019 memset(buffer_in,0,CAN_MSG_SIZE_FD);

1020 TEST_ASSERT(CAN_RunTransfer (tx_obj_idx, &tx_data_msg_info, buffer_out,

1021 rx_obj_idx, &rx_data_msg_info, buffer_in,

1022 CAN_MSG_SIZE_FD) != ARM_DRIVER_OK);

1023

1024 /* ObjectSetFilter remove extended exact ID 0x1FFFFFFF */

1025 TEST_ASSERT(drv->ObjectSetFilter(rx_obj_idx, ARM_CAN_FILTER_ID_EXACT_REMOVE, ARM_CAN_EXTENDED_ID(0x1FFFFFFFU), 0U) == ARM_DRIVER_OK );

1026

1027 /* Free buffer */

1028 free(buffer_out);

1029 free(buffer_in);

1030 }

1031 }

1032

1033 /* Power off and uninitialize*/

1034 TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);

1035 TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);

1036 }

1037

1038 /**

1039 @}

1040 */

1041 // end of group dv_can

1042