Sure. I still kind of like synchronizing the DP with the actual seconds count for a smooth visual experience though.
// Timer 0 set to interrupt about 3msec for now
// Setting is 256 - (3ms / .5usTcyc) / 64Prescaler = 256 - 93.755 counts = 162.25 ~= 162
#define TMR0set 162 // counts 162->255 then rolls over and interrupts#if(XTAL != 8000000)
ERROR "Timers.inc: Need to re-calculate timing!"
#endifAgreed.
Maybe. We kind of got off on 'can you multiplex an LED display with 1 PIC?' - OK, yes we can. But as you've seen, we have taken some side roads. To minimize that, its important to get back to a top-down design i.e. it charges batteries by doing this.. Top level. Second level: to to that, it needs some displays, accurate timing (getting there), some buttons (hmmm..) and (??). The third level we've begun with the fancy display/DP stuff. A still lower level would be the display mux. And on and on...
3ms was a starting point which I figured would change. The reason for 2 timers at this point was to compensate for the vague spec and allow changes to one time without fouling up the other. If the final version uses the same time, the timers can of course be driven off one IRQ.Is there some reason it needs to be so slow? I would think 1mS per digit would be optimal, and would have the added advantage of you being able to use the same 1mS interrupt to count seconds, so you don't need two interrupts. It does seem silly to have two separate interrupts, which are both timed periods.
I used all the IO's 
/******* LED/Display controls ****************************/
// These turn on, off, toggle LEDs in the display segment
// array according to the passed mask. Any '1' in the mask
// will have the indicated action on its asscoiated LED
// Multiple LEDs can be controlled in one call
// These assume that a 1 output turns the LED on.
// Added: FLASH MASK control
void LEDs_on(SegBits ledMask) // masked LEDs on
{
DigitsBuf[dLEDs] |= ledMask;
}
void LEDs_off(SegBits ledMask) // masked LEDs off
{
DigitsBuf[dLEDs] &= ~ledMask;
LEDflash_mask &= ~ledMask; // stop flashing on OFF LEDs
}
void LEDs_toggle(SegBits ledMask) // toggle masked LEDs
{
DigitsBuf[dLEDs] ^= ledMask; // not useful iff LED is flashing
}
void LEDs_direct(SegBits ledMask) // write mask value directly to all LEDs
{
DigitsBuf[dLEDs] = ledMask;
}
void LEDs_flash(SegBits ledmask) // flash any LEDs under mask
{
LEDflash_mask |= ledmask; // IRQ / mux does the flashing
}
void LEDs_UNflash(SegBits ledmask) // Stop flashing any LEDs under mask
{
LEDflash_mask &= ~ledmask;
} void initLEDdisplay()
{
unsigned short i;
for (i = 0; i < N_DIGITS; i++)
DigitsBuf = 0;
LEDflash_mask = 0;
digitN = 0;
// init multiplexer here
}
Yes, you should use it. The default return value for a function is a signed int. Void says the function returns nothing - so if you try to use a value from it the compiler will flag an error to help you out. Early C was did not do much type checking. If there was a type conflict, it applied default rules that may or may not have worked. Modern C will type check everything you tell it to - a BIG help.
This is a placeholder to remind you/me that this is the place to init any values that the mux needs before starting. The mux as written makes use of C initializing global variables to 0 (digitN in this case) so no further init is needed. The line can be deleted.
Why start fresh code and if you do, block copy is the way to go. My earlier reference to an error with block copy related to the fact that it included different names in each section which I neglected to update. Personally, if I want to clean up after experimenting I copy the entire file for safekeeping and as a reference then clean up the existing one.
If 1.7 ms is good, use that. My reasoning: the interrupt routine has some unseen overhead because it has to save any system registers that the various services use so that it can restore them before returning to the interrupted program. The less you burn this overhead, the more processing time you have for other things. Leave it at 1.7 for now, its easy enough to change.
It comes with practice but at this point, maybe a flow chart is too detailed. Consider describing the program with an inverted tree chart. At the top (root of tree) describe the broad function of the system - reads VOLTs and AMPs, displays V/A/Time, encoder for data entry, beeps warnings, times the cycle, flashes LEDs etc. - Don't try to put anything into sequence yet with a flow chart, just identify the basic functions that the system does and what it needs to do them on a horizontal line.
/******* All light check for fault *************************/
void initLightchk()
{
Time = Volts = Amps = 888; // Value to light all segments.
Int2Segs(Time,dTime,SegDP); // Conver to display.
Int2Segs(Volts,dVolts,SegDP); // Conver to display.
Int2Segs(Amps,dAmps,SegDP); // Conver to display.
LEDs_on(ALL_LEDs); // All LED's on.
delay_ms(1000); // 1 second visual indication.
Time = Volts = Amps = 000; // Resets Digit's to 0
Int2Segs(Time,dTime,SegDP); // Conver to display.
Int2Segs(Volts,dVolts,SegDP); // Conver to display.
Int2Segs(Amps,dAmps,SegDP); // Conver to display.
LEDs_off(ALL_LEDs); // All LED's off
}void ShutDown()
{
while(1)
{
PORTC = PORTE.RE2 = 0;
SD_Rly = 0;
LEDs_flash(SD_LED);
Sink_Temp = ADC_Read(3); // Get 10-bit results of HeatSink temperature.
if(Sink_Temp<=300){
HeatSink_threshold = 0;
break;
}
}
}It IS a lot to swallow at once. Go ahead and code how you are comfortable. We can take it from there.
Except blank them, I guess. A couple of ways to do it.. You can create a new entry in the segment table (digit 0ah maybe) that does not turn any segments on. You also can add other patterns and symbols - maybe you want to display '---' or 'OFF'. These can be done with an extended segment table. The problem with that approach is that its sometimes harder to do.. display VOLTS or write 0ah,0ah,0ah etc.
switch (digitN){ // all digits are off here
// turn on new digit iff not blanked
// (also brute force)
// digits 0-2 are TIME
case 0: if !(BlankTIME) dig0sel = 1;
break;
case 1: if !(BlankTIME) dig1sel = 1;
break;
case 2: if !(BlankTIME) dig2sel = 1;
break;
// digits 3-5 are VOLTS
case 3: if !(BlankVOLTS) dig3sel = 1;
break;
case 4: if !(BlankVOLTS) dig4sel = 1;
break;
case 5: if !(BlankVOLTS) dig5sel = 1;
break;
// digits 6-8 are AMPS
case 6: if !(BlankAMPS)dig6sel = 1;
break;
case 7: if !(BlankAMPS) dig7sel = 1;
break;
case 8: if !(BlankAMPS) dig8sel = 1;
break;
// digit 9 is LEDs
case 9: if !(BlankLEDs)digLEDsel = 1;
break;
}//switchPost or PM a working piece of code and I'll break it into separate files with the .h stuff. You can see how it works from there. You also might get a good C reference manual, maybe K&R 2ed. ed. even.
What you are experiencing is common but eventually, EVERY detail of EVERY module must be thought out and expressed in code. While it can seem easier to just fire up the IDE and code away, you'll find on the more complex projects that some sort of paper design that you can trace the flow on and see how things interact will save you lots of time and revisions. Think twice-Code once.
That is how I would do it. It's good to be able to display a blank digit, anywhere it is needed. On a 9 digit display he might even want to show two numbers separated by a blank digit.
// Digits 0-9
#define Digit0 (SegA + SegB + SegC + SegD + SegE + SegF)
#define Digit1 (SegB + SegC)
#define Digit2 (SegA + SegB + SegD + SegE + SegG)
#define Digit3 (SegA + SegB + SegC + SegD + SegG)
#define Digit4 (SegB + SegC + SegF + SegG)
#define Digit5 (SegA + SegC + SegD + SegF + SegG)
#define Digit6 (SegA + SegC + SegD + SegE + SegF + SegG)
#define Digit7 (SegA + SegB + SegC)
#define Digit8 (SegA + SegB + SegC + SegD + SegE + SegF + SegG)
#define Digit9 (SegA + SegB + SegC + SegD + SegF + SegG)
// A-F hexadecimal - character codes 0ah - 0fh
#define DigitA (SegA + SegB + SegC + SegE + SegF + SegG)
#define DigitB (SegC + SegD + SegE + SegF + SegG)
#define DigitC (SegA + SegD + SegE + SegF)
#define DigitD (SegB + SegC + SegD + SegE + SegG)
#define DigitE (SegA + SegD + SegE + SegF + SegG)
#define DigitF (SegA + SegE + SegF + SegG)
//Segment Look-up table - one entry for each digit/character. Position in the array
// determines its character code - 0-9, A-F are their hex equivalents.
const SegBits SegTable[] = {Digit0,Digit1,Digit2,Digit3,Digit4,Digit5,\
Digit6,Digit7,Digit8,Digit9,\
DigitA,DigitB,DigitC,DigitD,DigitE,DigitF}; // Symbols are stored in messages of raw segment patterns (not character codes)
#define DigitDASH (SegG)
#define DigitBLANK 0
#define DigitQUESTIONMARK (SegA + SegB + SegE + SegG)
//Canned messages - These are stored as raw segment patterns. The symbols do not
// have character codes assigned in this implementation.
const LEDmsg_OFF[] = {Digit0,DigitF,DigitF}; //'OFF'
const LEDmsg_WTF[] = {DigitQUESTIONMARK,DigitQUESTIONMARK,DigitQUESTIONMARK}; // '???'
const LEDmsg_D_Q[] = {DigitDASH,DigitBLANK,DigitQUESTIONMARK}; // '- ?'
const LEDmsg_BLANKALL[] = {DigitBLANK,DigitBLANK,DigitBLANK}; // ' 'void CannedMsg(SegBits *msg, unsigned short ofs, SegBits DPmask);
#define DigitF (SegA + SegE + SegF + SegG)
const SegBits SegTable[] = {Digit0,Digit1,Digit2,Digit3,Digit4,Digit5,\
Digit6,Digit7,Digit8,Digit9,DigitF,};
/******* OverHeat Conversion routine **********************/
void OFFmsg(SegBits, unsigned short ofs)
{
unsigned short x,i; // this gets removed by the optimizer
// Appends passed decimal point to first digit
x = i/100;
DigitsBuf[ofs] = SegTable[0];
x = (i/10)%10;
DigitsBuf[ofs+1] = SegTable[10];
x = (i%10);
DigitsBuf[ofs+2] = SegTable[10];
}
/******* Shut Down Loop ***********************************/
void ShutDown()
{
while(1)
{
OFFmsg(Time,dTime); // Show "OFF"
OFFmsg(Volts,dVolts); // Show "OFF"
OFFmsg(Amps,dAmps); // CShow "OFF"
SD_Rly = 0; // Turn Off All Relays.
BVt_Rly = 0; // ------ DO --------
Ch_Rly = 0; // ------ DO --------
CVs_Rly = 0; // ------ DO --------
LEDs_flash(SD_LED); // Flash Alarm LED
LEDs_off(CH_LED+CV_LED+CC_LED+BI_LED+BH_LED);// All LED's OFF except SD_LED
Sink_Temp = ADC_Read(3); // Get 10-bit results of HeatSink temperature.
if(Sink_Temp<=300) // 300 is dummy value for testing
{
HeatSink_threshold = 0; // If heat sink is cooled reset flag
break; // Move on if Temperatue is OK
} // While loop exits
}
}
by Jake Hertz
by Duane Benson
by Duane Benson
