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