ceedling 0.13.0.rc1 → 0.13.0

data/vendor/cmock/examples/src/UsartBaudRateRegisterCalculator.c

@@ -0,0 +1,18 @@
+#include "Types.h"
+#include "UsartBaudRateRegisterCalculator.h"
+
+uint8 UsartModel_CalculateBaudRateRegisterSetting(uint32 masterClock, uint32 baudRate)
+{
+  uint32 registerSetting = ((masterClock * 10) / (baudRate * 16));
+
+  if ((registerSetting % 10) >= 5)
+  {
+    registerSetting = (registerSetting / 10) + 1;
+  }
+  else
+  {
+    registerSetting /= 10;
+  }
+
+  return (uint8)registerSetting;
+}

data/vendor/cmock/examples/src/UsartBaudRateRegisterCalculator.h

@@ -0,0 +1,6 @@
+#ifndef _USARTBAUDRATEREGISTERCALCULATOR_H
+#define _USARTBAUDRATEREGISTERCALCULATOR_H
+
+uint8 UsartModel_CalculateBaudRateRegisterSetting(uint32 masterClock, uint32 baudRate);
+
+#endif // _USARTBAUDRATEREGISTERCALCULATOR_H

data/vendor/cmock/examples/src/UsartConductor.c

@@ -0,0 +1,21 @@
+#include "Types.h"
+#include "UsartConductor.h"
+#include "UsartHardware.h"
+#include "UsartModel.h"
+#include "TaskScheduler.h"
+
+void UsartConductor_Init(void)
+{
+  UsartHardware_Init(UsartModel_GetBaudRateRegisterSetting());
+  UsartHardware_TransmitString(UsartModel_GetWakeupMessage());
+}
+
+void UsartConductor_Run(void)
+{
+  char* temp;
+  if (TaskScheduler_DoUsart())
+  {
+    temp = UsartModel_GetFormattedTemperature();
+    UsartHardware_TransmitString(temp);
+  }
+}

data/vendor/cmock/examples/src/UsartConductor.h

@@ -0,0 +1,7 @@
+#ifndef _USARTCONDUCTOR_H
+#define _USARTCONDUCTOR_H
+
+void UsartConductor_Init(void);
+void UsartConductor_Run(void);
+
+#endif // _USARTCONDUCTOR_H

data/vendor/cmock/examples/src/UsartConfigurator.c

@@ -0,0 +1,39 @@
+#include "Types.h"
+#include "UsartConfigurator.h"
+
+void Usart_ConfigureUsartIO(void)
+{
+  AT91C_BASE_PIOA->PIO_ASR = USART0_TX_PIN;
+  AT91C_BASE_PIOA->PIO_BSR = 0;
+  AT91C_BASE_PIOA->PIO_PDR = USART0_TX_PIN;
+}
+
+void Usart_EnablePeripheralClock(void)
+{
+  AT91C_BASE_PMC->PMC_PCER = ((uint32)1) << USART0_CLOCK_ENABLE;
+}
+
+void Usart_Reset(void)
+{
+  AT91C_BASE_US0->US_IDR = 0xffffffff;
+  AT91C_BASE_US0->US_CR = AT91C_US_RSTRX | AT91C_US_RSTTX | AT91C_US_RXDIS | AT91C_US_TXDIS;
+}
+
+void Usart_ConfigureMode(void)
+{
+  AT91C_BASE_US0->US_MR = AT91C_US_USMODE_NORMAL |
+                          AT91C_US_NBSTOP_1_BIT |
+                          AT91C_US_PAR_NONE |
+                          AT91C_US_CHRL_8_BITS |
+                          AT91C_US_CLKS_CLOCK;
+}
+
+void Usart_SetBaudRateRegister(uint8 baudRateRegisterSetting)
+{
+  AT91C_BASE_US0->US_BRGR = baudRateRegisterSetting;
+}
+
+void Usart_Enable(void)
+{
+  AT91C_BASE_US0->US_CR = AT91C_US_TXEN;
+}

data/vendor/cmock/examples/src/UsartConfigurator.h

@@ -0,0 +1,13 @@
+#ifndef _USARTCONFIGURATOR_H
+#define _USARTCONFIGURATOR_H
+
+#include "Types.h"
+
+void Usart_ConfigureUsartIO(void);
+void Usart_EnablePeripheralClock(void);
+void Usart_Reset(void);
+void Usart_ConfigureMode(void);
+void Usart_SetBaudRateRegister(uint8 baudRateRegisterSetting);
+void Usart_Enable(void);
+
+#endif // _USARTCONFIGURATOR_H

data/vendor/cmock/examples/src/UsartHardware.c

@@ -0,0 +1,22 @@
+#include "Types.h"
+#include "UsartHardware.h"
+#include "UsartConfigurator.h"
+#include "UsartPutChar.h"
+
+void UsartHardware_Init(uint8 baudRateRegisterSetting)
+{
+  Usart_ConfigureUsartIO();
+  Usart_EnablePeripheralClock();
+  Usart_Reset();
+  Usart_ConfigureMode();
+  Usart_SetBaudRateRegister(baudRateRegisterSetting);
+  Usart_Enable();
+}
+
+void UsartHardware_TransmitString(char* data)
+{
+  while(*data != NULL)
+  {
+    Usart_PutChar(*data++);
+  }
+}

data/vendor/cmock/examples/src/UsartHardware.h

@@ -0,0 +1,9 @@
+#ifndef _USARTHARDWARE_H
+#define _USARTHARDWARE_H
+
+#include "Types.h"
+
+void UsartHardware_Init(uint8 baudRateRegisterSetting);
+void UsartHardware_TransmitString(char* data);
+
+#endif // _USARTHARDWARE_H

data/vendor/cmock/examples/src/UsartModel.c

@@ -0,0 +1,34 @@
+#include "Types.h"
+#include "UsartModel.h"
+#include "ModelConfig.h"
+#include "UsartBaudRateRegisterCalculator.h"
+#include "TemperatureFilter.h"
+#include <stdio.h>
+#include <math.h>
+
+char formattedTemperature[32];
+char* wakeup = "It's Awesome Time!\n";
+
+uint8 UsartModel_GetBaudRateRegisterSetting(void)
+{
+  return UsartModel_CalculateBaudRateRegisterSetting(MASTER_CLOCK, USART0_BAUDRATE);
+}
+
+char* UsartModel_GetFormattedTemperature(void)
+{
+  float temperature = TemperatureFilter_GetTemperatureInCelcius();
+  if (temperature == -INFINITY)
+  {
+    sprintf(formattedTemperature, "%s", "Temperature sensor failure!\n");
+  }
+  else
+  {
+    sprintf(formattedTemperature, "%.1f C\n", temperature);
+  }
+  return formattedTemperature;
+}
+
+char* UsartModel_GetWakeupMessage(void)
+{
+  return wakeup;
+}

data/vendor/cmock/examples/src/UsartModel.h

@@ -0,0 +1,10 @@
+#ifndef _USARTMODEL_H
+#define _USARTMODEL_H
+
+#include "Types.h"
+
+uint8 UsartModel_GetBaudRateRegisterSetting(void);
+char* UsartModel_GetFormattedTemperature(void);
+char* UsartModel_GetWakeupMessage(void);
+
+#endif // _USARTMODEL_H

data/vendor/cmock/examples/src/UsartPutChar.c

@@ -0,0 +1,16 @@
+#include "Types.h"
+#include "UsartPutChar.h"
+#include "UsartTransmitBufferStatus.h"
+#ifdef SIMULATE
+#include <stdio.h>
+#endif
+
+void Usart_PutChar(char data)
+{
+  while(!Usart_ReadyToTransmit());
+#ifdef SIMULATE
+  printf("%c", data);
+#else
+  AT91C_BASE_US0->US_THR = data;
+#endif
+}

data/vendor/cmock/examples/src/UsartPutChar.h

@@ -0,0 +1,8 @@
+#ifndef _USARTPUT_HAR_H
+#define _USARTPUT_HAR_H
+
+#include "Types.h"
+
+void Usart_PutChar(char data);
+
+#endif // _USARTPUT_HAR_H

data/vendor/cmock/examples/src/UsartTransmitBufferStatus.c

@@ -0,0 +1,7 @@
+#include "Types.h"
+#include "UsartTransmitBufferStatus.h"
+
+bool Usart_ReadyToTransmit(void)
+{
+  return (AT91C_BASE_US0->US_CSR & AT91C_US_TXRDY) > 0;
+}

data/vendor/cmock/examples/src/UsartTransmitBufferStatus.h

@@ -0,0 +1,8 @@
+#ifndef _USARTTRANSMITBUFFERSTATUS_H
+#define _USARTTRANSMITBUFFERSTATUS_H
+
+#include "Types.h"
+
+bool Usart_ReadyToTransmit(void);
+
+#endif // _USARTTRANSMITBUFFERSTATUS_H

data/vendor/cmock/examples/test/TestAdcConductor.c

@@ -0,0 +1,121 @@
+#include "unity.h"
+#include "UnityHelper.h"
+#include "Types.h"
+#include "Types.h"
+#include "AdcConductor.h"
+#include "MockAdcModel.h"
+#include "MockAdcHardware.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testInitShouldCallHardwareInit(void)
+{
+  AdcHardware_Init_Expect();
+  AdcConductor_Init();
+}
+
+void testRunShouldNotDoAnythingIfItIsNotTime(void)
+{
+  AdcModel_DoGetSample_ExpectAndReturn(FALSE);
+
+  AdcConductor_Run();
+}
+
+void testRunShouldNotPassAdcResultToModelIfSampleIsNotComplete(void)
+{
+  AdcModel_DoGetSample_ExpectAndReturn(TRUE);
+  AdcHardware_GetSampleComplete_ExpectAndReturn(FALSE);
+
+  AdcConductor_Run();
+}
+
+void testRunShouldGetLatestSampleFromAdcAndPassItToModelAndStartNewConversionWhenItIsTime(void)
+{
+  AdcModel_DoGetSample_ExpectAndReturn(TRUE);
+  AdcHardware_GetSampleComplete_ExpectAndReturn(TRUE);
+  AdcHardware_GetSample_ExpectAndReturn(293U);
+  AdcModel_ProcessInput_Expect(293U);
+  AdcHardware_StartConversion_Expect();
+
+  AdcConductor_Run();
+}
+
+void testJustHereToTest_Should_ProperlyPassAStructAndVerifyIt(void)
+{
+    EXAMPLE_STRUCT_T TestStruct;
+    TestStruct.x = 5;
+    TestStruct.y = 7;
+
+    AdcModel_DoNothingExceptTestASpecialType_ExpectAndReturn(TestStruct, TRUE);
+
+    TEST_ASSERT_TRUE(AdcConductor_JustHereToTest());
+}
+
+//void testJustHereToTest_Should_FailThisTestIfYouUncommentXIsBecauseItsWrong(void)
+//{
+//    EXAMPLE_STRUCT_T TestStruct;
+//    TestStruct.x = 6;
+//    TestStruct.y = 7;
+//
+//    AdcModel_DoNothingExceptTestASpecialType_ExpectAndReturn(TestStruct, TRUE);
+//
+//    TEST_ASSERT_TRUE(AdcConductor_JustHereToTest());
+//}
+//
+//void testJustHereToTest_Should_FailThisTestIfYouUncommentYIsBecauseItsWrong(void)
+//{
+//    EXAMPLE_STRUCT_T TestStruct;
+//    TestStruct.x = 5;
+//    TestStruct.y = 8;
+//
+//    AdcModel_DoNothingExceptTestASpecialType_ExpectAndReturn(TestStruct, TRUE);
+//
+//    TEST_ASSERT_TRUE(AdcConductor_JustHereToTest());
+//}
+
+void test_AdcConductor_AlsoHereToTest_Should_ProperlyReturnAStructAsExpected1(void)
+{
+    EXAMPLE_STRUCT_T TestStruct;
+    TestStruct.x = 99;
+    TestStruct.y = 1;
+
+    AdcModel_DoNothingExceptReturnASpecialType_ExpectAndReturn(TestStruct);
+
+    TEST_ASSERT_TRUE(AdcConductor_AlsoHereToTest());
+}
+
+void test_AdcConductor_AlsoHereToTest_Should_ProperlyReturnAStructAsExpected2(void)
+{
+    EXAMPLE_STRUCT_T TestStruct;
+    TestStruct.x = 98;
+    TestStruct.y = 1;
+
+    AdcModel_DoNothingExceptReturnASpecialType_ExpectAndReturn(TestStruct);
+
+    TEST_ASSERT_FALSE(AdcConductor_AlsoHereToTest());
+}
+
+void test_AdcConductor_YetAnotherTest_Should_VerifyThatPointersToStructsAreTestable(void)
+{
+    uint32 TestNum = 3;
+
+    AdModel_DoNothingExceptTestPointers_ExpectAndReturn(&TestNum, TRUE);
+
+    TEST_ASSERT_TRUE(AdcConductor_YetAnotherTest());
+}
+
+//void test_AdcConductor_YetAnotherTest_Should_FailIfYouUncommentThisTestBecauseTheValuePointedToIsWrong(void)
+//{
+//    uint32 TestNum = 7;
+//
+//    AdModel_DoNothingExceptTestPointers_ExpectAndReturn(&TestNum, FALSE);
+//
+//    TEST_ASSERT_FALSE(AdcConductor_YetAnotherTest());
+//}
+

data/vendor/cmock/examples/test/TestAdcHardware.c

@@ -0,0 +1,44 @@
+#include "unity.h"
+#include "Types.h"
+#include "AdcHardware.h"
+#include "MockAdcHardwareConfigurator.h"
+#include "MockAdcTemperatureSensor.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testInitShouldDelegateToConfiguratorAndTemperatureSensor(void)
+{
+  Adc_Reset_Expect();
+  Adc_ConfigureMode_Expect();
+  Adc_EnableTemperatureChannel_Expect();
+  Adc_StartTemperatureSensorConversion_Expect();
+
+  AdcHardware_Init();
+}
+
+void testGetSampleCompleteShouldReturn_FALSE_WhenTemperatureSensorSampleReadyReturns_FALSE(void)
+{
+  Adc_TemperatureSensorSampleReady_ExpectAndReturn(FALSE);
+  TEST_ASSERT(!AdcHardware_GetSampleComplete());
+}
+
+void testGetSampleCompleteShouldReturn_TRUE_WhenTemperatureSensorSampleReadyReturns_TRUE(void)
+{
+  Adc_TemperatureSensorSampleReady_ExpectAndReturn(TRUE);
+  TEST_ASSERT(AdcHardware_GetSampleComplete());
+}
+
+void testGetSampleShouldDelegateToAdcTemperatureSensor(void)
+{
+  uint16 sample;
+  Adc_ReadTemperatureSensor_ExpectAndReturn(847);
+
+  sample = AdcHardware_GetSample();
+  TEST_ASSERT_EQUAL(847, sample);
+}

data/vendor/cmock/examples/test/TestAdcHardwareConfigurator.c

@@ -0,0 +1,43 @@
+#include "unity.h"
+#include "Types.h"
+#include "AdcHardwareConfigurator.h"
+#include "AT91SAM7X256.h"
+#include "ModelConfig.h"
+
+AT91S_ADC AdcPeripheral;
+
+void setUp(void)
+{
+
+}
+
+void tearDown(void)
+{
+}
+
+void testResetShouldResetTheAdcConverterPeripheral(void)
+{
+  AT91C_BASE_ADC->ADC_CR = 0;
+  Adc_Reset();
+  TEST_ASSERT_EQUAL(AT91C_ADC_SWRST, AT91C_BASE_ADC->ADC_CR);
+}
+
+void testConfigureModeShouldSetAdcModeRegisterAppropriately(void)
+{
+  uint32 prescaler = (MASTER_CLOCK / (2 * 2000000)) - 1; // 5MHz ADC clock
+
+  AT91C_BASE_ADC->ADC_MR = 0;
+
+  Adc_ConfigureMode();
+
+  TEST_ASSERT_EQUAL(prescaler, (AT91C_BASE_ADC->ADC_MR & AT91C_ADC_PRESCAL) >> 8);
+}
+
+void testEnableTemperatureChannelShouldEnableTheAppropriateAdcInput(void)
+{
+  AT91C_BASE_ADC->ADC_CHER = 0;
+
+  Adc_EnableTemperatureChannel();
+
+  TEST_ASSERT_EQUAL(0x1 << 4, AT91C_BASE_ADC->ADC_CHER);
+}