| View previous topic :: View next topic |
| Author |
Message |
Ahmed Adel Hosni
Joined: 16 Aug 2010
Posts: 12
|
| Multiplying INT vs LONG cycle time |
 Posted: Tue Jun 03, 2014 1:46 am |
 |
|
Hello,
I have two methods making the same function but written in different algorithms. I want to understand which one will give the least cycle time.
The first one is using long variable and the other with int. i know long needs more memory than int, but when using int I will multiply the number by a factor to result slightly the same result when using long. so will this differ in anything ?
this function is repeated six times in a loop and used to control six Triacs.
The first code:
| Code: |
int d[0] = {127};
#int_ext
void ext_isr()
{
if(d[0] > 126)
{
output_low(pin_e0);
}
else
{
delay_us(d[0] * 55);
output_high(pin_e0);
delay_us(3);
output_low(pin_e0);
}
}
void main()
{
while(1)
{
if(input(PIN_B7) && d[0] <127)
{
d[0] = d[0] + 1;
}
else if(input(PIN_B6) && d[0] > 0)
{
d[0] = d[0] - 1;
}
}
}
|
The other code with long:
| Code: |
long d[0] = {7000};
#int_ext
void ext_isr()
{
if(d[0] > 7000)
{
output_low(pin_e0);
}
else
{
delay_us(d[0]);
output_high(pin_e0);
delay_us(3);
output_low(pin_e0);
}
}
void main()
{
while(1)
{
if(input(PIN_B7) && d[0] <7000)
{
d[0] = d[0] + 100;
}
else if(input(PIN_B6) && d[0] > 0)
{
d[0] = d[0] - 100;
}
}
}
|
|
|
 |
rikotech8
Joined: 10 Dec 2011
Posts: 376
Location: Sofiq,Bulgariq
|
|
| Posted: Tue Jun 03, 2014 3:30 am |
|
|
I can't see the point of your code, but anyway.
This declaration initializes array of integers with zero elements.
Just a hint. Good way to reduce your program time when you are using I/O functions is to use FAST IO which will not produce pin direction code (as default does), but just the logic state. It will make
| Code: |
output_high(pin_e0);
output_low(pin_e0); |
much faster.
1. Look at the .lst file in your project directory.
You are able to see the assembler instructions code.
2. Make a google search: | Quote: | | pic assembler instruction set pdf |
.
3. Compare the two patterns.
I hope it would help.
_________________
A person who never made a mistake never tried anything new. |
|
|
ckielstra
Joined: 18 Mar 2004
Posts: 3680
Location: The Netherlands
|
|
| Posted: Tue Jun 03, 2014 5:24 am |
|
|
You did not mention the PIC you are using. The PIC18 has a hardware multiply unit which can do 8x8 multiplications in 1 cycle where the PIC16 has to do a lot more work.
You can measure the timing differences yourself when you use Microchip's free MPLAB IDE, there you find a simulator tool with stopwatch. Run part of your program and read the time it took to execute.
Your program has a design flaw when you want to scale up to use more than 1 TRIAC. For example, when 1 TRIAC has a delay of up to 7000us all other TRIACs can not be controlled during that time.
Much better is to have a system that is triggers an interrupt every xxx us. When a zero crossing is detected you set timers for every TRIAC you have. In the interrupt routine you count down every timer by 1, when a timer reaches zero you fire the action for that TRIAC.
The interrupt frequency timing is dependent on how fast your processor is clocked because there is some overhead involved for saving and restoring registers. Choosing a 50us interrupt rate will give you 140 'steps' in your 7ms time frame. Because of the overhead I then suggest you use a clock frequency of 16MHz or higher. |
|
|
|
FAQ 
Search
Register
Profile 
Log in to check your private messages 
Log in
