• AVR Freaks

Hot!Using C function parameters in asm

Page: 12 > Showing page 1 of 2
Author
j.paul
New Member
  • Total Posts : 11
  • Reward points : 0
  • Joined: 2020/01/08 14:10:41
  • Location: 0
  • Status: offline
2020/01/10 14:39:10 (permalink)
0

Using C function parameters in asm

Hello,
I'm working with a PIC12F508 in MPLAB X IDE and XC8 v2.10 and have a question about the use of C parameter variables in asm:
 

void send_serial(unsigned char data)

{
// Send byte to SERIAL_TX at 115200 bps - 1us instruction time
// Adapted from Microchip PIC Tips and Tricks PDF

//Note: Standard C 90 must be set to accept #asm

#asm
_asm
MOVWF send_serial@data     // Patch to make it work
BCF SERIAL_TX              // Send start bit
GOTO $+1                   // 2us delay
BSF CARRY_bit              // Load stop bit into Carry
send_loop:
RRF send_serial@data,F     // Next data bit into Carry
BCF SERIAL_TX              // OUT=0
BTFSC CARRY_bit            // If CARRY=1
BSF SERIAL_TX              // OUT=1
BCF CARRY_bit              // Delete sent bit
MOVF send_serial@data,F
BTFSS ZERO_bit             // While bits left to send
GOTO send_loop
_endasm
#endasm
}


 
 
To make it work I had to add the first instruction 'MOVWF send_serial@data' as the dissassembly listing shows it stores in W the parameter value before CALL but then replaces the references 'send_serial@data' to '__pcstackBANK0'. By assigning W to '__pcstackBANK0' I can make it work but I think it is not the intended way. If I use the parameter within C code then the compiler adds that MOVWF for me and all works as expected.
 
Maybe it is a side-effect of setting Optimitzation=1, I had to do that to stop it from generating a lot of non-sense GOTO in conditions and loops. Also tried 'volatile' in the data declaration without change. I understand it may think the variable is not used and am afraid that enabling better optimization or some future improvement could also drop the assignment of parameter value to W. If that is the case maybe there should be a way to tell the compiler the variable is needed.
 
I read in the XC8 manual about a compiled stack in an attempt to understand what '__pcstackBANK0' is all about, however I think all I could understand is it is some sort of self-assigned memory location.
 
Thank you!
#1

24 Replies Related Threads

    ric
    Super Member
    • Total Posts : 27752
    • Reward points : 0
    • Joined: 2003/11/07 12:41:26
    • Location: Australia, Melbourne
    • Status: online
    Re: Using C function parameters in asm 2020/01/13 12:36:37 (permalink)
    0
    Change your function declaration to:
    void send_serial(volatile unsigned char data)

     
    I'm not sure if that's where you tried putting it, but it works fine for me in XC8 1.xx and XC8 2.xx in C90 mode.
    Haven't tried it in C99 mode.
     
     

    I also post at: PicForum
    Links to useful PIC information: http://picforum.ric323.co...opic.php?f=59&t=15
    NEW USERS: Posting images, links and code - workaround for restrictions.
    To get a useful answer, always state which PIC you are using!
    #2
    1and0
    Access is Denied
    • Total Posts : 10930
    • Reward points : 0
    • Joined: 2007/05/06 12:03:20
    • Location: Harry's Gray Matter
    • Status: offline
    Re: Using C function parameters in asm 2020/01/13 14:03:02 (permalink)
    0
    ric
    Change your function declaration to:
    void send_serial(volatile unsigned char data)

    ... but it works fine for me in XC8 1.xx and XC8 2.xx in C90 mode.

    Could you post the disassembly that works fine?
     
     
    #3
    1and0
    Access is Denied
    • Total Posts : 10930
    • Reward points : 0
    • Joined: 2007/05/06 12:03:20
    • Location: Harry's Gray Matter
    • Status: offline
    Re: Using C function parameters in asm 2020/01/13 14:05:19 (permalink)
    0
    j.paul
    I understand it may think the variable is not used ...

    That is what I think too.  Instead of using "data" use WREG. Also, you will have a glitch when the data bit is a "1" because you clear TX then set TX for a "1" bit.
     
    post edited by 1and0 - 2020/01/13 14:57:53
    #4
    ric
    Super Member
    • Total Posts : 27752
    • Reward points : 0
    • Joined: 2003/11/07 12:41:26
    • Location: Australia, Melbourne
    • Status: online
    Re: Using C function parameters in asm 2020/01/13 14:15:39 (permalink)
    0
    As 1and0 stated, once you've done that, the data arrives in the W register, you don't need to refer to it by the parameter name.
    The "volatile" qualifier on the parameter is simply to suppress the "Warning [1090] parameter not used" you would normally get.
     
    I can post some disassembly if you want, but of what?
    The function code just uses the parameter in W.
    The calling code would show the value being loaded into W before the function was called.
     
    Edit:
    Oops, I just realised I've read your question backwards.
    What I explained is how to just receive the data in W without using ANY other storage.
    As 1and0 stated, you can't use the RRF instruction on the W register in these old midrange devices.
    You CAN on newer devices.
    post edited by ric - 2020/01/13 14:29:15

    I also post at: PicForum
    Links to useful PIC information: http://picforum.ric323.co...opic.php?f=59&t=15
    NEW USERS: Posting images, links and code - workaround for restrictions.
    To get a useful answer, always state which PIC you are using!
    #5
    1and0
    Access is Denied
    • Total Posts : 10930
    • Reward points : 0
    • Joined: 2007/05/06 12:03:20
    • Location: Harry's Gray Matter
    • Status: offline
    Re: Using C function parameters in asm 2020/01/13 14:16:09 (permalink)
    0
    My bad. Forgot that PIC does not have a memory mapped WREG.
    #6
    ric
    Super Member
    • Total Posts : 27752
    • Reward points : 0
    • Joined: 2003/11/07 12:41:26
    • Location: Australia, Melbourne
    • Status: online
    Re: Using C function parameters in asm 2020/01/13 14:19:09 (permalink)
    0
    You're right, a PIC12F508 (or any PIC12Fxxx or PIC16Fxxx) doesn't have a memory mapped WREG. All the "enhanced" PIC12F and PIC16F devices do, but that's academic. The data is just in W.
     

    I also post at: PicForum
    Links to useful PIC information: http://picforum.ric323.co...opic.php?f=59&t=15
    NEW USERS: Posting images, links and code - workaround for restrictions.
    To get a useful answer, always state which PIC you are using!
    #7
    ric
    Super Member
    • Total Posts : 27752
    • Reward points : 0
    • Joined: 2003/11/07 12:41:26
    • Location: Australia, Melbourne
    • Status: online
    Re: Using C function parameters in asm 2020/01/13 14:31:07 (permalink)
    0
    See my edit in post#5.
    Sorry, I was answering the wrong question.
    You could just do it in W if you were using an "enhanced" PIC12F device.
     
    For now, your "patch" is the best solution.
    It's just doing something the compiler would do anyway if it saw any C code using the variable, so you're not losing any code space.
     
    post edited by ric - 2020/01/13 14:53:45

    I also post at: PicForum
    Links to useful PIC information: http://picforum.ric323.co...opic.php?f=59&t=15
    NEW USERS: Posting images, links and code - workaround for restrictions.
    To get a useful answer, always state which PIC you are using!
    #8
    j.paul
    New Member
    • Total Posts : 11
    • Reward points : 0
    • Joined: 2020/01/08 14:10:41
    • Location: 0
    • Status: offline
    Re: Using C function parameters in asm 2020/01/14 14:39:07 (permalink)
    0
    Thank you for your replies!
     
    The patch for now makes this function work. However I'm implementing another more complex function and the same issue is back. Now I call __delay_us(100) at the beginning and the code generated overwrites both W and '__pcstackBANK0' so no matter if I assign it or not the parameter value is lost.  It still replaces the parameter variable references with '__pcstackBANK0', so unless I'm missing something it looks like I have now to store W in a new local variable to keep it.

    To try to have the compiler do things right I added a reference to the parameter in C code but nothing changed!
    if(data!=0) GP0 = 0;
    Also disabled optimization and tried with and without 'volatile' with no effect.
     
    Now maybe it has realized the if condition is always true given the values in all calls so keeps thinking the parameter is unused, but interestingly it generates the code to perform the if.
     
    Tomorrow I will do some more tests and post the code.
     
    Thank you!
    post edited by j.paul - 2020/01/14 14:43:01
    #9
    ric
    Super Member
    • Total Posts : 27752
    • Reward points : 0
    • Joined: 2003/11/07 12:41:26
    • Location: Australia, Melbourne
    • Status: online
    Re: Using C function parameters in asm 2020/01/14 15:14:49 (permalink)
    0
    Lateral thinking.
    Could you just reserve one byte of global storage for your parameters, and manually write them there as required rather than as parameters to the function?
     

    I also post at: PicForum
    Links to useful PIC information: http://picforum.ric323.co...opic.php?f=59&t=15
    NEW USERS: Posting images, links and code - workaround for restrictions.
    To get a useful answer, always state which PIC you are using!
    #10
    1and0
    Access is Denied
    • Total Posts : 10930
    • Reward points : 0
    • Joined: 2007/05/06 12:03:20
    • Location: Harry's Gray Matter
    • Status: offline
    Re: Using C function parameters in asm 2020/01/14 16:07:36 (permalink)
    0
    Try this:
    void send_serial(volatile unsigned char data)
    {
        data = data + '\0';
        // ...

    which will waste two instruction words.  I vote to submit a ticket to Microchip on this issue. ;)
     
    #11
    dan1138
    Super Member
    • Total Posts : 3651
    • Reward points : 0
    • Joined: 2007/02/21 23:04:16
    • Location: 0
    • Status: offline
    Re: Using C function parameters in asm 2020/01/14 19:34:47 (permalink)
    0
    @j.paul,
     
    Here is an implementation I have used with several baseline PIC controllers:
    /*
     * File:   main.c
     * Author: dan1138
     * Target: PIC12F508
     * Compiler: XC8 v2.05 (C90 or C99 mode)
     * IDE: MPLABX v5.25
     *
     * Description:
     *
     *  Show one way to implement a bit-bang serial
     *  output on a baseline PIC12F device.
     *
     * Created on January 14, 2020, 5:11 PM
     */

    // CONFIG
    #pragma config OSC = XT         // Oscillator Selection bits (XT oscillator)
    #pragma config WDT = OFF        // Watchdog Timer Enable bit (WDT disabled)
    #pragma config CP = OFF         // Code Protection bit (Code protection off)
    #pragma config MCLRE = ON       // GP3/MCLR Pin Function Select bit (GP3/MCLR pin function is MCLR)

    #include <xc.h>

    #define SERIAL_TX_BIT   _GPIO_GP5_POSITION
    #define SERIAL_TX_MASK  _GPIO_GP5_MASK
    /*
     * Bit-bang serial output.
     *  10-bit data frame: <Start bit><lsb> ... <msb><Stop bit>
     *
     * Bit rate is FCYC/8, for 115200 baud use a 3.6864 MHz oscillator.
     */
    void send_serial(unsigned char data)
    {
        __asm(" bcf   GPIO," ___mkstr(SERIAL_TX_BIT)); // start bit
        __asm(" movwf send_serial@data ");  /* XC8 passes one byte parameters in the WREG without storing it to memory  */
        __asm(" clrc  ");                   /* first so, depending on the optimizer this code may not work as expected. */
        __asm(" rrf   send_serial@data,F"); /* This code works using the free version of XC8 v2.05, optimizer set to 1  */
        __asm(" xorwf send_serial@data,F");
        __asm(" bsf   send_serial@data,7");
        __asm(" movlw "      ___mkstr(SERIAL_TX_MASK));
        __asm("SendLoop:");
        __asm(" btfsc STATUS,0 ");
        __asm(" xorwf GPIO,F");
        __asm(" clrc  ");
        __asm(" rrf   send_serial@data,F");
        __asm(" movf  send_serial@data,F");
        __asm(" btfss STATUS,2 ");
        __asm(" goto SendLoop");
        __asm(" goto nx1");
        __asm("nx1: bsf   GPIO," ___mkstr(SERIAL_TX_BIT)); // stop bit
    }

    void main(void)
    {
        TRIS = ~SERIAL_TX_MASK;
        GPIO |= SERIAL_TX_MASK;
        
        for(;;)
        {
            send_serial(0x55);
            send_serial(0x00);
            send_serial(0xFF);
            send_serial(0xAA);
        }
    }

    When using the internal oscillator it is hard to tweak it for 115200 baud. This requires that OSCCAL set the internal 4MHz oscllator slow by 7.84%. It's not clear that OSCCAL has the range for that.
    post edited by dan1138 - 2020/01/15 19:56:41
    #12
    j.paul
    New Member
    • Total Posts : 11
    • Reward points : 0
    • Joined: 2020/01/08 14:10:41
    • Location: 0
    • Status: offline
    Re: Using C function parameters in asm 2020/01/15 17:15:56 (permalink)
    0
    ricCould you just reserve one byte of global storage for your parameters, and manually write them there as required rather than as parameters to the function?

     
    Yes. Also given the parameter value is stored in W before call it can be stored to a global variable right at the beginning of a function. However I believe we are patching a compiler defect.
     
    dan1138Here is an implementation I have used with several baseline PIC controllers

     
    Thanks for sharing your code, interesting function! Apparently you had the same problem with function parameters. Also interesting use of XORWF to switch the output.
    As for the clock I tested my function with success with its 4MHz internal osc and stock OSCCAL value. My calculations:
    - Instruction: 1us
    - Optimal bit time: 1/115200 = 8,68us
    - Actual bit time: 9us (Dev: 0,32us per bit)
    - Start bit: 7us to compensate (0,32us x 4 = 1,28us): almost centered in the 4th bit
     
    9us per bit means it gains 0,32us lag per bit so the last bit is off 2,88us (33%), might work depending on the sample point of the receiver but it is getting too far. In my function the start bit is 7us which aligns better all the bits in their sampling points, so now the 4th bit is almost centered and the first and last bits are off by -/+ half of what it was before. Of course that assumes the receiver syncs to the beginning of the start bit which may not be always the case.
    I've run tests with a PC serial port through a MAX232 and the PIC sending repeatedly a text with no errors. Might need more tests.
    #13
    dan1138
    Super Member
    • Total Posts : 3651
    • Reward points : 0
    • Joined: 2007/02/21 23:04:16
    • Location: 0
    • Status: offline
    Re: Using C function parameters in asm 2020/01/15 19:29:16 (permalink)
    +1 (1)
    There are some possible issues with this part of your implementation:
    send_loop:
    RRF send_serial@data,F     // Next data bit into Carry
    BCF SERIAL_TX              // OUT=0
    BTFSC CARRY_bit            // If CARRY=1
    BSF SERIAL_TX              // OUT=1

    This causes the TX line to pulse low for 2 instruction cycles between adjacent one bits.
     
    This also means the transitions from one to zero occur 2 instruction cycles sooner than zero to one transitions.
     
    This is why I am using the XORWF to toggle the TX output state though that does require pre-processing the data to be sent so CARRY indicates when the state of the TX output should change.
    #14
    dan1138
    Super Member
    • Total Posts : 3651
    • Reward points : 0
    • Joined: 2007/02/21 23:04:16
    • Location: 0
    • Status: offline
    Re: Using C function parameters in asm 2020/01/15 19:42:01 (permalink)
    0
    <EDIT>
    Fix timing issue with start bit.
    </EDIT>
     
    You can get the timing from your implementation by tweaking my code like this:
    #define SERIAL_TX_BIT   _GPIO_GP5_POSITION
    #define SERIAL_TX_MASK  _GPIO_GP5_MASK
    /*
     * Bit-bang serial output.
     *  10-bit data frame: <Start bit><lsb> ... <msb><Stop bit>
     *
     * Bit rate is FCYC/9, this will run at 115200 buad (mostly) using the internal 4MHz oscillator.
     */
    void send_serial(unsigned char data)
    {
        __asm(" bcf   GPIO," ___mkstr(SERIAL_TX_BIT)); // start bit
        __asm(" movwf send_serial@data ");
        __asm(" rrf   send_serial@data,F");
        __asm(" xorwf send_serial@data,F");
        __asm(" bsf   send_serial@data,7");
        __asm("SendLoop:");
        __asm(" movlw "      ___mkstr(SERIAL_TX_MASK));
        __asm(" btfsc STATUS,0 ");
        __asm(" xorwf GPIO,F");
        __asm(" clrc  ");
        __asm(" rrf   send_serial@data,F");
        __asm(" movf  send_serial@data,F");
        __asm(" btfss STATUS,2 ");
        __asm(" goto SendLoop");
        __asm(" goto nx1");
        __asm("nx1: nop");
        __asm(" bsf   GPIO," ___mkstr(SERIAL_TX_BIT)); // stop bit
    }

    post edited by dan1138 - 2020/01/19 15:49:59
    #15
    j.paul
    New Member
    • Total Posts : 11
    • Reward points : 0
    • Joined: 2020/01/08 14:10:41
    • Location: 0
    • Status: offline
    Re: Using C function parameters in asm 2020/01/18 20:27:06 (permalink)
    0
    dan1138You can get the timing from your implementation by tweaking my code like this:

     
    Thanks! In fact mixing your XORLW method with my timings results in a nice function. I think your start bit is 6us where 7us would be better, here is my revision tested and working:
     
    #define SERIAL_TX GP4_bit
    #define SERIAL_TX_MASK 0b00010000

    void send_serial(unsigned char data)
    {
    // Send byte to SERIAL_TX at 115200 bps

    // Instruction: 1us
    // Optimal bit time: 1/115200 = 8,68us
    // Actual bit time: 9us (Dev: 0,32us per bit)
    // Start bit: 7us to compensate (0,32us x 4 = 1,28us):
    // almost centered in the 4th bit

    //Note: Standard C 90 must be set to accept #asm
    #asm
    bcf SERIAL_TX // Start bit
    movwf send_serial@data
    rrf send_serial@data,F
    xorwf send_serial@data,F // Calculate inversions
    bsf send_serial@data,7 // Loop untill all bits sent
    SendLoop:
        movlw SERIAL_TX_MASK
        btfsc CARRY_bit
        xorwf GPIO,F // Invert output
        bcf CARRY_bit
        rrf send_serial@data,F // Next bit
        movf send_serial@data,F
        btfss ZERO_bit // while(data)
    goto SendLoop
    goto $+1 // Delay
    bsf SERIAL_TX // Stop bit
    nop
    #endasm
    }

     
    I also removed the first 'clrc' that does not seem useful.
     
    1and0Try this:
    void send_serial(volatile unsigned char data)
    {
        data = data + '\0';
        // ...

     
    Thanks! Adding 'data = data + 0;' for all parameters and local variables anywhere in the function results in the expected code, of course wasting two instructions per variable. Then the compiler inserts the expected 'movwf ...' at the beginning and assigns each variable a different memory position. Careful that these instructions overwrite W, I have put them at the end so I can rely on W containing the parameter value at the beginning.
    Note that '\0' is interpreted as ASCII '0' (0x30) and modifies the value, a 0 works fine.
     
    For send_serial it is enough to add 'movwf...', it saves some program words and we have optimized the timings including the movwf after the start bit. But more complex functions can't be fixed that way because it is not only the missing movwf, also the compiler reuses memory positions, you can see in the compiled listing two variables both replaced by '__pcstackBANK0'.
     
    Adding 'volatile' only supresses the compilation warning but does not change generated code. Adding 'var = var + 0;' at the end for all parameters and local variables fixes the problem: then the movwf is inserted and each variable assigned a unique memory position.
     
    XC8 manual says the compiler looks in ASM code for use of variables, that must be broken. Do you consider that a bug? Should it be reported?
    If not a bug, there should be a way to tell the compiler a variable must be assigned even if not used. Maybe volatile should have some effect.
     
    post edited by j.paul - 2020/01/19 10:55:59
    #16
    1and0
    Access is Denied
    • Total Posts : 10930
    • Reward points : 0
    • Joined: 2007/05/06 12:03:20
    • Location: Harry's Gray Matter
    • Status: offline
    Re: Using C function parameters in asm 2020/01/18 21:40:14 (permalink)
    0
    j.paul
    Thanks! In fact mixing your XORLW method with my timings results in a nice function. I think your start bit timing is 6us, here is my revision tested and working:

    Your data bit time is 9 us, except the last bit which is only 8 us.
     

    Thanks! Adding 'data = data + 0;' for all parameters and local variables anywhere in the function results in the expected code, of course wasting two instructions per variable. Then the compiler inserts the expected 'movwf ...' at the beginning and assigns each variable a different memory position. Careful that these instructions overwrite W, I have put them at the end so I can rely on W containing the parameter value at the beginning.
    Note that '\0' is interpreted as ASCII '0' (0x30) and modifies the value, a 0 works fine.

    I tried +0 but it did not work; but now it works. No idea what's happened. That's why I used +'\0' which by the way is not the ASCII '0'; it is the null character with a numeric value of 0. 
     

    Adding 'volatile' only supresses the compilation warning but does not change generated code. Adding 'var = var + 0' at the end for all parameters and local variables fixes the problem: the movwf is inserted and each variable assigned a unique memory position.

    Without 'volatile' the statement 'data = data + 0;' does not work and generates no code.
     

    XC8 manual says the compiler looks in ASM code for use of variables, that must be broken. Do you consider that a bug? Should it be reported?
    If not a bug, there should be a way to tell the compiler a variable must be assigned even if not used. Maybe volatile should have some effect.

    IMO, it is a bug and volatile should fix it but it does not. Yes, please submit a ticket to Microchip.
     
     
    #17
    j.paul
    New Member
    • Total Posts : 11
    • Reward points : 0
    • Joined: 2020/01/08 14:10:41
    • Location: 0
    • Status: offline
    Re: Using C function parameters in asm 2020/01/19 07:18:31 (permalink)
    0
    I was talking about the start bit duration that I increased to 7us in my revision. The following bits are 9us and the stop bit 8us, these are the intended timings. The last bit starts 1,28us late so 1us less produces an almost correct frame duration.
     
    You are right, without volatile the assembler does not see the variable, and '\0' compiles as 0x0. Don't know what I did yesterday that I was getting 0x30. So the problem that should be addressed in a ticket is that volatile does not force a local variable to be assigned and created by the compiler.
     
    XC8 v2.10 manual for PIC: page 163 section 4.12.3.5 UNDEFINED SYMBOLS
    If an object is defined in C source code, but is only accessed in assembly code, the
    compiler might ordinarily remove the object believing it is unused, resulting in an undefined
    symbol error.
    To work around this issue, MPLAB XC8 searches for symbols in assembly code that
    have no assembly definition (which would typically be a label). If these symbols are
    encountered in C source they are automatically treated as being volatile (see
    Section 4.4.8.2 “Volatile Type Qualifier”), which will prevent them from being removed.

     
    This part could work, even if forced volatile they are not preserved.
     
    Page 118 section 4.4.8.2 VOLATILE TYPE QUALIFIER
    A common use of the volatile keyword is to prevent unused global variables being
    removed.

     
    Hmmm.. says global variables. May not be implemented for local variables.
     
    A C statement that consists only of a volatile variable identifier will produce code
    that reads the variable’s memory location and discards the result.

     
    Tried that but does not work. The compiler accepts 'variable;' as a sentence but does not act like 'variable = variable + 0;'.
     
    post edited by j.paul - 2020/01/19 07:39:06
    #18
    1and0
    Access is Denied
    • Total Posts : 10930
    • Reward points : 0
    • Joined: 2007/05/06 12:03:20
    • Location: Harry's Gray Matter
    • Status: offline
    Re: Using C function parameters in asm 2020/01/19 09:04:53 (permalink)
    0
    j.paul
    I was talking about the start bit duration that I increased to 7us in my revision. The following bits are 9us and the stop bit 8us, these are the intended timings. The last bit starts 1,28us late so 1us less produces an almost correct frame duration.

    Your start bit is 7 us. The first 7 data bits are 9 us each, but the last data bit is only 8 us. The stop bit starts at BSF SERIAL_TX; so if there is a back-to-back send_serial() calls, the stop bit is 8 us (BSF, RETLW, MOVLW, CALL, GOTO). That yields a 10-bit frame of 86 us. Baud rate of 115200 has a 10-bit frame of 86.8 us, so making the last data bit 9 us (as Dan did in Post #15) might be better.
     

    So the problem that should be addressed in a ticket is that volatile does not force a local variable to be assigned and created by the compiler.

    Yup.
     
    post edited by 1and0 - 2020/01/19 10:14:07
    #19
    j.paul
    New Member
    • Total Posts : 11
    • Reward points : 0
    • Joined: 2020/01/08 14:10:41
    • Location: 0
    • Status: offline
    Re: Using C function parameters in asm 2020/01/19 11:03:20 (permalink)
    0
    That's right, back to back calls were missing 1us. I added a 'nop' at the end after the BSF (edited the function at my previous post). That way the last bit is 8us and the stop bit 9us. I think that centers better the last transition at its theorical point.
     
    I'm looking to open a ticket.
     
    Thank you for your support!
     
    #20
    Page: 12 > Showing page 1 of 2
    Jump to:
    © 2020 APG vNext Commercial Version 4.5