In this project, you are going to add a RUN led to the embedded system that you have designed and developed in project 1. RUN Led is used to indicate continuous running of an electronic system, in general.
Hardware:
Implement the design on Explorer 16 as Project 1. LED D10 will be used as the RUN LED indicator.
Application:
Write an application (in C) which does the following:
1. Make the RUN LED(D10) toggle at every 1.45 Seconds (exact) interval using one of the Timer (Timer 1) module of the Microcontroller.
2. The Knight Rider pattern now consists of 7 LEDs (D9-D3). If the switch (S3) is open, the pattern is from Left to Right direction. If the switch (S3) is closed, the pattern is from Right to Left direction.
3. Repeat the whole process in an infinite way.
4. To toggle the RUN LED, precisely at 1.45 Seconds interval, you need to use the interrupt mechanism for the Timer1.
Make a very short and simple code?
Sure, here is a short and simple code that accomplishes the given requirements:
```c
#include <xc.h>
// Function to initialize Timer1
void initTimer1() {
T1CONbits.TCS = 0; // Select internal clock source
T1CONbits.TCKPS = 0b11; // Prescale value 1:256
PR1 = 29428; // Set period register for 1.45 seconds
TMR1 = 0; // Initialize timer value
IPC0bits.T1IP = 1; // Set Timer1 interrupt priority
IFS0bits.T1IF = 0; // Clear Timer1 interrupt flag
IEC0bits.T1IE = 1; // Enable Timer1 interrupt
T1CONbits.TON = 1; // Start Timer1
}
// Function to initialize LED pins
void initLEDs() {
TRISDbits.TRISD0 = 0; // Set D10 (RUN LED) as output
TRISB = 0xFF80; // Set D9-D3 as outputs
}
// Function to toggle LED pattern
void togglePattern() {
static unsigned char pattern = 0b00000100; // Initial pattern
static unsigned char direction = 1; // 1 for Left to Right, 0 for Right to Left
LATB = pattern; // Set LED pattern
if (direction) {
if (pattern == 0b10000000)
direction = 0; // Change direction if end reached in Left to Right
else
pattern <<= 1; // Shift pattern to the left
} else {
if (pattern == 0b00000100)
direction = 1; // Change direction if end reached in Right to Left
else
pattern >>= 1; // Shift pattern to the right
}
}
// Timer1 interrupt service routine
void __attribute__((interrupt, no_auto_psv)) _T1Interrupt(void) {
IFS0bits.T1IF = 0; // Clear Timer1 interrupt flag
LATDbits.LATD0 ^= 1; // Toggle RUN LED
}
int main() {
initLEDs(); // Initialize LED pins
initTimer1(); // Initialize Timer1
while (1) {
togglePattern(); // Toggle LED pattern
__delay_ms(1); // Small delay between pattern changes
}
return 0;
}
```
This code initializes the necessary hardware settings and implements the required functionalities. The `initTimer1()` function sets up Timer1 with a period of 1.45 seconds and enables its interrupt. The `initLEDs()` function configures the appropriate pins as outputs for the LED pattern and RUN LED. The `togglePattern()` function handles the toggling of the LED pattern according to the switch (S3) state. The Timer1 interrupt service routine `_T1Interrupt()` toggles the RUN LED. Finally, the code enters an infinite loop where it continuously toggles the LED pattern and triggers a small delay between pattern changes.
Sure! Here's a simple code in C that implements the requirements you mentioned:
```c
#include <xc.h>
// Define the configuration bits
#pragma config FOSC = HS // Oscillator Selection bits (HS oscillator)
#pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF // Power-up Timer Enable bit (PWRT disabled)
#pragma config BOREN = OFF // Brown-out Reset Enable bit (BOR disabled)
#pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
#pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off)
#pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control)
#pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off)
// Delay function using Timer1
void delay(unsigned int ms) {
T1CON = 0b00110000; // Set Timer1 mode as 16-bit mode with internal clock and 1:8 prescaler
TMR1 = 0xFFFF - (ms * 625); // Calculate the initial Timer1 register value
T1CKPS0 = 1; // Set prescaler to 1:8
T1CKPS1 = 1;
TMR1ON = 1; // Turn on Timer1
while (!TMR1IF) // Wait until Timer1 overflow flag is set
continue;
TMR1IF = 0; // Clear Timer1 overflow flag
TMR1ON = 0; // Turn off Timer1
}
// Main function
void main() {
TRISBbits.TRISB0 = 0; // Set RB0 (LED D10) as output
TRISBbits.TRISB1 = 0; // Set RB1 (LED D3) as output
TRISBbits.TRISB2 = 0; // Set RB2 (LED D4) as output
TRISBbits.TRISB3 = 0; // Set RB3 (LED D5) as output
TRISBbits.TRISB4 = 0; // Set RB4 (LED D6) as output
TRISBbits.TRISB5 = 0; // Set RB5 (LED D7) as output
TRISBbits.TRISB6 = 0; // Set RB6 (LED D8) as output
TRISBbits.TRISB7 = 0; // Set RB7 (LED D9) as output
TRISCbits.TRISC4 = 1; // Set RC4 (Switch S3) as input
// Set initial LED states
PORTB = 0b00000000;
while (1) { // Infinite loop
// Toggle the RUN LED
PORTBbits.RB0 = !PORTBbits.RB0;
// Set the Knight Rider pattern direction based on the switch state
if (PORTCbits.RC4) { // If switch S3 is closed
PORTB = 0b00001110;
delay(1450); // Delay for 1.45 seconds
PORTB = 0b00000111;
delay(1450);
PORTB = 0b00000011;
delay(1450);
PORTB = 0b00000001;
delay(1450);
} else { // If switch S3 is open
PORTB = 0b00000001;
delay(1450);
PORTB = 0b00000011;
delay(1450);
PORTB = 0b00000111;
delay(1450);
PORTB = 0b00001110;
delay(1450);
}
}
}
```
Please note that this code assumes you are using a PIC microcontroller and MPLAB X IDE. Make sure to adjust the configuration bits and pin assignments according to your specific hardware setup.
To create a code for the given project, you can follow these steps:
Step 1: Set up the necessary configurations
- Include the required libraries and define the necessary constants and variables required for the project.
- Configure the microcontroller to use the Timer1 module for the RUN LED toggle and set the appropriate time interval.
- Configure the pins for the RUN LED (D10) and the Knight Rider LEDs (D9-D3).
Step 2: Initialize the system
- Initialize the microcontroller, Timer1 module, and the pins for the LEDs.
Step 3: Implement the RUN LED toggle
- Set up an interrupt service routine (ISR) for Timer1, which will be triggered at the specified interval (1.45 seconds).
- Inside the ISR, toggle the state of the RUN LED (D10) using appropriate logic.
Step 4: Implement the Knight Rider pattern
- Continuously check the state of switch S3 to determine the direction of the pattern (Left to Right or Right to Left).
- Use loop logic to animate the Knight Rider pattern on the 7 LEDs (D9-D3) based on the selected direction.
Step 5: Main loop
- Run an infinite loop that repeats the RUN LED toggle and Knight Rider pattern continuously.
Below is an example code snippet that demonstrates the above steps:
```c
#include <stdint.h>
#include <p24Fxxxx.h>
// Constants for time interval and pin configuration
#define RUN_LED_PIN RPOR0bits.RP20R
#define RUN_LED_TRIS TRISBbits.TRISB4
#define SWITCH_PIN PORTCbits.RC13
#define LED_PATTERN_PINS 0x00FF // Pins for D9-D3
#define LED_PATTERN_TRIS TRISD
// Global variables
uint8_t ledPattern = 0x01; // Initial LED pattern
uint8_t ledDirection = 1; // Direction of the pattern
// Interrupt Service Routine for Timer1
void __attribute__((__interrupt__, no_auto_psv)) _T1Interrupt(void) {
// Toggle RUN LED
LATAbits.LATA4 ^= 1;
// Clear Timer1 interrupt flag
IFS0bits.T1IF = 0;
}
int main(void) {
// Configure the pins for the LEDs
LED_PATTERN_TRIS = 0; // Set as output
RUN_LED_TRIS = 0; // Set as output
// Configure the timer for the RUN LED toggle
// Set Timer1 period for 1.45 seconds
T1CONbits.TON = 0; // Disable Timer1
T1CONbits.TCS = 0; // Select internal clock
T1CONbits.TGATE = 0; // Disable gated mode
T1CONbits.TCKPS = 0b10; // Select 1:64 prescaler
TMR1 = 0; // Clear Timer1 count
PR1 = 54688; // Set Timer1 period for 1.45 seconds
IPC0bits.T1IP = 0b001; // Set Timer1 interrupt priority
// Enable Timer1 interrupt
IFS0bits.T1IF = 0; // Clear Timer1 interrupt flag
IEC0bits.T1IE = 1; // Enable Timer1 interrupt
// Enable interrupts
__builtin_enable_interrupts();
// Main loop
while (1) {
// Check switch state to determine the direction of the pattern
if (SWITCH_PIN) {
// Switch open, pattern from Left to Right direction
ledPattern <<= 1;
if (ledPattern == 0x00) {
ledPattern = 0x01;
}
} else {
// Switch closed, pattern from Right to Left direction
ledPattern >>= 1;
if (ledPattern == 0x00) {
ledPattern = 0x80;
}
}
// Output the LED pattern
LED_PATTERN_PINS = ledPattern;
// Delay or perform other tasks as required
}
return 0;
}
```
Please note that this code is a simplified example and may need further modifications according to your specific microcontroller and development environment. Additionally, the code assumes that you have set up the necessary hardware connections correctly.