blinky 2013sep23hkt2016

// ***********************************************************************
// Program  - LPC1114 GPIO Testing
// Function - LED, 7 Segment LED, Key Testing
// Author   - TL Fong
// Build    - 2013.09.22.04
// Date     - 2013sep22hkt2003
// Hardware - WHUT LPC11C14/301 Evaluation Board
// Software - GCC ARM 4.7, CoIDE 1.7.4,  CoLinkEx 1.1, Flash Magic v7.51
// ***********************************************************************

#include "test031.h"

// ***********************************************************************
// Main Function
// ***********************************************************************

int main()
{
// blinkLedP18EightTimes(); // LED #1 - WHUT LED D1
// blinkLedP09FourTimes(); // LED #5 - WHUT JTAG Pin 13
// blinkAllLeds01(); // WHUT LED D1 to D4, JTAG Pin 13
// displayAllSevenSegmentLedDigits(); // WHUT 7 Segment LED
        // blinkDisplayAll(); // blink 5 LEDs, display all digits

startProgram();

echoWakeUpKeyFourTimes();

return 0;
}

// ***********************************************************************
// End
// ***********************************************************************




// ***********************************************************************
// test031.h 2013sep22hkt1139
// ***********************************************************************

#include "led031.h"
#include "key033.h"

void blinkLedP18EightTimes() // LED #1 - WHUT LED D1
{
delayTime(TWO_SECONDS);

blinkLedP18(ON_ONE_FIFTH_SECOND, OFF_ONE_FIFTH_SECOND, REPEAT_8_TIMES);
}

void blinkLedP09FourTimes() // LED #5 - WHUT JTAG Pin 13
{
delayTime(TWO_SECONDS);

blinkLedP09(ON_ONE_FIFTH_SECOND, OFF_ONE_FIFTH_SECOND, REPEAT_4_TIMES);
}

void blinkAllLeds01() // WHUT LED D1 to D4, JTAG Pin 13
{
initializeAllOutputPins(WhutBoardLedPortPinArrayPointerArray, MAX_LED_NUMBER);

delayTime(TWO_SECONDS);

blinkAllLeds(ON_ONE_FIFTH_SECOND, OFF_ONE_FIFTH_SECOND, REPEAT_2_TIMES);
}

void displayAllSevenSegmentLedDigits() // WHUT 7 Segment LED
{
initializeAllOutputPins(WhutBoardSevenSegmentLedPortPinArrayPointerArray, \
MAX_7_SEG_LED_PIN_NUMBER);

delayTime(TWO_SECONDS);

displayAllDigits();
}

void blinkDisplayAll()
{
initializeAllOutputPins(WhutBoardLedPortPinArrayPointerArray, MAX_LED_NUMBER);
initializeAllOutputPins(WhutBoardSevenSegmentLedPortPinArrayPointerArray, \
MAX_7_SEG_LED_PIN_NUMBER);

delayTime(ONE_SECOND);
blinkAllLeds(ON_ONE_FIFTH_SECOND, OFF_ONE_FIFTH_SECOND, REPEAT_2_TIMES);
delayTime(ONE_SECOND);
displayAllDigits();
}

void startProgram()
{
initializeAllOutputPins(WhutBoardLedPortPinArrayPointerArray, MAX_LED_NUMBER);
initializeAllOutputPins(WhutBoardSevenSegmentLedPortPinArrayPointerArray, \
MAX_7_SEG_LED_PIN_NUMBER);

displayAllBlank();
delayTime(ONE_SECOND);
display1Digit(DIGIT_3);
delayTime(ONE_SECOND);
display1Digit(DIGIT_3);
delayTime(ONE_SECOND);
display1Digit(DIGIT_2);
delayTime(ONE_SECOND);
display1Digit(DIGIT_1);
delayTime(ONE_SECOND);
display1Digit(DIGIT_0);
delayTime(ONE_SECOND);

blinkDigit(DIGIT_0, ONE_HALF_SECOND, ONE_HALF_SECOND, REPEAT_2_TIMES);
}
void echoWakeUpKeyFourTimes()
{
initializeAllInputPins(WhutBoardKeyPortPinArrayPointerArray, MAX_KEY_NUMBER);
echo1KeyBySingleLed(KEY_5, LED_5, REPEAT_4_TIMES);
}

// ***********************************************************************
// End
// ***********************************************************************



// ***********************************************************************
// config031.h - 2013sep22hkt1139
// ***********************************************************************

#include "lpc11xx_syscon.h"
#include "lpc11xx_gpio.h"
#include "lpc11xx_iocon.h"

// #include "lpc11xx_uart.h"

#ifndef CONFIG_HEADER_SEEN
#define CONFIG_HEADER_SEEN

// ***********************************************************************
// * Logic voltage level, IO direction *
// ***********************************************************************

#define LOW 0
#define HIGH 1

#define LOW_LEVEL 0
#define HIGH_LEVEL 1

#define LOGIC_LOW_LEVEL 0
#define LOGIC_HIGH_LEVEL 1

typedef int logicLevelValue;

logicLevelValue LogicLevelLow = 0;
logicLevelValue LogicLevelHigh = 1;

// ***********************************************************************
// * GPIO Direction *
// ***********************************************************************

#define INPUT_DIRECTION 0
#define OUTPUT_DIRECTION 1

typedef int directionValue;

directionValue InputDirection = 0;
directionValue OutputDirection = 1;


// ***********************************************************************
// * Delay tenth seconds *
// ***********************************************************************

#define ONE_FIFTH_SECOND  2
#define ONE_HALF_SECOND   5
#define ONE_SECOND       10
#define TWO_SECONDS      20

#define ON_ONE_FIFTH_SECOND   2
#define OFF_ONE_FIFTH_SECOND  2
#define ON_ONE_HALF_SECOND    5
#define OFF_ONE_HALF_SECOND   5
#define ON_ONE_SECOND        10
#define OFF_ONE_SECOND       10

// ***********************************************************************
// * Repeat times *
// ***********************************************************************

#define REPEAT_1_TIME 1
#define REPEAT_2_TIMES 2
#define REPEAT_3_TIMES 3
#define REPEAT_4_TIMES 4
#define REPEAT_5_TIMES 5
#define REPEAT_6_TIMES 6
#define REPEAT_8_TIMES 8
#define REPEAT_10_TIMES 10
#define REPEAT_20_TIMES 20

// *** GPIO port number, pin number, port/pin number ***

#define PORT0 0
#define PORT1 1
#define PORT2 2
#define PORT3 3

#define PIN0 0
#define PIN1 1
#define PIN2 2
#define PIN3 3
#define PIN4 4
#define PIN5 5
#define PIN6 6
#define PIN7 7
#define PIN8 8
#define PIN9 9
#define PIN10 10
#define PIN11 11

typedef int portNumber;
portNumber Port0 = 0;
portNumber Port1 = 1;
portNumber Port2 = 2;
portNumber Port3 = 3;

typedef int pinNumber;
pinNumber Pin0  =  0;
pinNumber Pin1  =  1;
pinNumber Pin2  =  2;
pinNumber Pin3  =  3;
pinNumber Pin4  =  4;
pinNumber Pin5  =  5;
pinNumber Pin6  =  6;
pinNumber Pin7  =  7;
pinNumber Pin8  =  8;
pinNumber Pin9  =  9;
pinNumber Pin10 = 10;
pinNumber Pin11 = 11;

typedef const int portPinNumber;

portPinNumber Pio05  = 5;
portPinNumber Pio08  = 8;
portPinNumber Pio09  = 9;

portPinNumber Rpio11 = 11;
portPinNumber Rpio12 = 12;
portPinNumber Pio19  = 19;
portPinNumber Rpio18 = 18;
portPinNumber Pio110  = 110;

// *** system timer number, match register number ***

typedef const int timerNumber;
timerNumber Ct16b0 = 0;
timerNumber Ct16b1 = 1;
timerNumber Ct32b0 = 2;
timerNumber Ct32b1 = 3;

typedef const int matchRegisterNumber;
matchRegisterNumber MatchRegister0 = 0;
matchRegisterNumber MatchRegister1 = 1;
matchRegisterNumber MatchRegister2 = 2;

typedef const int deviceNumber;

#define LED1 1
#define LED2 2
#define LED3 3
#define LED4 4
#define LED5 5

#define LED_1 1
#define LED_2 2
#define LED_3 3
#define LED_4 4
#define LED_5 5

#define DIGIT_0 0
#define DIGIT_1 1
#define DIGIT_2 2
#define DIGIT_3 3
#define DIGIT_4 4
#define DIGIT_5 5
#define DIGIT_6 6
#define DIGIT_7 7
#define DIGIT_8 8
#define DIGIT_9 9

#define KEY_1 1
#define KEY_2 2
#define KEY_3 3
#define KEY_4 4
#define KEY_5 5

#define MAX_DEVICE_NUMBER 5
#define MAX_LED_NUMBER    5
#define MAX_KEY_NUMBER    5
#define MAX_PWM_NUMBER    5

// *** Port pin array typedef and declaration ***

// ***********************************************************************
// typedef portPinArray[]
// Description - this array denotes a GPIO port pin.  It has two elements,
//   portNumber and pinNumber
// **********************************************************************

#define PORT_INDEX 0
#define PIN_INDEX 1

typedef int portPinArray[2];

// ***********************************************************************
// WHUT LP!1114 Evaluation Board configuration
// ***********************************************************************

const int MaxBoardDeviceNumber =  5;
const int MaxBoardLedNumber = 5;
const int MaxBoardKeyNumber = 5;
const int MaxBoardPwmNumber = 5;

portPinArray WhutBoardLedPortPinArray1 = {PORT1, PIN8};  // LED D1
portPinArray WhutBoardLedPortPinArray2 = {PORT1, PIN9};  // LED D2
portPinArray WhutBoardLedPortPinArray3 = {PORT1, PIN10}; // LED D3
portPinArray WhutBoardLedPortPinArray4 = {PORT1, PIN11}; // LED D4
portPinArray WhutBoardLedPortPinArray5 = {PORT0, PIN9};  // JTAG pin13

#define SCLK_INDEX 0
#define DIN_INDEX 1
#define LATCH_INDEX 2

// *** Seven segment LED data and control signals ***

portPinArray WhutBoardSevenSegmentLedPortPinArraySclk = {PORT2, PIN1}; // Serial Clock
portPinArray WhutBoardSevenSegmentLedPortPinArrayDin = {PORT2, PIN3}; // Data in
portPinArray WhutBoardSevenSegmentLedPortPinArrayLatch = {PORT2, PIN0}; // Latch

portPinArray WhutBoardKeyPortPinArray1 = {PORT2, PIN7};  // LCD D4 <<<<< 2013aug28
portPinArray WhutBoardKeyPortPinArray2 = {PORT2, PIN8};  // LCD D5 <<<<< 2013aug28
portPinArray WhutBoardKeyPortPinArray3 = {PORT2, PIN9};  // LCD D6 <<<<< 2013aug28
portPinArray WhutBoardKeyPortPinArray4 = {PORT2, PIN10}; // LCD D7 <<<<< 2013aug28
portPinArray WhutBoardKeyPortPinArray5 = {PORT1, PIN4};  // WakeUp <<<<< 2013aug30

// ***********************************************************************
// typedef portPinArrayPointerArray
// Description - Array pointers to pin array
// **********************************************************************

// *** Led configuration ***

typedef portPinArray *portPinArrayPointerArray[MAX_DEVICE_NUMBER];

#define WHUT_MAX_LED_PIN_NUMBER 5

portPinArrayPointerArray WhutBoardLedPortPinArrayPointerArray[WHUT_MAX_LED_PIN_NUMBER] = \
  {&WhutBoardLedPortPinArray1, &WhutBoardLedPortPinArray2, \
  &WhutBoardLedPortPinArray3, &WhutBoardLedPortPinArray4, \
  &WhutBoardLedPortPinArray5};

// *** 7 Segment LED configuration ***

#define MAX_7_SEG_LED_PIN_NUMBER 3

portPinArrayPointerArray WhutBoardSevenSegmentLedPortPinArrayPointerArray[MAX_7_SEG_LED_PIN_NUMBER] = \
  {&WhutBoardSevenSegmentLedPortPinArraySclk, &WhutBoardSevenSegmentLedPortPinArrayDin, \
       &WhutBoardSevenSegmentLedPortPinArrayLatch};

// *** Key configuration ***

#define MAX_KEY_PIN_NUMBER 5

portPinArrayPointerArray WhutBoardKeyPortPinArrayPointerArray[MAX_KEY_PIN_NUMBER] = \
    {&WhutBoardKeyPortPinArray1, &WhutBoardKeyPortPinArray2, \
    &WhutBoardKeyPortPinArray3, &WhutBoardKeyPortPinArray4, \
    &WhutBoardKeyPortPinArray5};

// ***********************************************************************
// typedef mcuBoardStruct (To test later)
// Description - MCU Board struct with LEDs, Keys, and PWMs
// **********************************************************************

typedef struct
 {
 portPinArrayPointerArray *LedPortPinArrayPointerArray;
 portPinArrayPointerArray *KeyPortPinArrayPointerArray;
 portPinArrayPointerArray *PwmPortPinArrayPointerArray;
 } mcuBoardStruct;

// *** WHUT LPC1114 Evaluation Board Configuration ***

mcuBoardStruct *WHUT_LPC1114_EvaluationBoardStructPointer() // To be tested
 {
 mcuBoardStruct *WHUT_LPC1114_EValuationBoardStructPointer;

   // WHUT_LPC1114_EvaluationBoardStructPointer-> LedPortPinArrayPointerArray = \
     // WhutBoardLedPortPinArrayPointerArray;

   // WHUT_LPC1114_EvaluationBoardStructPointer-> SevenSegmentLedPortPinArrayPointerArray = \
       // WhutBoardSevenSegmentLedPortPinArrayPointerArray;

     // WHUT_LPC1114_EvaluationBoardStructPointer-> KeyPortPinArrayPointerArray = \
     // WhutBoardKeyPortPinArrayPointerArray;

  return WHUT_LPC1114_EValuationBoardStructPointer;
 }

// * typedefs of logic level and IO direction *

// ***********************************************************************
// typedef GPIO_TypeDef *gpioStructPointerArray[4];
// Description - CMSIS declares 4 struct pointers LPC_GPIO0, LPC_GPIO1,
// LPC_GPIO2, LPC_GPIO3 for the 4 structs each of which controls
// one port of up to 11 pins.
// ***********************************************************************

typedef GPIO_TypeDef *gpioStructPointerArray[4];
gpioStructPointerArray CmsisGpioStructPointerArray = {LPC_GPIO0, LPC_GPIO1, LPC_GPIO2, LPC_GPIO3};

#endif /* CONFIG_HEADER_SEEN */

// ***********************************************************************
// * End *
// ***********************************************************************



// ***********************************************************************
// gpio033.h 2013sep22hkt1540
// ***********************************************************************

#ifndef GPIO033_HEADER_SEEN
#define GPIO033_HEADER_SEEN

#include "lpc11xx_syscon.h"
#include "lpc11xx_gpio.h"
#include "lpc11xx_iocon.h"
#include "config031.h"
#include "delay031.h"

// ***********************************************************************
// *** PIO1_8, PIO0_9 functions ***
// ***********************************************************************

// *** PIO1_8 ***

void setPio18Direction(int direction)
{
 /* Set pin to GPIO */
 IOCON_SetPinFunc(IOCON_PIO1_8, PIO1_8_FUN_PIO);

  /* Set pin direction */
 if (direction == OUTPUT_DIRECTION)
  GPIO_SetDir(PORT1, GPIO_Pin_8, 1);
 else
  GPIO_SetDir(PORT1, GPIO_Pin_8, 0);
}

void setPio18OutputHigh()
{
 GPIO_SetBits(PORT1, GPIO_Pin_8);
}

void setPio18OutputLow()
{
 GPIO_ResetBits(PORT1, GPIO_Pin_8);
}

void setPio18Output(int logicLevel)
{
 if (logicLevel == HIGH_LEVEL)
  GPIO_SetBits(PORT1, GPIO_Pin_8);
 else
  GPIO_ResetBits(PORT1, GPIO_Pin_8);
}

// *** PIO0_9 ***

void setPio09Direction(int direction)
{
 /* Set pin to GPIO */
 IOCON_SetPinFunc(IOCON_PIO0_9, PIO0_9_FUN_PIO);

  /* Set pin direction */
 if (direction == OUTPUT_DIRECTION)
  GPIO_SetDir(PORT0, GPIO_Pin_9, 1);
 else
  GPIO_SetDir(PORT0, GPIO_Pin_9, 0);
}

void setPio09OutputHigh()
{
 GPIO_SetBits(PORT0, GPIO_Pin_9);
}

void setPio09OutputLow()
{
 GPIO_ResetBits(PORT0, GPIO_Pin_9);
}

// ***********************************************************************
// *** blink P18, P09 LEDs ***
// ***********************************************************************

void setPio09Output(int logicLevel)
{
 if (logicLevel == HIGH_LEVEL)
  GPIO_SetBits(PORT0, GPIO_Pin_9);
 else
  GPIO_ResetBits(PORT0, GPIO_Pin_9);
}

// ***********************************************************************
// gpio032.h 2013sep22hkt1355
// ***********************************************************************

// ***********************************************************************
// Name   - getGpioStructPointer()
// Input  - port number
// Output - pointer to the struct of the port
// ***********************************************************************

GPIO_TypeDef *getGpioStructPointer(int portNumber)
{
 GPIO_TypeDef *gpioStructPointer;
 gpioStructPointer =  CmsisGpioStructPointerArray[portNumber];
 return gpioStructPointer;
}

// ***********************************************************************
// typedef gpioPortStructPinStruct;
// Description - this struct has 2 members: *GpioStructPointer and pin
//   pin number. This struct is not yet being used.
// ***********************************************************************

typedef struct
{
 GPIO_TypeDef *GpioStructPointer;
 int PinNumber;
} gpioPortStructPinStruct;

// ***********************************************************************
// Name   - getGpioPortStructPinStructPointer() // To be tested
// Input  - port number, pin number
// Output - pointer to gpioPortStructPinStruct
// ***********************************************************************

gpioPortStructPinStruct *getGpioPortStructPinStructPointer(portNumber portNumber, pinNumber pinNumber)
  {
 gpioPortStructPinStruct *gpioPortStructPinStruct;
 gpioPortStructPinStruct->GpioStructPointer = getGpioStructPointer(portNumber);
 gpioPortStructPinStruct->PinNumber = pinNumber;
 return gpioPortStructPinStruct;
  }

// ***********************************************************************
// GPIO functions
// ***********************************************************************

// ***********************************************************************
// Name   - setGpioDataPinInput()
// Input  - gpio_struct_ptr, pin number
// Output - none
// ***********************************************************************

void setGpioDataPinInput(GPIO_TypeDef *gpio_struct_ptr, int pinNumber)
{
 gpio_struct_ptr->DIR  &= ~(1 << pinNumber);
}

// ***********************************************************************
// Name   - setGpioDataPinOutput
// Input  - port control structure, pin number
// Output - set pin as output
// ***********************************************************************

void setGpioDataPinOutput(GPIO_TypeDef *gpio_struct_ptr, int pinNumber)
{
 gpio_struct_ptr->DIR |= (1 << pinNumber);
}

// ***********************************************************************
// Name   - setGpioDataPinLow
// Input  - port control structure, pin number
// Output - none
// ***********************************************************************

void setGpioDataPinLow(GPIO_TypeDef *gpio_struct_ptr, int pinNumber)
{
 gpio_struct_ptr->DATA &= ~(1 << pinNumber);
}

// ***********************************************************************
// Name   - setGpioDataPinHigh
// Input  - port control structure, pin number
// Output - set pin as output
// ***********************************************************************

void setGpioDataPinHigh(GPIO_TypeDef *gpio_struct_ptr, int pinNumber)
{
 gpio_struct_ptr->DATA |= (1 << pinNumber);
}

// ***********************************************************************
// Name   - setGpioDataPinDirection
// Input  - port control structure, pin number, direction value
// Output - set pin as input or output
// ***********************************************************************

void setGpioPinDirection(GPIO_TypeDef *gpio_struct_ptr, int pinNumber, directionValue directionValue)
{
 if (directionValue == INPUT_DIRECTION)
  setGpioDataPinInput(gpio_struct_ptr, pinNumber);
 else
  setGpioDataPinOutput(gpio_struct_ptr, pinNumber);
}

// ***********************************************************************
// Name   - setGpioDataRegister
// Input  - port control structure, pin number, data value
// Output - none
// ***********************************************************************

void setGpioDataPin(GPIO_TypeDef *gpio_struct_ptr, int pinNumber, logicLevelValue logicLevelValue)
{
 if (logicLevelValue == LOGIC_LOW_LEVEL)
  setGpioDataPinLow(gpio_struct_ptr, pinNumber);
 else
  setGpioDataPinHigh(gpio_struct_ptr, pinNumber);
}

// ***********************************************************************
// Function - getGpioDataPinValue
// Input    - GPIO structure pointer, pin number
// Output   - Gpio data pin value
// ***********************************************************************

logicLevelValue getGpioDataPinValue01(GPIO_TypeDef *gpio_struct_ptr, int pinNumber)
{
 logicLevelValue logicLevelValue;

  int GpioDataPinMask = (1 << pinNumber);

  if ((gpio_struct_ptr->DATA  &= GpioDataPinMask) == GpioDataPinMask)
  logicLevelValue = HIGH;
 else
  logicLevelValue = LOW;

  return logicLevelValue;
}

logicLevelValue getGpioDataPinValue(portPinArrayPointerArray inputPortPinArrayPointerArray, int pinNumber)
{
 int portNumber;
 GPIO_TypeDef *gpioStructPointer;
 logicLevelValue logicLevelValue;

  portNumber = getPortNumber01(inputPortPinArrayPointerArray, pinNumber);
 gpioStructPointer = getGpioStructPointer(portNumber);
 pinNumber = getPinNumber01(inputPortPinArrayPointerArray, pinNumber);

  logicLevelValue = getGpioDataPinValue01(gpioStructPointer, pinNumber);

  return logicLevelValue;
}

// ***********************************************************************
// Name   - get port number of portPinArray
// Input  - port pin array
// Output - portNumber
// ***********************************************************************

portNumber getPortNumber(portPinArray portPinArray)
{
 int portNumber;
 portNumber = portPinArray[PORT_INDEX];
 return portNumber;
}

// ***********************************************************************
// Name   - get port number from portPinArrayPointerArray
// Input  - portPinPointerArray, deviceNumber
// Output - portNumber
// ***********************************************************************

portNumber getPortNumber01(portPinArrayPointerArray portPinArrayPointerArray, deviceNumber deviceNumber)
{
 int portNumber;
 portNumber = getPortNumber(*portPinArrayPointerArray[deviceNumber - 1]);
 return portNumber;
}

// ***********************************************************************
// Name   - get pin number of portPinArray
// Input  - port pin array
// Output - pinNumber
// ***********************************************************************

pinNumber getPinNumber(portPinArray portPinArray)
{
 int pinNumber;
 pinNumber = portPinArray[PIN_INDEX];
 return pinNumber;
}

// ***********************************************************************
// Name   - get pin number from portPinArrayPointerArray and index
// Input  - portPinPointerArray, index
// Output - pinNumber
// ***********************************************************************

pinNumber getPinNumber01(portPinArrayPointerArray portPinArrayPointerArray, deviceNumber deviceNumber)
{
 int pinNumber;
 pinNumber = getPinNumber(*portPinArrayPointerArray[deviceNumber - 1]);
 return pinNumber;
}

// ***********************************************************************
// Name   - initialize one output pin
// Input  - outputPortPinPointerArray, index
// Output - none
// ***********************************************************************

void initializeOneOutputPin(portPinArrayPointerArray outputPortPinArrayPointerArray, deviceNumber deviceNumber)
{
 int portNumber;
 int pinNumber;
 GPIO_TypeDef *gpioStructPointer;

  portNumber = getPortNumber01(outputPortPinArrayPointerArray, deviceNumber);
 gpioStructPointer = getGpioStructPointer(portNumber);
 pinNumber = getPinNumber01(outputPortPinArrayPointerArray, deviceNumber);

  setGpioDataPinOutput(gpioStructPointer, pinNumber);
 setGpioDataPinLow (gpioStructPointer, pinNumber);
  }

// ***********************************************************************
// Function - initialize all output port pins
// Input    - outputPortPinArrayPointerArray
// Output   - none
// ***********************************************************************

void initializeAllOutputPins(portPinArrayPointerArray outputPortPinArrayPointerArray, int maxPinNumber)
{
  int pinNumber;

  for (pinNumber = 1; pinNumber < (maxPinNumber + 1); pinNumber++)
  {
   initializeOneOutputPin(outputPortPinArrayPointerArray, pinNumber);
  }
}

// ***********************************************************************
// Name   - initialize one input pin
// Input  - outputPortPinPointerArray, index
// Output - none
// ***********************************************************************

void initializeOneInputPin(portPinArrayPointerArray outputPortPinArrayPointerArray, \
  deviceNumber deviceNumber)
{
 int portNumber;
 int pinNumber;
 GPIO_TypeDef *gpioStructPointer;

  portNumber = getPortNumber01(outputPortPinArrayPointerArray, deviceNumber);
 gpioStructPointer = getGpioStructPointer(portNumber);
 pinNumber = getPinNumber01(outputPortPinArrayPointerArray, deviceNumber);

  setGpioDataPinInput(gpioStructPointer, pinNumber);
  }

// ***********************************************************************
// Function - initialize all input port pins
// Input    - outputPortPinArrayPointerArray
// Output   - none
// ***********************************************************************

void initializeAllInputPins(portPinArrayPointerArray inputPortPinArrayPointerArray, int maxPinNumber)
{
  int pinNumber;

  for (pinNumber = 1; pinNumber < (maxPinNumber + 1); pinNumber++)
  {
   initializeOneInputPin(inputPortPinArrayPointerArray, pinNumber);
  }
}

#endif /* GPIO033_HEADER_SEEN */

// ***********************************************************************
// End
// ***********************************************************************



// ***********************************************************************
// led031.h 2013sep22hkt1140
// ***********************************************************************

#include "config031.h"
#include "delay031.h"
#include "gpio033.h"

void blinkLedP18(int onTime, int offTime, int repeatCount)
{
setPio18Direction(OUTPUT_DIRECTION);
setPio18Output(LOW_LEVEL);

int i;
for (i = 0; i < repeatCount; i++)
{
setPio18Output(HIGH_LEVEL);
delayTime(onTime);

setPio18Output(LOW_LEVEL);
delayTime(offTime);
}
}

void blinkLedP09(int onTime, int offTime, int repeatCount)
{
setPio09Direction(OUTPUT_DIRECTION);
setPio09Output(LOW_LEVEL);

int i;
for (i = 0; i < repeatCount; i++)
{
setPio09Output(HIGH_LEVEL);
delayTime(onTime);

setPio09Output(LOW_LEVEL);
delayTime(offTime);
}
}

// ***********************************************************************
// ***********************************************************************
// Function - Single LED
// ***********************************************************************
// ***********************************************************************

void setGpioDataPinHigh01(portPinArray *portPinArrayPointer)
{
 pinNumber pinNumber;
 portNumber portNumber;
 GPIO_TypeDef *gpioStructPointer;

  pinNumber = getPinNumber(portPinArrayPointer);
 portNumber = getPortNumber(portPinArrayPointer);
 gpioStructPointer = getGpioStructPointer(portNumber);
 setGpioDataPinHigh(gpioStructPointer, pinNumber);
}

void setGpioDataPinLow01(portPinArray *portPinArrayPointer)
{
 pinNumber pinNumber;
 portNumber portNumber;
 GPIO_TypeDef *gpioStructPointer;

  pinNumber = getPinNumber(portPinArrayPointer);
 portNumber = getPortNumber(portPinArrayPointer);
 gpioStructPointer = getGpioStructPointer(portNumber);
 setGpioDataPinLow(gpioStructPointer, pinNumber);
}

// ***********************************************************************
// Function - Blink 1 LED
// Input    - PortPinArrayPointerArray, device number, on time, off time,
//            blink repetition times
// Output   - none
// ***********************************************************************

void blink1Led01(portPinArrayPointerArray portPinArrayPointerArray, \
  deviceNumber ledNumber, int onTime, int offTime, int blinkCount)
{
 int count = 0;
 portPinArray *portPinArrayPointer;

  portPinArrayPointer = portPinArrayPointerArray[ledNumber - 1];

   for (count = 0; count < blinkCount; count++)
   {
    setGpioDataPinHigh01(portPinArrayPointer);
    delayTenthSecond(onTime);
    setGpioDataPinLow01(portPinArrayPointer);
    delayTenthSecond(offTime);
   }
}

void blink1Led(int ledNumber)
{
 blink1Led01(WhutBoardLedPortPinArrayPointerArray, ledNumber, \
   ON_ONE_FIFTH_SECOND, OFF_ONE_FIFTH_SECOND, REPEAT_2_TIMES );
}

// ***********************************************************************
// Function - Blink all LEDs
// Input    - PortPinArrayPointerArray, device number, on time, off time,
//            blink repetition times
// Output   - none
// ***********************************************************************

void blinkAllLeds(int onTime, int offTime, int repeatCount)
{
 int ledNumber;

  // initializeAllOutputPins(WhutBoardLedPortPinArrayPointerArray, MAX_LED_NUMBER);

    for (ledNumber = 1; ledNumber < (MAX_LED_NUMBER + 1); ledNumber++ )
    {
     blink1Led01(WhutBoardLedPortPinArrayPointerArray, ledNumber, \
       onTime, offTime, repeatCount);
    }
}

// ***********************************************************************
// ***********************************************************************
// Function - Seven Segment LED
// ***********************************************************************
// ***********************************************************************

void sendGoingPositivePulse(portPinArray *portPinArrayPointer)
{
 setGpioDataPinHigh01(portPinArrayPointer);
 setGpioDataPinLow01(portPinArrayPointer);
}

void loadSevenSegmentDataBits(portPinArray *portPinArrayPointerData, \
  portPinArray *portPinArrayPointerClock, int alphaNumbericCharacter)
{
 int segmentNumber;
 int segmentBit;
 int segmentByte, segmentByte1;

 int Segment0 = 0b11111100;
 int Segment1 = 0b01100000;
 int Segment2 = 0b11011010;
 int Segment3 = 0b11110010;
 int Segment4 = 0b01100110;
 int Segment5 = 0b10110110;
 int Segment6 = 0b10111110;
 int Segment7 = 0b11100000;
 int Segment8 = 0b11111110;
 int Segment9 = 0b11110110;

 int AllBlank = 0b00000000;

  int SegmentArray[] = {Segment0, Segment1, Segment2, Segment3, Segment4, \
                 Segment5, Segment6, Segment7, Segment8, Segment9, AllBlank};

  segmentByte = SegmentArray[alphaNumbericCharacter];

    for (segmentNumber = 0; segmentNumber < 8; segmentNumber++)
    {
     segmentByte1 = segmentByte | (1 << segmentNumber);
     if (segmentByte1 == segmentByte)
        setGpioDataPinHigh01(portPinArrayPointerData);
     else
      setGpioDataPinLow01(portPinArrayPointerData);

        sendGoingPositivePulse(portPinArrayPointerClock);
    }
}

void display1Digit01(portPinArrayPointerArray sevenSegmentPortPinArrayPointerArray, \
  int digitNumber)
{
 portPinArray *portPinArrayPointerClock;
 portPinArray *portPinArrayPointerData;
 portPinArray *portPinArrayPointerLatch;

  portPinArrayPointerClock = sevenSegmentPortPinArrayPointerArray[SCLK_INDEX];
 portPinArrayPointerData  = sevenSegmentPortPinArrayPointerArray[DIN_INDEX];
 portPinArrayPointerLatch = sevenSegmentPortPinArrayPointerArray[LATCH_INDEX];

  setGpioDataPinLow01(portPinArrayPointerLatch);

  setGpioDataPinLow01(portPinArrayPointerClock);

  loadSevenSegmentDataBits(portPinArrayPointerData, portPinArrayPointerClock, digitNumber);

  setGpioDataPinHigh01(portPinArrayPointerLatch);
}

void display1Digit(int digitNumber)
{
display1Digit01(WhutBoardSevenSegmentLedPortPinArrayPointerArray, digitNumber);
}

void displayAllBlank()
{
     display1Digit(10);
}

void blinkDigit(int digitNumber, int onTime, int offTime, int repeatCount)
{
int count;

for (count = 0; count < repeatCount; count++)
   {
displayAllBlank();
delayTenthSecond(offTime);
display1Digit(digitNumber);
delayTenthSecond(onTime);
   }
}

// ***********************************************************************
// Function - Display all digits
// ***********************************************************************

void displayAllDigits()
{
 int digitNumber;

 for (digitNumber = 0; digitNumber < 10; digitNumber++)
    {
display1Digit(digitNumber);
delayTime(ONE_HALF_SECOND);
    }
}

// ***********************************************************************
// End
// ***********************************************************************



// ***********************************************************************
// key033.h 2013sep22hkt1939
// ***********************************************************************

#include "config031.h"
#include "delay031.h"
#include "gpio033.h"

// ***********************************************************************
// Key functions
// ***********************************************************************

logicLevelValue getKeyStatus();
void echo1Key01();
void echo1Key();
void testEchoThreeKeys();

// ***********************************************************************
// Function - getKeyStatus
// Input    - keyPortPinArrayPointerArray, keyNumber
// Output   - port pin data bit
// ***********************************************************************

logicLevelValue getKeyStatus(portPinArrayPointerArray keyPortPinArrayPointerArray, \
  deviceNumber keyNumber)
{
 logicLevelValue keyStatus;
 int portNumber;
 int pinNumber;
 GPIO_TypeDef *gpio_struct_ptr;

  keyStatus = getGpioDataPinValue(keyPortPinArrayPointerArray, keyNumber);

  return keyStatus;
}

// ***********************************************************************
// Function - echo key by LED
// Input    - keyPinPortArrayPointerArray, keyNumber, ledPinPortArrayPointerArray, ledNumber
// Output   - none
// ***********************************************************************

// *** Echo key by single LED ***

void echo1KeyBySingleLed01(portPinArrayPointerArray keyPortPinArrayPointerArray, \
  deviceNumber keyNumber, \
  portPinArrayPointerArray ledPortPinArrayPointerArray, \
  deviceNumber ledNumber, int echoCount)
{
 int count;
 logicLevelValue keyStatus;

  for (count = 0; count < echoCount; count++)
 {
  delayTime(ONE_SECOND);

   keyStatus = HIGH;
  while (keyStatus == HIGH)
  {
   keyStatus = getKeyStatus(keyPortPinArrayPointerArray, keyNumber);

    if (keyStatus == LOW)
   {
    blink1Led(ledNumber);
    delayTime(TWO_SECONDS);
    keyStatus = HIGH;
    break;
   }
  }
 }
}

void echo1KeyBySingleLed(deviceNumber keyNumber, int ledNumber, int repeatCount)
{
 echo1KeyBySingleLed01(*WhutBoardKeyPortPinArrayPointerArray, keyNumber, \
    *WhutBoardLedPortPinArrayPointerArray, ledNumber, \
    repeatCount);
}


// *** Echo key by 7 segment LED ***

void echo1KeyBy7SegmentLed01(portPinArrayPointerArray keyPortPinArrayPointerArray, \
  deviceNumber keyNumber, \
  portPinArrayPointerArray sevenSegmentledPortPinArrayPointerArray, \
  int digitNumber, int echoCount)
{
 int count;
 logicLevelValue keyStatus;

  for (count = 0; count < echoCount; count++)
 {
  delayTime(ONE_SECOND);

   keyStatus = HIGH;
  while (keyStatus == HIGH)
  {
   keyStatus = getKeyStatus(keyPortPinArrayPointerArray, keyNumber);

    if (keyStatus == LOW)
   {
    // blink1Led(ledNumber);
    display1Digit(digitNumber);
    delayTime(TWO_SECONDS);
    keyStatus = HIGH;
    break;
   }
  }
 }
}

void echo1KeyBy7SegmentLed(deviceNumber keyNumber, int digitNumber, int repeatCount)
{
 echo1KeyBy7SegmentLed01(*WhutBoardKeyPortPinArrayPointerArray, keyNumber, \
    *WhutBoardSevenSegmentLedPortPinArrayPointerArray, digitNumber, \
    repeatCount);
}


// ***********************************************************************
// End
// ***********************************************************************

Android Elektorcardioscope - Elektor

Android Elektorcardioscope - Elektor 4 September 2013

http://www.elektor.com/news/android-elektorcardioscope-now-available.2554671.lynkx?referer=rss

Beginning in our July/August double sized edition of Elektor, we published the first of our three part project on building an electrocardioscope that uses an Android tablet or smartphone as a wireless terminal for viewing the electrocardiograms. The project involves skillfully combining a small PIC interface to control an analog input stage with a great deal of software.

Making use of technology first invented by Willem Einthoven, we’ve developed an application that’s instructive, fascinating and potentially useful to everyone. Traditionally, electrocardioscopes are cumbersome, frail machines energized from conventional AC power outlets. Being able to perform your own electrocardiograms allows you to monitor the mechanical function (and possible dysfunctions) of a heart. An excellent tool for anyone interested in monitoring their personal health or developing a greater understanding of human biology or cardiology.

In anticipation for the final installment of this project, we’ve released an ECG interface in the form of a ready-to-use module which only requires the addition of four electrodes and an Android application (for smartphone or tablet). As it uses Bluetooth communication, there’s no physical connection between this terminal and its interface.

Technical Specifications:

‧ Interface for Android phones or tablets with Bluetooth

‧ Simultaneous or individual scrolling display of the three standard leads (DI, DII, and DIII) and the three enhanced leads (aVR, aVL, and aVF)

‧ Adapts automatically to screen resolution

‧ Measures and displays cardiac rhythm

‧ Audible heartbeat indication

‧ Scrolling speeds: 250/125/62.5 and 31.25 pixels per second

‧ Display gain: ×1 ×1.2 ×1.5 ×2 ×3 and ×10

‧ Full-scale sensitivity: 3.2 mV. 10-bit conversion

‧ Sampling frequency: 2 kHz

‧ Common-mode rejection: > 100 dB

‧ Max. contact voltage: ± 150 mV

‧ Auto-adaptive alignment time constant

‧ Frequency response: 0.005 Hz to 170 Hz

‧ Dynamic trace memory: 10 minutes

‧ ECG recording in flash memory (10 min)

‧ Periodic injection of 1 mV/2 Hz calibration signal

‧ Powered by 2 no. 1.5 V primary or 1.2 V rechargeable cells

‧ Constant display of battery voltage

‧ Current consumption: 50 mA (standby: <4 μA)

‧ Battery life: 15 hours (1 Ah cells)

...

Android ElektorCardioscope (1) Wireless, button-free: Bluetooth & touch screen Published in issue 439, July/August 2013

http://www.elektor.com/magazines/2013/july-047-august/android-elektorcardioscope-(1).2494375.lynkx

The title says it all—this article describes an electrocardioscope you can build yourself, using an Android tablet or smartphone as a wireless terminal for viewing the electrocardiograms. The project involves skillfully combining a small PIC interface to control an analog input stage with a great deal of software.

...


Android Elektorcardioscope (2) Wireless, button-free: Bluetooth & touch screen Published in issue 441, September 2013

http://www.elektor.com/magazines/2013/september/android-elektorcardioscope-(2).2538209.lynkx

Following on from the description of the hardware for our new ECG interface on tablets or Android smartphones in the July & August 2013 double edition, we're coming back now to the PIC functions and how the program runs, before looking at the Android application. Without going into too much detail though—we’re just going to say enough about this to encourage readers to get hold of the code and have a go at development under Android.

...

Android Elektorcardioscope (120107-91) Ready assembled board

http://www.elektor.com/products/kits-modules/modules-(-91)/120107-91-android-elektorcardioscope.2494031.lynkx

This article describes an electrocardioscope you can build yourself, using an Android tablet or smartphone as a wireless terminal for viewing the electrocardiograms. The project involves skillfully combining a small PIC interface to control an analog input stage with a great deal of software.

Our ECG interface is available in the form of a ready-to-use module to which you just have to add four electrodes and an Android application for smartphone or tablet; there’s no physical connection between this terminal and the interface, as it uses Bluetooth communication! As you’d expect for a modern device, this one has only very few adjustments (three presets in all) or controls (3 buttons). Clearly, it’s the software that does all the work.

Technical Specifications:

...

Elektor / 120107-91

Price : 97.84 EUR 

Specifications : Height : 58.420 Width : 101.850  Published on : July 2013


.END


Mobile diagnostics by smartphone and image analysis for detecting antibiotic resistance - Sep 19, 2013 Source: Fraunhofer

http://www.research-in-germany.de/dachportal/en/Infoservice/News/2013/09/2013-09-19-mobile-diagnostics.html

Fraunhofer FIT demonstrates a mobile wireless system that monitors the health of elderly people in their own homes, using miniature sensors, and also a novel optical system for detecting antibiotic resistance, which can determine in just two hours if bacteria react to a specific antibiotic.

At BIOTECHNICA 2013, Fraunhofer FIT demonstrates the first system that integrates three different sensors in one platform. A nano potentiostat measures biochemical information in a patient's assay, e.g. glucose, lactate or cholesterol levels. A fluorescence sensor is used to detect color-marked biomarkers. A SpO2 sensor monitors heart rate and arterial oxygen saturation. A smartphone app processes the data from the three sensors and transfers them to a server. For secure data communication, a Bluetooth connection with a specifically developed protocol is used.

"Our aim was to integrate, in one mobile device, several miniature sensors that measure relevant diagnostic parameters and communicate their data wirelessly", says Professor Harald Mathis, head of the department 'Biomolecular Optical Systems' of the Fraunhofer Institute for Applied Information Technology FIT. As devices that measure biometrical data do not use standardized protocols, we developed a sensor platform that takes the data from the different sensors, processes them and sends them to a smartphone. The smartphone can then transmit the data to the patient's physician.

The system was developed by Fraunhofer FIT in cooperation with Charité and T-Systems Deutschland in the BMBF/EU-funded project Nanoelectronics for Mobile AAL Systems – MAS.

Fraunhofer FIT's second exhibit is an image analysis system for bacteria diagnostics. Antibiotic resistance is a growing threat to our health. Many antibiotics are losing their effectiveness. Unfortunately, there are no universal flash tests for antibiotic resistance. FIT's new system uses an optical process that can determine in just about two hours if bacteria react to a specific antibiotic.

.END