Nikon D70 Remote Control with a Button and EEPROM
A remote control which can only generate a signal when initially powered up is of limited use. The addition of a switch will allow the user to determine when the camera is triggered.
Adding a Button
The initial versions of the infra-red remote control for the Nikon D70 which have been discussed so far are limited in that the control sequence is transmitted when the STM8S starts and never again until the next time the STM8S is restarted/reset. Adding a button to the remote control will allow the user to select when the control sequence is transmitted.
One of the main problems with switches is that they are subject to switch bounce. You can see an example of this in the post regarding External Interrupts on the STM8S. There are two approaches to switch debouncing, software and hardware. The button on the infra-red remote control will be triggering a sequence of pulses which will typically last several milliseconds. This means that it lends itself to software debouncing using a simple state machine.
The state machine will put the infra-red remote control into two states, waiting for user input and running. When waiting for user input the interrupt handler for the switch will accept user input. When in the running mode the system will be generating the infra-red output for the camera and it will ignore any input from the switch. At the end of the infra-red sequence the switch input will be re-enabled.
So much for the theory, lets have a look at the code. The first thing which the application will need to do is to setup the appropriate pin as an interrupt port:
//--------------------------------------------------------------------------------
//
// Now set up the ports.
//
// PD3 - IR Pulse signal.
// PD4 - Input pin indicating that the user wishes to trigger the camera.
//
void SetupPorts()
{
PD_ODR = 0; // All pins are turned off.
//
// PD3 is the output for the IR control.
//
PD_DDR_DDR3 = 1;
PD_CR1_C13 = 1;
PD_CR2_C23 = 1;
//
// Now configure the input pin.
//
PD_DDR_DDR4 = 0; // PD4 is input.
PD_CR1_C14 = 1; // PD4 is floating input.
PD_CR2_C24 = 1;
//
// Set up the interrupt.
//
EXTI_CR1_PDIS = 1; // Interrupt on rising edge.
EXTI_CR2_TLIS = 1; // Rising edge only.
}
The modifications to the SetupPorts method keeps the infra-red output on PD3 but adds an input on PD4 with a rising edge interrupt.
The next step is to deal with the interrupt on PD4. Here we need to work out if we are waiting for an interrupt and if we are then the application needs to start the generation of the infra-red signal. If we are not waiting for a button press then we should ignore the user request as it is likely to be a result of switch bounce. The code starts to look like this:
//--------------------------------------------------------------------------------
//
// Process the interrupt generated by the pressing of the button.
//
// This ISR makes the assumption that we only have on incoming interrupt on Port D.
//
#pragma vector = 8
__interrupt void EXTI_PORTD_IRQHandler(void)
{
if (_currentState != STATE_RUNNING)
{
//
// Set everything up ready for the timers.
//
// TODO!
//
// Now we have everything ready we need to force the Timer 2 counters to
// reload and enable Timers 1 & 2.
//
TIM2_CR1_URS = 1;
TIM2_EGR_UG = 1;
TIM1_CR1_CEN = 1;
TIM2_CR1_CEN = 1;
}
}
The exact code required for setting up the timer will be revealed following the EEPROM section of this post.
Using EEPROM
In the post Storing Data in the EEPROM on the STM8S we saw how we could save data into the EEPROM of the STM8S for later retrieval. The data used in the example should look familiar if you have been following this series on the Nikon D70 Remote Control as it is the timing and signal data which triggers the Nikon D70.
The first thing we should do is to modify the order in which the data is written into the EEPROM. In the above post, the timing data is written into the EEPROM low byte followed by high byte. By swapping the order we can store the data in the order required by the interrupt for Timer 2. So the first task is to modify the application which wrote and verified the timing information to the following:
//
// Write a series of bytes to the EEPROM of the STM8S105C6 and then
// verify that the data has been written correctly.
//
// This software is provided under the CC BY-SA 3.0 licence. A
// copy of this licence can be found at:
//
// http://creativecommons.org/licenses/by-sa/3.0/legalcode
//
#if defined DISCOVERY
#include <iostm8S105c6.h>
#else
#include <iostm8s103f3.h>
#endif
//
// Data to write into the EEPROM.
//
unsigned int _pulseLength[] = { 2000U, 27830U, 400U, 1580U, 400U, 3580U, 400U };
unsigned char _onOrOff[] = { 1, 0, 1, 0, 1, 0, 1 };
char numberOfValues = 7;
//--------------------------------------------------------------------------------
//
// Write the default values into EEPROM.
//
void SetDefaultValues()
{
//
// Check if the EEPROM is write-protected. If it is then unlock the EEPROM.
//
if (FLASH_IAPSR_DUL == 0)
{
FLASH_DUKR = 0xae;
FLASH_DUKR = 0x56;
}
//
// Write the data to the EEPROM.
//
char *address = (char *) 0x4000; // EEPROM base address.
*address++ = (char) numberOfValues;
for (int index = 0; index < numberOfValues; index++)
{
*address++ = (char) ((_pulseLength[index] >> 8) & 0xff);
*address++ = (char) (_pulseLength[index] & 0xff);
*address++ = _onOrOff[index];
}
//
// Now write protect the EEPROM.
//
FLASH_IAPSR_DUL = 0;
}
//--------------------------------------------------------------------------------
//
// Verify that the data in the EEPROM is the same as the data we
// wrote originally.
//
void VerifyEEPROMData()
{
PD_ODR_ODR2 = 1; // Checking the data
PD_ODR_ODR3 = 0; // No errors.
//
char *address = (char *) 0x4000; // EEPROM base address.
if (*address++ != numberOfValues)
{
PD_ODR_ODR3 = 1;
}
else
{
for (int index = 0; index < numberOfValues; index++)
{
unsigned int value = (*address++ << 8);
value += *address++;
if (value != _pulseLength[index])
{
PD_ODR_ODR3 = 1;
}
if (*address++ != _onOrOff[index])
{
PD_ODR_ODR3 = 1;
}
}
}
PD_ODR_ODR2 = 0; // Finished processing.
}
//--------------------------------------------------------------------------------
//
// Setup port D for data output.
//
void SetupPorts()
{
//
// Initialise Port D.
//
PD_ODR = 0; // All pins are turned off.
PD_DDR = 0xff; // All bits are output.
PD_CR1 = 0xff; // All pins are Push-Pull mode.
PD_CR2 = 0xff; // Pins can run up to 10 MHz.
}
//--------------------------------------------------------------------------------
//
// Main program loop.
//
void main()
{
SetupPorts();
SetDefaultValues();
VerifyEEPROMData();
}
Create a new project for the above and execute the program on the STM8S Discovery board. This should set up the timing data ready for use to use.
Using the EEPROM Data
The above application has been tailored to write the byte data into the EEPROM in the order in which the bytes are required by the remote control application. Using this data should be a simple case of setting a pointer to the first byte and then consuming the bytes one after another. To do this we will need some pointers and a counter:
//
// Define where we will be working in the EEPROM.
//
#define EEPROM_BASE_ADDRESS 0x4000
#define EEPROM_INITIAL_OFFSET 0x0000
#define EEPROM_DATA_START (EEPROM_BASE_ADDRESS + EEPROM_INITIAL_OFFSET)
//
// Data ready for the pulse timer ISR's to use.
//
int _numberOfPulses = 0;
int _currentPulse = 0;
char *_pulseDataAddress = NULL;
As part of the initialisation process we will need to set the pointer and also the number of pulses we have data for:
_pulseDataAddress = (char *) EEPROM_DATA_START;
_numberOfPulses = *_pulseDataAddress++;
So now we should have the initial state configured and we should revisited the button handler method. This method kicks off the timers by consuming the first three bytes of data:
//--------------------------------------------------------------------------------
//
// Process the interrupt generated by the pressing of the button.
//
// This ISR makes the assumption that we only have on incoming interrupt on Port D.
//
#pragma vector = 8
__interrupt void EXTI_PORTD_IRQHandler(void)
{
if (_currentState != STATE_RUNNING)
{
//
// Set everything up ready for the timers.
//
_currentState = STATE_RUNNING;
_currentPulse = 0;
_pulseDataAddress = (char *) (EEPROM_DATA_START + 1);
TIM2_ARRH = *_pulseDataAddress++;
TIM2_ARRL = *_pulseDataAddress++;
PD_ODR_ODR3 = *_pulseDataAddress++;
//
// Now we have everything ready we need to force the Timer 2 counters to
// reload and enable Timers 1 & 2.
//
TIM2_CR1_URS = 1;
TIM2_EGR_UG = 1;
TIM1_CR1_CEN = 1;
TIM2_CR1_CEN = 1;
}
}
Finally, the interrupt for the Timer 2 interrupt needs to be modified in order to continue to process the data three bytes at a time until we have reached the total number of pulses:
//--------------------------------------------------------------------------------
//
// Timer 2 Overflow handler.
//
#pragma vector = TIM2_OVR_UIF_vector
__interrupt void TIM2_UPD_OVF_IRQHandler(void)
{
_currentPulse++;
if (_currentPulse == _numberOfPulses)
{
//
// We have processed the pulse data so stop now.
//
PD_ODR_ODR3 = 0;
TIM2_CR1_CEN = 0;
TIM1_CR1_CEN = 0; // Stop Timer 1.
_currentState = STATE_WAITING_FOR_USER;
}
else
{
TIM2_ARRH = *_pulseDataAddress++;
TIM2_ARRL = *_pulseDataAddress++;
PD_ODR_ODR3 = *_pulseDataAddress++;
TIM2_CR1_URS = 1;
TIM2_EGR_UG = 1;
}
TIM2_SR1_UIF = 0; // Reset the interrupt otherwise it will fire again straight away.
}
Conclusion
The addition of the button certainly makes the remote control more usable as the user can elect when to trigger the camera. At this stage, the EEPROM does not offer too many advantages over the use of the static data but it can allow the remote control to be fine-tuned at a later stage.
The acid test, does it still trigger the camera – Yes it does.
Tags: Electronics, Software Development, STM8
Thursday, September 12th, 2013 at 8:14 pm • Electronics, Software Development, STM8 • RSS 2.0 feed Both comments and pings are currently closed.
