begriffs open source - cmsis-driver-validation/blob - Source/DV_USART.c

   1 /*-----------------------------------------------------------------------------
   2  *      Name:         DV_USART.c
   3  *      Purpose:      USART test cases
   4  *----------------------------------------------------------------------------
   5  *      Copyright(c) KEIL - An ARM Company
   6  *----------------------------------------------------------------------------*/
   7
   8 #include "cmsis_dv.h"
   9 #include "DV_Config.h"
  10 #include "DV_Framework.h"
  11 #include "Driver_USART.h"
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15
  16 // USART buffer type
  17 #if (USART_DATA_BITS>8U)
  18 typedef uint16_t buf_t;
  19 #else
  20 typedef uint8_t buf_t;
  21 #endif
  22
  23 // USART buffer pointers
  24 static buf_t *buffer_out;
  25 static buf_t *buffer_in;
  26
  27 // USART data bits
  28 #if   (USART_DATA_BITS==5U)
  29 #define USART_DATA_BITS_CTRL_CODE ARM_USART_DATA_BITS_5
  30 #elif (USART_DATA_BITS==6U)
  31 #define USART_DATA_BITS_CTRL_CODE ARM_USART_DATA_BITS_6
  32 #elif (USART_DATA_BITS==7U)
  33 #define USART_DATA_BITS_CTRL_CODE ARM_USART_DATA_BITS_7
  34 #elif (USART_DATA_BITS==8U)
  35 #define USART_DATA_BITS_CTRL_CODE ARM_USART_DATA_BITS_8
  36 #elif (USART_DATA_BITS==9U)
  37 #define USART_DATA_BITS_CTRL_CODE ARM_USART_DATA_BITS_9
  38 #endif
  39
  40 // USART baudrates
  41 static const uint32_t USART_BR[] = {
  42 #if (USART_BR_1>0)
  43   USART_BR_1,
  44 #endif
  45 #if (USART_BR_2>0)
  46   USART_BR_2,
  47 #endif
  48 #if (USART_BR_3>0)
  49   USART_BR_3,
  50 #endif
  51 #if (USART_BR_4>0)
  52   USART_BR_4,
  53 #endif
  54 #if (USART_BR_5>0)
  55   USART_BR_5,
  56 #endif
  57 #if (USART_BR_6>0)
  58   USART_BR_6,
  59 #endif
  60 };
  61 static const uint32_t USART_BR_NUM = ARRAY_SIZE(USART_BR);
  62
  63 // Register Driver_USART#
  64 extern ARM_DRIVER_USART CREATE_SYMBOL(Driver_USART, DRV_USART);
  65 static ARM_DRIVER_USART *drv = &CREATE_SYMBOL(Driver_USART, DRV_USART);
  66 static ARM_USART_CAPABILITIES capab;
  67
  68 static char str[128];
  69
  70 // Event flags
  71 static uint8_t volatile Event;
  72
  73 // USART event
  74 static void USART_DrvEvent (uint32_t event) {
  75   Event |= event;
  76 }
  77
  78 // USART asynchronous transfer
  79 int8_t USART_RunTransfer (void *out, void *in, uint32_t cnt);
  80 int8_t USART_RunTransfer (void *out, void *in, uint32_t cnt) {
  81   uint32_t tick;
  82
  83   Event &= ~ARM_USART_EVENT_RECEIVE_COMPLETE;
  84
  85   drv->Receive (in, cnt);
  86   drv->Send (out, cnt);
  87
  88   tick = GET_SYSTICK();
  89   do {
  90     if (Event & ARM_USART_EVENT_RECEIVE_COMPLETE) {
  91       return 0;
  92     }
  93   }
  94   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(USART_TRANSFER_TIMEOUT));
  95
  96   drv->Control(ARM_USART_ABORT_TRANSFER, 0);
  97   return -1;
  98 }
  99
 100 // USART send with callback
 101 int8_t USART_RunSend (void *out, uint32_t cnt);
 102 int8_t USART_RunSend (void *out, uint32_t cnt) {
 103   uint32_t tick;
 104
 105   Event &= ~ARM_USART_EVENT_SEND_COMPLETE;
 106
 107   drv->Send (out, cnt);
 108
 109   tick = GET_SYSTICK();
 110   do {
 111     if (Event & ARM_USART_EVENT_SEND_COMPLETE) {
 112       return 0;
 113     }
 114   }
 115   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(USART_TRANSFER_TIMEOUT));
 116
 117   drv->Control(ARM_USART_ABORT_SEND, 0);
 118   return -1;
 119 }
 120
 121 // USART send without callback
 122 int8_t USART_RunSend_NoCallback (void *out, uint32_t cnt);
 123 int8_t USART_RunSend_NoCallback (void *out, uint32_t cnt) {
 124   uint32_t tick;
 125
 126   drv->Send (out, cnt);
 127
 128   tick = GET_SYSTICK();
 129   do {
 130     if (drv->GetTxCount() == cnt) {
 131       return 0;
 132     }
 133   }
 134   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(USART_TRANSFER_TIMEOUT));
 135
 136   drv->Control(ARM_USART_ABORT_SEND, 0);
 137   return -1;
 138 }
 139
 140 // USART receive with callback
 141 int8_t USART_RunReceive (void *out, void *in, uint32_t cnt);
 142 int8_t USART_RunReceive (void *out, void *in, uint32_t cnt) {
 143   uint32_t tick;
 144
 145   Event &= ~ARM_USART_EVENT_RECEIVE_COMPLETE;
 146
 147   drv->Receive (in,  cnt);
 148   drv->Send    (out, cnt);              // Send data that will be received with loopback
 149
 150   tick = GET_SYSTICK();
 151   do {
 152     if (Event & ARM_USART_EVENT_RECEIVE_COMPLETE) {
 153       return 0;
 154     }
 155   }
 156   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(USART_TRANSFER_TIMEOUT));
 157
 158   drv->Control(ARM_USART_ABORT_RECEIVE, 0);
 159   return -1;
 160 }
 161
 162 // USART receive without callback
 163 int8_t USART_RunReceive_NoCallback (void *out, void *in, uint32_t cnt);
 164 int8_t USART_RunReceive_NoCallback (void *out, void *in, uint32_t cnt) {
 165   uint32_t tick;
 166
 167   drv->Receive (in,  cnt);
 168   drv->Send    (out, cnt);              // Send data that will be received with loopback
 169
 170   tick = GET_SYSTICK();
 171   do {
 172     if (drv->GetRxCount() == cnt) {
 173       return 0;
 174     }
 175   }
 176   while ((GET_SYSTICK() - tick) < SYSTICK_MICROSEC(USART_TRANSFER_TIMEOUT));
 177
 178   drv->Control(ARM_USART_ABORT_RECEIVE, 0);
 179   return -1;
 180 }
 181
 182
 183 /*-----------------------------------------------------------------------------
 184  *      Test cases
 185  *----------------------------------------------------------------------------*/
 186
 187
 188 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 189 /**
 190 \defgroup usart_funcs USART Validation
 191 \brief USART test cases
 192 \details
 193 The USART validation test performs the following checks:
 194 - API interface compliance.
 195 - Data communication with various transfer sizes and communication parameters.
 196 - Transfer speed of the data communication.
 197 - Loopback communication.
 198
 199 \anchor usart_loop_back_setup
 200 Loopback Communication Setup
 201 ----------------------------
 202
 203 To perform loopback communication tests, it is required to connect the USART's \b TX signal to the \b RX signal (refer to the
 204 schematics of your target hardware for detailed pinout information).
 205 @{
 206 */
 207
 208 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 209 /**
 210 \brief Test case: USART_GetCapabilities
 211 \details
 212 The test case \b USART_GetCapabilities verifies the function \b GetCapabilities.
 213 */
 214 void USART_GetCapabilities (void) {
 215   /* Get USART capabilities */
 216   capab = drv->GetCapabilities();
 217   TEST_ASSERT(&capab != NULL);
 218 }
 219
 220 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 221 /**
 222 \brief  Test case: USART_Initialization
 223 \details
 224 The test case \b USART_Initialization verifies the USART functions with the sequence:
 225   - \b Initialize without callback
 226   - \b Uninitialize
 227   - \b Initialize with callback
 228   - \b Uninitialize
 229 */
 230 void USART_Initialization (void) {
 231
 232   /* Initialize without callback */
 233   TEST_ASSERT(drv->Initialize(NULL) == ARM_DRIVER_OK);
 234
 235   /* Uninitialize */
 236   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 237
 238   /* Initialize with callback */
 239   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 240
 241   /* Uninitialize */
 242   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 243 }
 244
 245 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 246 /**
 247 \brief  Test case: USART_CheckInvalidInit
 248 \details
 249 The test case \b USART_CheckInvalidInit verifies the driver behaviour when receiving an invalid initialization sequence:
 250   - \b Uninitialize
 251   - \b PowerControl with Power off
 252   - \b PowerControl with Power on
 253   - \b Control
 254   - \b PowerControl with Power off
 255   - \b Uninitialize
 256 */
 257 void USART_CheckInvalidInit (void) {
 258
 259   /* Uninitialize */
 260   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 261
 262   /* Power off */
 263   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 264
 265   /* Try to power on */
 266   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) != ARM_DRIVER_OK);
 267
 268   /* Try to set configuration */
 269   TEST_ASSERT(drv->Control (ARM_USART_MODE_ASYNCHRONOUS | USART_DATA_BITS_CTRL_CODE | ARM_USART_PARITY_NONE |
 270     ARM_USART_STOP_BITS_1 | ARM_USART_FLOW_CONTROL_NONE, USART_BR[0]) != ARM_DRIVER_OK);
 271
 272   /* Power off */
 273   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 274
 275   /* Uninitialize */
 276   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 277 }
 278
 279 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 280 /**
 281 \brief  Test case: USART_PowerControl
 282 \details
 283 The test case \b USART_PowerControl verifies the \b PowerControl function with the sequence:
 284  - Initialize with callback
 285  - Power on
 286  - Power low
 287  - Power off
 288  - Uninitialize
 289 */
 290 void USART_PowerControl (void) {
 291   int32_t val;
 292
 293   /* Initialize with callback */
 294   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 295
 296   /* Power on */
 297   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 298
 299   /* Power low */
 300   val = drv->PowerControl (ARM_POWER_LOW);
 301   if (val == ARM_DRIVER_ERROR_UNSUPPORTED) { TEST_MESSAGE("[WARNING] Low power is not supported"); }
 302   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 303
 304   /* Power off */
 305   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 306
 307   /* Uninitialize */
 308   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 309 }
 310
 311 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 312 /**
 313 \brief  Test case: USART_Config_PolarityPhase
 314 \details
 315 The test case \b USART_Config_PolarityPhase verifies the \b Control function with the sequence:
 316  - Initialize with callback
 317  - Power on
 318  - Set basic SPI bus configuration
 319  - Change polarity
 320  - Change phase
 321  - Change polarity and phase
 322  - Power off
 323  - Uninitialize
 324 */
 325 void USART_Config_PolarityPhase (void) {
 326
 327   /* Initialize with callback and power on */
 328   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 329   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 330
 331   /* Set basic SPI bus configuration*/
 332   TEST_ASSERT(drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_CPOL0 | ARM_USART_CPHA0, USART_BR[0]) == ARM_DRIVER_OK);
 333
 334   /* Change polarity */
 335   TEST_ASSERT(drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_CPOL1 | ARM_USART_CPHA0, USART_BR[0]) == ARM_DRIVER_OK);
 336
 337   /* Change phase */
 338   TEST_ASSERT(drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_CPOL0 | ARM_USART_CPHA1, USART_BR[0]) == ARM_DRIVER_OK);
 339
 340   /* Change polarity and phase */
 341   TEST_ASSERT(drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_CPOL1 | ARM_USART_CPHA1, USART_BR[0]) == ARM_DRIVER_OK);
 342
 343   /* Power off and uninitialize */
 344   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 345   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 346 }
 347
 348 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 349 /**
 350 \brief  Test case: USART_Config_DataBits
 351 \details
 352 The test case \b USART_Config_DataBits verifies the \b Control function with the sequence:
 353  - Initialize with callback
 354  - Power on
 355  - Data bits = \token{5}
 356  - Data bits = \token{6}
 357  - Data bits = \token{7}
 358  - Data bits = \token{8}
 359  - Data bits = \token{9}
 360  - Power off
 361  - Uninitialize
 362 */
 363 void USART_Config_DataBits (void) {
 364   int32_t val;
 365
 366   /* Initialize with callback and power on */
 367   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 368   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 369
 370   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_5, USART_BR[0]);
 371   if (val == ARM_USART_ERROR_DATA_BITS) { TEST_MESSAGE("[WARNING] Data Bits = 5 are not supported"); }
 372   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 373
 374   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_6, USART_BR[0]);
 375   if (val == ARM_USART_ERROR_DATA_BITS) { TEST_MESSAGE("[WARNING] Data Bits = 6 are not supported"); }
 376   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 377
 378   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_7, USART_BR[0]);
 379   if (val == ARM_USART_ERROR_DATA_BITS) { TEST_MESSAGE("[WARNING] Data Bits = 7 are not supported"); }
 380   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 381
 382   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_8, USART_BR[0]);
 383   if (val == ARM_USART_ERROR_DATA_BITS) { TEST_MESSAGE("[WARNING] Data Bits = 8 are not supported"); }
 384   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 385
 386   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_DATA_BITS_9, USART_BR[0]);
 387   if (val == ARM_USART_ERROR_DATA_BITS) { TEST_MESSAGE("[WARNING] Data Bits = 9 are not supported"); }
 388   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 389
 390   /* Power off and uninitialize */
 391   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 392   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 393 }
 394
 395 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 396 /**
 397 \brief  Test case: USART_Config_StopBits
 398 \details
 399 The test case \b USART_Config_StopBits verifies the \b Control function with the sequence:
 400  - Initialize with callback
 401  - Power on
 402  - Stop bits = \token{1}
 403  - Stop bits = \token{2}
 404  - Stop bits = \token{1.5}
 405  - Stop bits = \token{0.5}
 406  - Power off
 407  - Uninitialize
 408 */
 409 void USART_Config_StopBits (void) {
 410   int32_t val;
 411
 412   /* Initialize with callback and power on */
 413   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 414   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 415
 416   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_STOP_BITS_1, USART_BR[0]);
 417   if (val == ARM_USART_ERROR_STOP_BITS) { TEST_MESSAGE("[WARNING] Stop Bits = 1 are not supported"); }
 418   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 419
 420   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_STOP_BITS_2, USART_BR[0]);
 421   if (val == ARM_USART_ERROR_STOP_BITS) { TEST_MESSAGE("[WARNING] Stop Bits = 2 are not supported"); }
 422   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 423
 424   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_STOP_BITS_1_5, USART_BR[0]);
 425   if (val == ARM_USART_ERROR_STOP_BITS) { TEST_MESSAGE("[WARNING] Stop Bits = 1.5 are not supported"); }
 426   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 427
 428   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_STOP_BITS_0_5, USART_BR[0]);
 429   if (val == ARM_USART_ERROR_STOP_BITS) { TEST_MESSAGE("[WARNING] Stop Bits = 0.5 are not supported"); }
 430   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 431
 432   /* Power off and uninitialize */
 433   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 434   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 435 }
 436
 437 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 438 /**
 439 \brief  Test case: USART_Config_Parity
 440 \details
 441 The test case \b USART_Config_Parity verifies the \b Control function with the sequence:
 442  - Initialize with callback
 443  - Power on
 444  - Sets parity bits: even parity
 445  - Sets parity bits: no parity
 446  - Sets parity bits: odd parity
 447  - Power off
 448  - Uninitialize
 449 */
 450 void USART_Config_Parity (void) {
 451   int32_t val;
 452
 453   /* Initialize with callback and power on */
 454   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 455   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 456
 457   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_PARITY_EVEN, USART_BR[0]);
 458   if (val == ARM_USART_ERROR_PARITY) { TEST_MESSAGE("[WARNING] Even parity is not supported"); }
 459   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 460
 461   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_PARITY_NONE, USART_BR[0]);
 462   if (val == ARM_USART_ERROR_PARITY) { TEST_MESSAGE("[WARNING] No parity is not supported"); }
 463   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 464
 465   val = drv->Control(ARM_USART_MODE_ASYNCHRONOUS | ARM_USART_PARITY_ODD, USART_BR[0]);
 466   if (val == ARM_USART_ERROR_PARITY) { TEST_MESSAGE("[WARNING] Odd parity not supported"); }
 467   else { TEST_ASSERT(val == ARM_DRIVER_OK); }
 468
 469   /* Power off and uninitialize */
 470   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 471   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 472 }
 473
 474 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 475 /**
 476 \brief  Test case: USART_Config_Baudrate
 477 \details
 478 The test case \b USART_Config_Baudrate verifies the \b Control function and configures various baudrates with the sequence:
 479  - Initialize with callback
 480  - Power on
 481  - Change bus speed
 482  - Power off
 483  - Uninitialize
 484
 485 \note This test needs to pass to be able to transfer data via the USART correctly. Usually, USART communication is set to a
 486 certain baudrate with a defined tolerance. If the driver is not able to set the baudrate correctly, data exchange will not be
 487 possible.
 488 */
 489 void USART_Config_Baudrate (void) {
 490   uint32_t speed;
 491
 492   /* Initialize with callback and power on */
 493   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 494   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 495
 496   /* Change baud rate*/
 497   for (speed=0; speed<USART_BR_NUM; speed++) {
 498
 499     TEST_ASSERT (drv->Control(ARM_USART_MODE_ASYNCHRONOUS, USART_BR[speed])
 500        == ARM_DRIVER_OK);
 501   }
 502
 503   /* Power off and uninitialize */
 504   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 505   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 506 }
 507
 508 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 509 /**
 510 \brief  Test case: USART_Loopback_CheckBaudrate
 511 \details
 512 The test case \b USART_Loopback_CheckBaudrate verifies the \b Control function, configures various baudrates, and measures
 513 the transfer time with this sequence:
 514
 515  - Initialize with callback
 516  - Power on
 517  - Change baud rate with specific control parameter
 518  - Measure transfer time
 519  - Power off
 520  - Uninitialize
 521
 522  \note If this test issues errors or warnings, refer to the \ref test_results section for more information.
 523 */
 524 void USART_Loopback_CheckBaudrate (void) {
 525   uint16_t cnt;
 526   uint32_t speed;
 527   uint32_t ticks_measured;
 528   uint32_t ticks_expected;
 529   double rate;
 530
 531   /* Allocate buffer */
 532   buffer_out = malloc(BUFFER_SIZE_BR*sizeof(buf_t));
 533   TEST_ASSERT(buffer_out != NULL);
 534   buffer_in = malloc(BUFFER_SIZE_BR*sizeof(buf_t));
 535   TEST_ASSERT(buffer_in != NULL);
 536
 537   /* Initialize with callback, power on and configure USART bus */
 538   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 539   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 540   TEST_ASSERT(drv->Control (ARM_USART_MODE_ASYNCHRONOUS | USART_DATA_BITS_CTRL_CODE | ARM_USART_PARITY_NONE |
 541     ARM_USART_STOP_BITS_1 | ARM_USART_FLOW_CONTROL_NONE, USART_BR[0]) == ARM_DRIVER_OK);
 542
 543   /* Test baudrates */
 544   for (speed=0; speed<USART_BR_NUM; speed++) {
 545
 546     /* Set output buffer with random data*/
 547     srand(GET_SYSTICK());
 548     for (cnt = 0; cnt<BUFFER_SIZE_BR; cnt++) {
 549       buffer_out[cnt] = (buf_t)rand()&((1U<<USART_DATA_BITS)-1U);
 550     }
 551
 552     /* Change baud rate*/
 553     TEST_ASSERT(drv->Control (ARM_USART_CONTROL_TX,0) == ARM_DRIVER_OK);
 554     TEST_ASSERT(drv->Control (ARM_USART_CONTROL_RX,0) == ARM_DRIVER_OK);
 555     TEST_ASSERT(drv->Control(ARM_USART_MODE_ASYNCHRONOUS, USART_BR[speed])
 556        == ARM_DRIVER_OK);
 557     TEST_ASSERT(drv->Control (ARM_USART_CONTROL_TX,1) == ARM_DRIVER_OK);
 558     TEST_ASSERT(drv->Control (ARM_USART_CONTROL_RX,1) == ARM_DRIVER_OK);
 559
 560     /* Set Local Loopback */
 561     USART_LOCAL_LOOPBACK();
 562
 563     /* Measure transfer time */
 564     ticks_measured = GET_SYSTICK();
 565     USART_RunTransfer(buffer_out, buffer_in, BUFFER_SIZE_BR);
 566     ticks_measured = GET_SYSTICK() - ticks_measured;
 567     ticks_expected = SYSTICK_MICROSEC(BUFFER_SIZE_BR*10000/(USART_BR[speed]/100));
 568     ticks_expected *= USART_DATA_BITS+2;
 569
 570     rate = (double)ticks_measured/ticks_expected;
 571
 572     if ((rate>(1.0+(double)TOLERANCE_BR/100))||(rate<(1.0-(double)TOLERANCE_BR/100))) {
 573       snprintf(str,sizeof(str),"[WARNING] At %dbps: measured time is %f x expected time", USART_BR[speed], rate);
 574       TEST_MESSAGE(str);
 575     } else TEST_PASS();
 576
 577     /* Check received data against sent data */
 578     if (memcmp(buffer_in, buffer_out, BUFFER_SIZE_BR)!=0) {
 579       snprintf(str,sizeof(str),"[FAILED] At %dbps: fail to check block of %d bytes", USART_BR[speed], BUFFER_SIZE_BR);
 580       TEST_FAIL_MESSAGE(str);
 581     } else TEST_PASS();
 582   }
 583
 584   /* Power off and uninitialize */
 585   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 586   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 587
 588   /* Free buffer */
 589   free(buffer_out);
 590   free(buffer_in);
 591 }
 592
 593 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 594 /**
 595 \brief  Test case: USART_Config_CommonParams
 596 \details
 597 The test case \b USART_Config_CommonParams verifies the \b Control function with the sequence:
 598  - Initialize with callback
 599  - Power on
 600  - Configure USART bus
 601  - Set transmitter
 602  - Set receiver
 603  - Power off
 604  - Uninitialize
 605 */
 606 void USART_Config_CommonParams (void) {
 607
 608   /* Initialize with callback and power on */
 609   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 610   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 611
 612   /* Configure USART bus*/
 613   TEST_ASSERT(drv->Control (ARM_USART_MODE_ASYNCHRONOUS | USART_DATA_BITS_CTRL_CODE | ARM_USART_PARITY_NONE |
 614     ARM_USART_STOP_BITS_1 | ARM_USART_FLOW_CONTROL_NONE, USART_BR[0]) == ARM_DRIVER_OK);
 615   TEST_ASSERT(drv->Control (ARM_USART_CONTROL_TX,1) == ARM_DRIVER_OK);
 616   TEST_ASSERT(drv->Control (ARM_USART_CONTROL_RX,1) == ARM_DRIVER_OK);
 617
 618   /* Power off and uninitialize */
 619   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 620   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 621 }
 622
 623 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 624 /**
 625 \brief  Test case: USART_Send
 626 \details
 627 The test case \b USART_Send verifies the \b Send function with the sequence:
 628  - Initialize with callback
 629  - Power on
 630  - Send data using callback
 631  - Send data without callback
 632  - Power off
 633  - Uninitialize
 634 */
 635 void USART_Send (void) {
 636   uint16_t cnt;
 637
 638   /* Allocate buffer */
 639   buffer_out = malloc(BUFFER[BUFFER_NUM-1]*sizeof(buf_t));
 640   TEST_ASSERT(buffer_out != NULL);
 641
 642   /* Initialize with callback, power on and configure USART bus */
 643   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 644   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 645   TEST_ASSERT(drv->Control (ARM_USART_MODE_ASYNCHRONOUS | USART_DATA_BITS_CTRL_CODE | ARM_USART_PARITY_NONE |
 646     ARM_USART_STOP_BITS_1 | ARM_USART_FLOW_CONTROL_NONE, USART_BR[0]) == ARM_DRIVER_OK);
 647   TEST_ASSERT(drv->Control (ARM_USART_CONTROL_TX,1) == ARM_DRIVER_OK);
 648   TEST_ASSERT(drv->Control (ARM_USART_CONTROL_RX,1) == ARM_DRIVER_OK);
 649
 650   /* Send data chunks */
 651   for (cnt = 0; cnt<BUFFER_NUM; cnt++) {
 652
 653     /* Send using callback */
 654     if (USART_RunSend(buffer_out, BUFFER[cnt]) != ARM_DRIVER_OK) {
 655       snprintf(str,sizeof(str),"[FAILED] Fail to send %d bytes",BUFFER[cnt]);
 656       TEST_FAIL_MESSAGE(str);
 657     } else TEST_PASS();
 658
 659     /* Send without callback */
 660     if (USART_RunSend_NoCallback(buffer_out, BUFFER[cnt]) != ARM_DRIVER_OK) {
 661       snprintf(str,sizeof(str),"[FAILED] Fail to send without callback %d bytes",BUFFER[cnt]);
 662       TEST_FAIL_MESSAGE(str);
 663     } else TEST_PASS();
 664   }
 665
 666   /* Power off and uninitialize */
 667   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 668   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 669
 670   /* Free buffer */
 671   free(buffer_out);
 672 }
 673
 674 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 675 /**
 676 \brief  Test case: USART_AsynchronousReceive
 677 \details
 678 The test case \b USART_AsynchronousReceive verifies the \b Receive function with the sequence:
 679  - Initialize with callback
 680  - Power on
 681  - Send data using callback
 682  - Send data without callback
 683  - Power off
 684  - Uninitialize
 685 */
 686 void USART_AsynchronousReceive (void) {
 687   uint16_t cnt;
 688
 689   /* Allocate buffer */
 690   buffer_in  = malloc(BUFFER[BUFFER_NUM-1]*sizeof(buf_t));
 691   buffer_out = malloc(BUFFER[BUFFER_NUM-1]*sizeof(buf_t));
 692   TEST_ASSERT(buffer_in  != NULL);
 693   TEST_ASSERT(buffer_out != NULL);
 694
 695   /* Initialize with callback, power on and configure USART bus */
 696   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 697   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 698   TEST_ASSERT(drv->Control (ARM_USART_MODE_ASYNCHRONOUS | USART_DATA_BITS_CTRL_CODE | ARM_USART_PARITY_NONE |
 699     ARM_USART_STOP_BITS_1 | ARM_USART_FLOW_CONTROL_NONE, USART_BR[0]) == ARM_DRIVER_OK);
 700   TEST_ASSERT(drv->Control (ARM_USART_CONTROL_TX,1) == ARM_DRIVER_OK);
 701   TEST_ASSERT(drv->Control (ARM_USART_CONTROL_RX,1) == ARM_DRIVER_OK);
 702
 703   /* Receive data chunks */
 704   for (cnt = 0; cnt<BUFFER_NUM; cnt++) {
 705
 706     /* Receive using callback */
 707     if (USART_RunReceive(buffer_out, buffer_in, BUFFER[cnt]) != ARM_DRIVER_OK) {
 708       snprintf(str,sizeof(str),"[FAILED] Fail to receive %d bytes",BUFFER[cnt]);
 709       TEST_FAIL_MESSAGE(str);
 710     } else TEST_PASS();
 711
 712     /* Receive without callback */
 713     if (USART_RunReceive_NoCallback(buffer_out, buffer_in, BUFFER[cnt]) != ARM_DRIVER_OK) {
 714       snprintf(str,sizeof(str),"[FAILED] Fail to send without callback %d bytes",BUFFER[cnt]);
 715       TEST_FAIL_MESSAGE(str);
 716     } else TEST_PASS();
 717   }
 718
 719   /* Power off and uninitialize */
 720   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 721   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 722
 723   /* Free buffer */
 724   free(buffer_in);
 725 }
 726
 727 /*=======0=========1=========2=========3=========4=========5=========6=========7=========8=========9=========0=========1====*/
 728 /**
 729 \brief  Test case: USART_Loopback_Transfer
 730 \details
 731 The test case \b USART_Loopback_Transfer verifies the \b Transfer function with the sequence:
 732  - Initialize with callback
 733  - Power on
 734  - Clear input buffer
 735  - Transfer data
 736  - Check received data against sent data
 737  - Power off
 738  - Uninitialize
 739 */
 740 void USART_Loopback_Transfer (void) {
 741   uint16_t cnt, i;
 742   uint8_t pattern[] = BUFFER_PATTERN;
 743
 744   /* Allocate buffer */
 745   buffer_out = malloc(BUFFER[BUFFER_NUM-1]*sizeof(buf_t));
 746   TEST_ASSERT(buffer_out != NULL);
 747   buffer_in = malloc(BUFFER[BUFFER_NUM-1]*sizeof(buf_t));
 748   TEST_ASSERT(buffer_in != NULL);
 749
 750   /* Initialize with callback, power on and configure USART bus */
 751   TEST_ASSERT(drv->Initialize(USART_DrvEvent) == ARM_DRIVER_OK);
 752   TEST_ASSERT(drv->PowerControl (ARM_POWER_FULL) == ARM_DRIVER_OK);
 753   TEST_ASSERT(drv->Control (ARM_USART_MODE_ASYNCHRONOUS | USART_DATA_BITS_CTRL_CODE | ARM_USART_PARITY_NONE |
 754     ARM_USART_STOP_BITS_1 | ARM_USART_FLOW_CONTROL_NONE, USART_BR[0]) == ARM_DRIVER_OK);
 755   TEST_ASSERT(drv->Control (ARM_USART_CONTROL_TX,1) == ARM_DRIVER_OK);
 756   TEST_ASSERT(drv->Control (ARM_USART_CONTROL_RX,1) == ARM_DRIVER_OK);
 757
 758   /* Set Local Loopback */
 759   USART_LOCAL_LOOPBACK();
 760
 761   /* Set output buffer pattern*/
 762   for (cnt = 0; cnt<BUFFER[BUFFER_NUM-1];) {
 763     for (i = 0; i<ARRAY_SIZE(pattern);) {
 764       buffer_out[cnt] = pattern[i++];
 765       if (USART_DATA_BITS>8U) buffer_out[cnt] |= pattern[i++]<<8U;
 766       buffer_out[cnt++] &= (1U<<USART_DATA_BITS)-1U;
 767     }
 768   }
 769
 770   /* Transfer data chunks */
 771   for (cnt = 0; cnt<BUFFER_NUM; cnt++) {
 772     /* Clear input buffer*/
 773     memset(buffer_in,0,BUFFER[cnt]);
 774     if (USART_RunTransfer(buffer_out, buffer_in, BUFFER[cnt]) != ARM_DRIVER_OK) {
 775       snprintf(str,sizeof(str),"[FAILED] Fail to transfer block of %d bytes",BUFFER[cnt]);
 776       TEST_FAIL_MESSAGE(str);
 777     } else TEST_PASS();
 778     if (memcmp(buffer_in, buffer_out, BUFFER[cnt])!=0) {
 779       snprintf(str,sizeof(str),"[FAILED] Fail to check block of %d bytes",BUFFER[cnt]);
 780       TEST_FAIL_MESSAGE(str);
 781     } else TEST_PASS();
 782   }
 783
 784   /* Set output buffer with random data*/
 785   srand(GET_SYSTICK());
 786   for (cnt = 0; cnt<BUFFER[BUFFER_NUM-1]; cnt++) {
 787     buffer_out[cnt] = (buf_t)rand()&((1U<<USART_DATA_BITS)-1U);
 788   }
 789
 790   /* Transfer data chunks */
 791   for (cnt = 0; cnt<BUFFER_NUM; cnt++) {
 792     /* Clear input buffer*/
 793     memset(buffer_in,0,BUFFER[cnt]);
 794     if (USART_RunTransfer(buffer_out, buffer_in, BUFFER[cnt]) != ARM_DRIVER_OK) {
 795       snprintf(str,sizeof(str),"[FAILED] Fail to transfer block of %d bytes",BUFFER[cnt]);
 796       TEST_FAIL_MESSAGE(str);
 797     } else TEST_PASS();
 798     if (memcmp(buffer_in, buffer_out, BUFFER[cnt])!=0) {
 799       snprintf(str,sizeof(str),"[FAILED] Fail to check block of %d bytes",BUFFER[cnt]);
 800       TEST_FAIL_MESSAGE(str);
 801     } else TEST_PASS();
 802   }
 803
 804   /* Power off and uninitialize */
 805   TEST_ASSERT(drv->PowerControl (ARM_POWER_OFF) == ARM_DRIVER_OK);
 806   TEST_ASSERT(drv->Uninitialize() == ARM_DRIVER_OK);
 807
 808   /* Free buffer */
 809   free(buffer_out);
 810   free(buffer_in);
 811 }
 812
 813 /**
 814 @}
 815 */
 816 // end of group usart_funcs
 817
 818
 819