For the statement "DebugStr('Zero Counts: ' + s1 + ' (11.7mA resolution)' + #13 + #10);" the compiler has to reserve memory to hold the total string that will be sent to the uart.
In case you e.g. define "procedure DebugStr(var debugstring: string[50]);" it will reserve (on the stack) 50 bytes for the total string sent to DebugStr.
This means also, that, when you take a number that is too low (e.g. "procedure DebugStr(var debugstring: string[5]);" the software will block due to memory corruption. (tested: it happens).
In case of using "procedure DebugStr(var debugstring: string);" the compiler has no clue about the number of bytes to reserve.
The P24 mP compiler version 6.0.1 takes here a size based on the size of S1, which is 129 bytes, plus the constants in the DebugStr statement, comes in total 164 bytes reserved for the total string.
So, as far as I can see using "procedure DebugStr(var debugstring: string);" should be safer than using "procedure DebugStr(var debugstring: string[50]);" because in the latter case one can reserve a too low amount.
p.s. I did not know this could happen.
Anyway: I see the opposite happening of what You detected Jim, but only if the size of the string parameter is too low to hold the complete string parameter for DebugStr. Do you use the same mP compiler version as I do?
I did the test with the P24FJ64GA002, what type did you use?
p.s. to prevent these type of problems it is perhaps better not to use the '+' operator when handling strings. This means creating your own temp string variable and using "strcat".
My Test code:
Code: Select all
program Jim_Keuneman;
{ Declarations section }
var
ADCZeroCounts: Integer;
Res: word;
procedure DebugStr(var debugstring: string);
begin
UART1_Write_Text(debugstring);
end;
begin
{ Main program }
ADPCFG := 0xFFFF; // Configure AN pins as digital I/O
Res := PPS_Mapping (7, _INPUT, _U1RX); // RP7 is uart1 input
Res := PPS_Mapping (6, _OUTPUT, _U1TX); // RP6 is uart1 output
Uart1_init(115200);
delay_ms(250);
ADCZeroCounts := 1250;
while true do
begin
WordToStr(ADCZeroCounts, s1);
DebugStr('Zero Counts: ' + s1 + ' (11.7mA resolution)' + #13 + #10);
end;
end.
). After all, you use string literal in parameter passed by reference (I know mP allows it, but it's more a shortcut for newbies to pass the famous "Hello World" string than a proper Pascal use). Putting too much trust in small processor compiler by employing multiple '+' operators is also a bit risky. That it may work at all is due more to mE developers effort to satisfy user's wishes than to Pascal language requirements. If mP and mB users had to pay the same high RAM use penalty for passing string literals as programmers using mC, it certainly wouldn't be a popular solution.
). When one declares size of a parameter, it should be for a reason, so mP limits the memory reserved to user-specified size and it becomes user responsibility to keep within his own limits. (Initially, when one forced string literal to be passed by reference, compiler assumed size 0 when one didn't specify the parameter size or exactly the size specified - whether the space was needed or not. Present solution seems much better and I don't see any other reasonable way it could work with the limited resources of small processors.) 
), as a warning, but there doesn't seem to be a need for changes in compiler. Certainly, passing string literals by reference should not be so much encouraged in examples and the way it works (against Pascal definition) should be well described in Help.
.