Implement the design on Explorer 16.
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.
4. The Potentiometer (R6) and the temperature sensor (U4) on Explorer 16 board will be read, converted and processed. And the values (pot voltage and temperature in centrigrade) will be sent out through UART2 and will be displayed on a terminal program (Putty/TeraTerm, running in your PC). The UART2 will be running at 9600 baud rate.
To implement the design specified on the Explorer 16 Development Board, let's break down the tasks and tackle them step by step, writing the pseudocode that could then be translated into suitable code for the microcontroller used in the Explorer 16 board.
### 1. RUN LED Toggle every 3.5sec using Timer 1
```pseudo
// Pseudocode for PIC24/dsPIC
Initialize Timer1:
Configure Timer1 with the pre-scaler that matches the desired interval based on the system clock
Set Timer1 period to 3.5sec // This will be a count value depending on the clock and pre-scaler
Timer1 Interrupt Handler:
On interrupt:
Toggle RUN LED (D10)
Reset Timer1 interrupt flag
main:
Initialize Timer1
Enable Timer1 interrupt
Start Timer1
while True:
// Keep the microcontroller running to maintain the timer interrupt
```
### 2. Knight Rider Pattern
```pseudo
// Pseudocode for Knight Rider LED pattern
Initialize GPIO:
Set D9-D3 as output
Read switch S3 state
KnightRiderPattern:
Repeat:
if S3 is open:
Shift pattern from Left to Right
else:
Shift pattern from Right to Left
Delay before shifting the next LED
main:
//... other initializations
while True:
KnightRiderPattern
//... other tasks
```
### 3. Infinite Process
```pseudo
// The while loop in main already ensures the process is repeated infinitely
main:
Initialize all peripherals
while True:
ToggleLEDwithTimer1
KnightRiderPattern
UpdateUART2
```
### 4. Read Potentiometer and Temperature Sensor, Output via UART2
```pseudo
// Pseudocode for reading and sending sensor data
Initialize ADC:
Configure channels for Potentiometer (R6) and temperature sensor (U4)
Initialize UART2:
Set baud rate to 9600
SendDataUART2(data):
Write data to UART2 buffer
Wait until transmission is complete
main:
Initialize ADC
Initialize UART2
while True:
Read potentiometer value
Convert to voltage
Read temperature sensor value
Convert to Celsius
Format string with both values
SendDataUART2(formatted string)
//... other tasks
```
### Final Integration
Now you need to integrate all the components into your main program loop, making sure that the timing for the LED toggle does not get disrupted by the other operations.
This pseudocode needs to be translated into real code according to the microcontroller's instruction set used on the Explorer 16 board, typically a PIC24 or dsPIC. The exact implementation details will vary based on the specific microcontroller's registers and peripherals. The MPLAB IDE from Microchip provides libraries and examples that can be used to implement the Timer, ADC, GPIO, and UART functionality. You may also need to tweak the timing and pre-scaler settings based on the actual clock frequency of your microcontroller.
Remember to be careful with multitasking: the pseudocode above expects that all operations are quick and non-blocking. If any of the operations are blocking (such as waiting in a busy loop for UART transmission to complete), it could disturb the timing of the LED toggle or the responsiveness of the Knight Rider pattern. In such cases, you would need to look into interrupt-based or state machine designs.