Implement the design on Explorer 16 as Project 1. LED D10 will be used as the RUN LED indicator.
Write an application (in C) which does the following:
1. Make the RUN LED(D10) toggle at every 3.5 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.
what is the configuration?
To implement the given design on Explorer 16 as Project 1, you would need to configure the following components and modules:
1. LED D10 (RUN LED): This LED will be used as the RUN LED indicator and will toggle at every 3.5 seconds interval using Timer 1 module.
2. Timer 1 Module: You will need to configure Timer 1 module to generate an interrupt at a precise interval of 3.5 seconds. This will be used to toggle the RUN LED.
Additionally, you will be implementing the Knight Rider pattern using 7 LEDs (D9-D3) and the behavior of the pattern will be determined by the state of switch S3.
Below is the step-by-step guide on how to implement the design:
Step 1: Configuration
- Connect LED D10 to an appropriate GPIO pin on the microcontroller.
- Connect the 7 LEDs (D9-D3) to the microcontroller GPIO pins.
- Connect switch S3 to another GPIO pin on the microcontroller.
Step 2: Timer 1 Configuration
- Configure Timer 1 module to generate an interrupt at a frequency of 1 / (2 × 3.5) Hz, which is approximately 0.2857 Hz.
- Set the timer period to achieve a 3.5 seconds interval. This can be calculated by dividing the timer frequency by the desired frequency.
Step 3: LED D10 Toggling
- In the Timer 1 interrupt service routine, toggle the state of LED D10.
- Use a variable to keep track of the current state of the LED, and toggle it between ON and OFF states whenever the interrupt occurs.
Step 4: Knight Rider Pattern
- Determine the state of switch S3.
- If the switch is open, implement the Knight Rider pattern from Left to Right direction.
- If the switch is closed, implement the Knight Rider pattern from Right to Left direction.
Step 5: Repeat Process Infinitely
- After completing the above steps, repeat the entire process in an infinite loop.
By following the above steps and configuring the necessary components and modules correctly, you can implement the given design on Explorer 16 as Project 1.
To implement the design on the Explorer 16 board as Project 1, here is the configuration you would need:
1. Set up the microcontroller's Timer 1 module to toggle the RUN LED (D10) at a 3.5-second interval.
2. Configure the circuit to have 7 LEDs (D9-D3) for the Knight Rider pattern. Depending on the state of switch S3, the pattern will either go from left to right or right to left.
3. Set up the application to repeat the entire process indefinitely.
Now, let's write the code in C to achieve this configuration:
```c
#include <xc.h>
// Configuration bits
#pragma config FOSC = INTIO67 // Internal oscillator, port function on RA6 and RA7
#pragma config WDTEN = OFF // Watchdog Timer disabled
#pragma config LVP = OFF // Single-Supply ICSP disabled
// Define constants
#define RUN_LED LATBbits.LATB11
#define SWITCH_S3 PORTBbits.RB0
// Configure Timer 1 for toggling the RUN LED
void configureTimer1() {
T1CONbits.TMR1CS = 0; // Select internal clock
T1CONbits.T1CKPS = 0b11; // Prescaler 1:8
TMR1 = 0; // Clear Timer 1 value
PR1 = 43750; // Set period for 3.5 seconds with a 8 MHz clock
T1CONbits.TMR1ON = 1; // Enable Timer 1
}
// Initialize ports and pins
void init() {
// Set PORTB as output
TRISB = 0;
// Set RB11 (RUN LED) as output
TRISBbits.TRISB11 = 0;
}
// Toggle the RUN LED
void toggleRunLED() {
RUN_LED = !RUN_LED;
}
// Knight Rider pattern control
void knightRiderPattern() {
int direction = 1; // 1 for left to right, -1 for right to left
int currentLED = 0;
while (1) {
if (SWITCH_S3) {
// Switch S3 is open, left to right direction
currentLED += direction;
if (currentLED < 3 || currentLED > 9) {
direction = -direction;
currentLED += direction;
}
} else {
// Switch S3 is closed, right to left direction
currentLED -= direction;
if (currentLED < 3 || currentLED > 9) {
direction = -direction;
currentLED -= direction;
}
}
// Turn on current LED
LATB = (LATB & 0xFFC7) | (1 << currentLED);
__delay_ms(300);
// Turn off current LED
LATB = (LATB & 0xFFC7);
}
}
// Main function
void main() {
init();
configureTimer1();
while (1) {
toggleRunLED();
knightRiderPattern();
}
}
```
Please note that this code assumes you are using a PIC microcontroller, and the specific pin assignments may vary depending on the microcontroller model you are using.
To implement the design on Explorer 16 as Project 1, the following configuration is required:
1. Set up the hardware connections:
- Connect LED D10 to the corresponding I/O pin of the microcontroller.
- Connect LEDs D3-D9 to their respective I/O pins of the microcontroller.
- Connect switch S3 to an interrupt-capable I/O pin of the microcontroller.
2. Set up the Timer 1 module:
- Configure Timer 1 for a 3.5 seconds interval using the appropriate settings (prescaler, period, etc.).
- Enable interrupts for Timer 1.
3. Configure the I/O pins:
- Set the I/O pins for LEDs D3-D9 as output pins.
- Set the I/O pin for LED D10 as an output pin.
- Set the I/O pin for switch S3 as an input pin.
4. Enable the interrupts:
- Enable global interrupts.
- Enable the interrupt for the switch S3 (if necessary).
5. Write the application program in C to implement the desired functionality:
- Toggle the LED D10 (RUN LED) every 3.5 seconds with a Timer 1 interrupt service routine.
- Implement the Knight Rider pattern for LEDs D3-D9 based on the state of switch S3 (open or closed) with a separate function or loop.
- Repeat the whole process in an infinite loop.
Example code snippet:
```c
#include <xc.h>
// Function to implement the Knight Rider pattern
void knightRiderPattern(int direction) {
int leds[] = {LATB3, LATB4, LATB5, LATB6, LATB7, LATB8, LATB9};
if (direction == 0) { // Left to Right
for (int i = 0; i < 7; i++) {
LATA = leds[i];
__delay_ms(200); // Adjust the delay time for desired speed
}
} else { // Right to Left
for (int i = 6; i >= 0; i--) {
LATA = leds[i];
__delay_ms(200); // Adjust the delay time for desired speed
}
}
}
// Timer 1 interrupt service routine
void __interrupt() isr() {
if (TMR1IF) {
LATAbits.LATA5 = !LATAbits.LATA5; // Toggle LED D10
TMR1IF = 0; // Clear Timer 1 interrupt flag
}
}
void main() {
// Configure Timer 1 for a 3.5 seconds interval
T1CON = 0b00110000; // Prescaler 1:8, TMR1ON = 1 (enabled)
TMR1 = 15536; // TMR1H: TMR1L = 0x3C00, 20MHz / (8 * 65536) * 25000 = 3.5 seconds
// Configure I/O pins
TRISAbits.TRISA5 = 0; // Set LED D10 as an output pin
TRISBbits.TRISB3 = 0; // Set LED D3 as an output pin
TRISBbits.TRISB4 = 0; // Set LED D4 as an output pin
TRISBbits.TRISB5 = 0; // Set LED D5 as an output pin
TRISBbits.TRISB6 = 0; // Set LED D6 as an output pin
TRISBbits.TRISB7 = 0; // Set LED D7 as an output pin
TRISBbits.TRISB8 = 0; // Set LED D8 as an output pin
TRISBbits.TRISB9 = 0; // Set LED D9 as an output pin
TRISBbits.TRISB15 = 1; // Set switch S3 as an input pin
// Enable interrupts
PEIE = 1; // Enable peripheral interrupts
GIE = 1; // Enable global interrupts
TMR1IE = 1; // Enable Timer 1 interrupt
RCONbits.IPEN = 1; // Enable interrupt priority levels
// Infinite loop
while (1) {
// Check the state of switch S3
int switchState = PORTBbits.RB15;
// Implement the Knight Rider pattern
if (switchState == 0) {
knightRiderPattern(0); // Left to Right
} else {
knightRiderPattern(1); // Right to Left
}
}
}
```
This code snippet demonstrates one possible implementation of the given requirements. However, it is important to note that the exact implementation might vary based on the specific microcontroller and development environment being used.