private/hsb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ADC debugged and functional now

Browse Source 
Added Version interface

Added DisplayDevice to create an independent bridge between display app and specific display driver

git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@228 05563f52-14a8-4384-a975-3d1654cca0fa
This commit is contained in:
mmi
2017-10-04 09:06:16 +00:00
parent 802e9c64ca
commit c613e64e8a
24 changed files with 1147 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

163
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/DisplayDevice.c Normal file
View File

@@ -0,0 +1,163 @@
// -----------------------------------------------------------------------------
/// @file DisplayDevice.c
/// @brief Description
// -----------------------------------------------------------------------------
// Micro-Key bv
// Industrieweg 28, 9804 TG Noordhorn
// Postbus 92, 9800 AB Zuidhorn
// The Netherlands
// Tel: +31 594 503020
// Fax: +31 594 505825
// Email: support@microkey.nl
// Web: www.microkey.nl
// -----------------------------------------------------------------------------
/// $Revision$
/// $Author$
/// $Date$
// (c) 2017 Micro-Key bv
// -----------------------------------------------------------------------------
/// @file DisplayDevice.c
/// @ingroup {group_name}
// -----------------------------------------------------------------------------
// Include files
// -----------------------------------------------------------------------------
#include "DisplayDevice.h"
// -----------------------------------------------------------------------------
// Constant and macro definitions
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Type definitions
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// File-scope variables
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Function declarations
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Function definitions
// -----------------------------------------------------------------------------
ErrorStatus DisplayDevice_construct (struct DisplayDevice* self, struct DisplayDeviceParameters* parameters,
DisplayResetFunction reset,
DisplaySetStateFunction setState,
DisplayWriteFunction write,
DisplayClearFunction clear,
DisplaySetBrightnessFunction setBrightness,
DisplaySetContrastFunction setContrast,
DisplayInvertFunction invert)
{
ErrorStatus returnValue = SUCCESS;
self->_reset = reset;
self->_setState = setState;
self->_write = write;
self->_clear = clear;
self->_setBrightness = setBrightness;
self->_setContrast = setContrast;
self->_invert = invert;
self->parameters = *parameters;
return returnValue;
}
ErrorStatus DisplayDevice_reset(const struct DisplayDevice* self)
{
ErrorStatus returnValue = SUCCESS;
if (self->_reset != NULL)
{
returnValue = self->_reset(self);
}
return returnValue;
}
ErrorStatus DisplayDevice_setState(const struct DisplayDevice* self, DisplayDevice_functionalState state)
{
ErrorStatus returnValue = SUCCESS;
if (self->_setState != NULL)
{
returnValue = self->_setState(self, state);
}
return returnValue;
}
ErrorStatus DisplayDevice_write(const struct DisplayDevice* self, const char* buffer, size_t length, size_t row, size_t column)
{
ErrorStatus returnValue = SUCCESS;
if (self->_write != NULL)
{
returnValue = self->_write(self, buffer, length, row, column);
}
return returnValue;
}
ErrorStatus DisplayDevice_clear(const struct DisplayDevice* self)
{
ErrorStatus returnValue = SUCCESS;
if (self->_clear != NULL)
{
returnValue = self->_clear(self);
}
return returnValue;
}
ErrorStatus DisplayDevice_setBrightness(const struct DisplayDevice* self, size_t brightness)
{
ErrorStatus returnValue = SUCCESS;
if (self->_setBrightness != NULL)
{
returnValue = self->_setBrightness(self, brightness);
}
return returnValue;
}
ErrorStatus DisplayDevice_setContrast(const struct DisplayDevice* self, size_t contrast)
{
ErrorStatus returnValue = SUCCESS;
if (self->_setContrast != NULL)
{
returnValue = self->_setContrast(self, contrast);
}
return returnValue;
}
ErrorStatus DisplayDevice_invert(const struct DisplayDevice* self)
{
ErrorStatus returnValue = SUCCESS;
if (self->_invert != NULL)
{
returnValue = self->_invert(self);
}
return returnValue;
}

78
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/IODevice.c
View File

@@ -1,78 +0,0 @@
// -----------------------------------------------------------------------------
/// @file IODevice.c
/// @brief Description
// -----------------------------------------------------------------------------
// Micro-Key bv
// Industrieweg 28, 9804 TG Noordhorn
// Postbus 92, 9800 AB Zuidhorn
// The Netherlands
// Tel: +31 594 503020
// Fax: +31 594 505825
// Email: support@microkey.nl
// Web: www.microkey.nl
// -----------------------------------------------------------------------------
/// $Revision$
/// $Author$
/// $Date$
// (c) 2017 Micro-Key bv
// -----------------------------------------------------------------------------
/// @file IODevice.c
/// @ingroup {group_name}
// -----------------------------------------------------------------------------
// Include files
// -----------------------------------------------------------------------------
#include "IODevice.h"
// -----------------------------------------------------------------------------
// Constant and macro definitions
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Type definitions
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// File-scope variables
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Function declarations
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Function definitions
// -----------------------------------------------------------------------------
ErrorStatus IODevice_construct (struct IODevice* self, ReadFunction read, WriteFunction write)
{
ErrorStatus returnValue = SUCCESS;
self->_write = write;
self->_read = read;
return returnValue;
}
ErrorStatus IODevice_write(const struct IODevice* self, const char* buffer, size_t length)
{
ErrorStatus returnValue = SUCCESS;
if (self->_write != NULL)
{
self->_write(self, buffer, length);
}
return returnValue;
}

226
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/keypadMatrix.c
View File

@@ -1,226 +0,0 @@
// -----------------------------------------------------------------------------
/// @file keypadMatrix.c
/// @brief Description
// -----------------------------------------------------------------------------
// Micro-Key bv
// Industrieweg 28, 9804 TG Noordhorn
// Postbus 92, 9800 AB Zuidhorn
// The Netherlands
// Tel: +31 594 503020
// Fax: +31 594 505825
// Email: support@microkey.nl
// Web: www.microkey.nl
// -----------------------------------------------------------------------------
/// $Revision$
/// $Author$
/// $Date$
// (c) 2017 Micro-Key bv
// -----------------------------------------------------------------------------
/// @file keypadMatrix.c
/// @ingroup {group_name}
// -----------------------------------------------------------------------------
// Include files
// -----------------------------------------------------------------------------
#include <stdbool.h>
#include <stdio.h>
#include "FreeRTOSFixes.h"
#include "Logger.h"
#include "keypadMatrix.h"
#include "platform.h"
#include "stm32f10x_it.h"
// -----------------------------------------------------------------------------
// Constant and macro definitions
// -----------------------------------------------------------------------------
#define KEYPAD_STACK_SIZE (512)
#define KEYPAD_TASK_PRIORITY (3)
#define KEYPAD_DEF_QUEUESIZE (32)
// -----------------------------------------------------------------------------
// Type definitions
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// File-scope variables
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Function declarations
// -----------------------------------------------------------------------------
static ErrorStatus read(const struct IODevice* self, char* buffer, size_t length, size_t* actualLength);
static void KeypadTask(void* parameters);
// -----------------------------------------------------------------------------
// Function definitions
// -----------------------------------------------------------------------------
ErrorStatus Keypad_construct(struct Keypad* self, struct KeypadParameters* parameters, int debounceTime)
{
int rowCounter = 0;
int colCounter = 0;
ErrorStatus returnValue = SUCCESS;
if(keypad != NULL)
{
IODevice_construct(&self->device, read, NULL);
if(returnValue == SUCCESS)
{
//! Create semaphore to synchronize with Keypad/EXTI interrupt handler
vSemaphoreCreateBinary(self->scanSemaphore);
}
self->waitToDebounce_ms = debounceTime;
// Initialize memory to keep track of state changes per key
for (rowCounter = 0; rowCounter < KEYPAD_NUMBER_OF_ROWS; rowCounter++)
{
for (colCounter = 0; colCounter < KEYPAD_NUMBER_OF_COLUMNS; colCounter++)
{
self->lastState[rowCounter][colCounter] = RELEASED;
}
}
//! Create a new FREERTOS queue to handle data from Keypad input to app
self->rxQueue = xQueueCreate(parameters->rxQueueSize, sizeof(struct KeypadQueueItem));
if (self->rxQueue == 0)
{
//! Queue identifier is 0 -> error
returnValue = ERROR; //! Set error flag
}
if(returnValue == SUCCESS)
{
xTaskCreate(KeypadTask, (const char*)"keypadTask", KEYPAD_STACK_SIZE, keypad, KEYPAD_TASK_PRIORITY, self->taskHandle);
}
if(returnValue == SUCCESS)
{
//! take txSemaphore
if (xSemaphoreTake(self->scanSemaphore, 0) == pdFALSE)
{
//! An error has occurred
returnValue = ERROR;
}
}
if(returnValue == SUCCESS)
{
LOGGER_INFO("Keypad task started");
}
else
{
LOGGER_ERROR("Keypad task FAILED");
}
}
return returnValue;
}
void Keypad_Destruct (const struct Keypad* self)
{
vTaskDelete(self->taskHandle);
vQueueDelete(self->rxQueue);
}
ErrorStatus Keypad_getDefaultParameters(struct KeypadParameters* parameters)
{
ErrorStatus errorStatus = SUCCESS;
parameters->rxQueueSize = KEYPAD_DEF_QUEUESIZE;
return errorStatus;
}
static ErrorStatus read(const struct IODevice* self, char* buffer, size_t length, size_t* actualLength)
{
ErrorStatus errorStatus = SUCCESS;
*actualLength = 1;
return errorStatus;
}
static void KeypadTask(void* parameters)
{
int rowCounter = 0;
int colCounter = 0;
struct Keypad* self = (struct Keypad*) parameters;
while (1)
{
// Wait for an interrupt to occur on one of the keypad columns
xSemaphoreTake(self->scanSemaphore, portMAX_DELAY);
// Debounce the keypad and wait for debounceTime prior to do anything
vTaskDelay(self->waitToDebounce_ms);
// Set all row outputs
for (rowCounter = 0; rowCounter < KEYPAD_NUMBER_OF_ROWS; rowCounter++)
{
GPIO_SetBits(self->row[rowCounter].gpio.GPIO_Typedef, self->row[rowCounter].gpio.GPIO_InitStruct.GPIO_Pin);
}
// Scan through each row individually by resetting it (output level low) and check all column levels
for (rowCounter = 0; rowCounter < KEYPAD_NUMBER_OF_ROWS; rowCounter++)
{
GPIO_ResetBits(self->row[rowCounter].gpio.GPIO_Typedef, self->row[rowCounter].gpio.GPIO_InitStruct.GPIO_Pin);
for (colCounter = 0; colCounter < KEYPAD_NUMBER_OF_COLUMNS; colCounter++)
{
if (GPIO_ReadInputDataBit(self->column[colCounter].gpio.GPIO_Typedef, self->column[colCounter].gpio.GPIO_InitStruct.GPIO_Pin) == (uint8_t)Bit_SET)
{
if (self->lastState[rowCounter][colCounter] == PRESSED)
{
self->lastState[rowCounter][colCounter] = RELEASED;
// Key has been released
LOGGER_DEBUG("KEY row%d, column%d released", rowCounter, colCounter);
}
else
{
// nothing changed
}
}
else
{
if (self->lastState[rowCounter][colCounter] == RELEASED)
{
self->lastState[rowCounter][colCounter] = PRESSED;
// Key has been pressed
LOGGER_DEBUG("KEY row%d, column%d pressed", rowCounter, colCounter);
}
else
{
// nothing changed
}
}
}
GPIO_SetBits(self->row[rowCounter].gpio.GPIO_Typedef, self->row[rowCounter].gpio.GPIO_InitStruct.GPIO_Pin);
}
// Reset all row outputs and return to IRQ status
for (rowCounter = 0; rowCounter < KEYPAD_NUMBER_OF_ROWS; rowCounter++)
{
GPIO_ResetBits(self->row[rowCounter].gpio.GPIO_Typedef, self->row[rowCounter].gpio.GPIO_InitStruct.GPIO_Pin);
}
IRQ_setKeypadEXTI(self, ENABLE);
}
}

70
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/nhd0420.c
View File

@@ -64,6 +64,11 @@ static int nhd0420_cursorRowOffset[NHD0420_NUMBER_OF_ROWS] =
// Function declarations
// -----------------------------------------------------------------------------
static ErrorStatus setState(const struct DisplayDevice* self, DisplayDevice_functionalState state);
static ErrorStatus write(const struct DisplayDevice* self, const char* buffer, size_t length, size_t row, size_t column);
static ErrorStatus clear(const struct DisplayDevice* self);
static ErrorStatus setBrightness(const struct DisplayDevice* self, size_t brightness);
static ErrorStatus setContrast(const struct DisplayDevice* self, size_t contrast);
// -----------------------------------------------------------------------------
// Function definitions
@@ -77,6 +82,15 @@ ErrorStatus NHD0420_construct(struct NHD0420* self, const struct IODevice* devic
if (self->device == NULL)
{
self->device = device;
struct DisplayDeviceParameters ddParameters;
ddParameters.numberOfRows = NHD0420_NUMBER_OF_ROWS;
ddParameters.numberOfColumns = NHD0420_NUMBER_OF_COLUMNS;
ddParameters.brightnessMin = NHD0420_BRIGHTNESS_MIN;
ddParameters.brightnessMax = NHD0420_BRIGHTNESS_MAX;
ddParameters.contrastMin = NHD0420_CONTRAST_MIN;
ddParameters.contrastMax = NHD0420_CONTRAST_MAX;
DisplayDevice_construct(&self->displayDevice, &ddParameters, NULL, setState, write, clear, setBrightness, setContrast, NULL);
}
else
{
@@ -137,7 +151,7 @@ ErrorStatus NHD0420_getSpiParameters(struct SpiParameters* parameters)
}
ErrorStatus NHD0420_setCursorToPosition(const struct NHD0420* self, char row, char column)
ErrorStatus NHD0420_setCursorToPosition(const struct NHD0420* self, size_t row, size_t column)
{
ErrorStatus returnValue = SUCCESS;
@@ -298,3 +312,57 @@ ErrorStatus NHD0420_sendData(const struct NHD0420* self, const char* buffer, siz
return returnValue;
}
static ErrorStatus setState(const struct DisplayDevice* self, DisplayDevice_functionalState state)
{
ErrorStatus returnValue = SUCCESS;
if (state == ON)
{
returnValue = NHD0420_turnOnDisplay((const struct NHD0420*)self);
}
else
{
returnValue = NHD0420_turnOffDisplay((const struct NHD0420*)self);
}
return returnValue;
}
static ErrorStatus write(const struct DisplayDevice* self, const char* buffer, size_t length, size_t row, size_t column)
{
ErrorStatus returnValue = SUCCESS;
// Set cursor on display
returnValue = NHD0420_setCursorToPosition((const struct NHD0420*)self, row, column);
if (returnValue == SUCCESS)
{
returnValue = NHD0420_sendData((const struct NHD0420*)self, buffer, length);
}
return returnValue;
}
static ErrorStatus clear(const struct DisplayDevice* self)
{
return NHD0420_clearScreen((const struct NHD0420*)self);
}
static ErrorStatus setBrightness(const struct DisplayDevice* self, size_t brightness)
{
return NHD0420_setBacklightBrightness((const struct NHD0420*)self, brightness);
}
static ErrorStatus setContrast(const struct DisplayDevice* self, size_t contrast)
{
return NHD0420_setContrast((const struct NHD0420*)self, contrast);
}