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