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