Here's an example implementation of the given requirements using the Timer1 module and interrupts on Explorer 16:
```C
#include <xc.h>
// Configuration settings
#pragma config FOSC = HS
#pragma config WDTEN = OFF
#pragma config XINST = OFF
// Global variables
unsigned char LEDPattern = 0x18; // Initial LED pattern: 00011000
unsigned char LEDDirection = 0; // 0: Left to Right, 1: Right to Left
// Function prototypes
void init(void);
void delay(unsigned int millis);
void __interrupt(high_priority) high_isr(void);
void __interrupt(low_priority) low_isr(void);
void main(void) {
init();
while (1) {
// Toggle RUN LED (D10) every 1.45 seconds
LATAbits.LATA9 ^= 1;
delay(1450);
// Update LED pattern
if (LEDDirection == 0) {
// Left to Right direction
if (LEDPattern == 0x80) {
// Reached the rightmost LED, switch direction
LEDPattern >>= 1;
LEDDirection = 1;
} else {
// Shift pattern to the left
LEDPattern <<= 1;
}
} else {
// Right to Left direction
if (LEDPattern == 0x01) {
// Reached the leftmost LED, switch direction
LEDPattern <<= 1;
LEDDirection = 0;
} else {
// Shift pattern to the right
LEDPattern >>= 1;
}
}
// Display LED pattern
LATAbits.LATA8 = ((LEDPattern >> 0) & 1); // D9
LATAbits.LATA7 = ((LEDPattern >> 1) & 1); // D8
LATAbits.LATA6 = ((LEDPattern >> 2) & 1); // D7
LATAbits.LATA5 = ((LEDPattern >> 3) & 1); // D6
LATAbits.LATA4 = ((LEDPattern >> 4) & 1); // D5
LATAbits.LATA3 = ((LEDPattern >> 5) & 1); // D4
LATAbits.LATA2 = ((LEDPattern >> 6) & 1); // D3
}
return;
}
void init(void) {
// Configure oscillator
OSCCON = 0x70;
// Configure I/O ports
ANSELB = 0; // Disable analog inputs
TRISB = 0xFF; // Configure PORTB as input
ANSELA = 0x00; // Configure AN0-AN3 as digital I/O
TRISA = 0x00; // Configure PORTA as output
LATA = 0x00; // Initialize PORTA outputs
// Configure Timer1 for 1.45 second interrupt
T1CONbits.TON = 0; // Disable Timer1
T1CONbits.TCS = 0; // Select internal clock (Fosc/4)
T1CONbits.TGATE = 0; // Disable gated timer mode
T1CONbits.TCKPS = 0b10; // Set prescaler to 1:64
PR1 = 0xF89D; // Set period register for 1.45 second interval
T1CONbits.TON = 1; // Enable Timer1
// Configure Timer1 interrupt
IPC0bits.T1IP = 0b101; // Set Timer1 interrupt priority to 5
IFS0bits.T1IF = 0; // Clear Timer1 interrupt flag
IEC0bits.T1IE = 1; // Enable Timer1 interrupt
// Enable interrupts
RCONbits.IPEN = 1; // Enable interrupt priority levels
INTCONbits.GIEH = 1; // Enable high priority interrupts
INTCONbits.GIEL = 1; // Enable low priority interrupts
}
void delay(unsigned int millis) {
while (millis--) {
__delay_ms(1);
}
}
void __interrupt(high_priority) high_isr(void) {
// Handle high priority interrupts here
}
void __interrupt(low_priority) low_isr(void) {
// Handle low priority interrupts here
}
```
In this implementation, Timer1 is used to generate a 1.45 second interrupt. Inside the interrupt handler, the RUN LED (D10) is toggled and the LED pattern is updated based on the switch (S3) state. The LED pattern is displayed on LEDs D3-D9, with the direction controlled by the LEDDirection variable. The program runs in an infinite loop, continuously updating the LED pattern and toggling the RUN LED at the specified interval.
Note that the code assumes that the necessary configuration bits are set correctly and that the necessary hardware connections are made (e.g. connecting the switches to the appropriate input pins, connecting LEDs to the appropriate output pins, etc.).
Make sure to test the code on your specific hardware and adjust the pin assignments and configuration settings if necessary.
Implement the design on Explorer 16 as Project 1. LED D10 will be used as the RUN LED indicator.
Knight rider code:
unsigned int count1 = 200;
unsigned int count2 = 200;
void main(void) {
while (1)
{
bool sw = PORTDbits.RD6;
if( toggleDirection ) {
LATA <<= 1;
}
else {
LATA >>= 1;
}
if( LATA == 0x80 ) toggleDirection = false;
if( LATA == 0x01 ) toggleDirection = true;
if( !sw ) {
if( !pressed ) {
if( toggleDirection ){
toggleDirection = false;
LATA = 0x80;
}
else {
toggleDirection = true;
LATA = 0x01;
}
pressed = true;
}
}
else {
pressed = false;
}
delayFunc();
}
return -1;
}
}
void delayFunc(void)
{
int j,k;
int a;
for(j = 0; j < count1; j++)
{
for(k=0; k < count2; k++)
{
a = 0;
}
}
}
Using the knight rider code above, do the following:
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.
1 answer