IO-Link driver using UARTE and EndTx event.

RE: IO-Link driver using UARTE and EndTx event.

Hung Bui — Wed, 14 Aug 2019 15:25:54 GMT

Would adding any hardcoded timing helps? Sorry that I'm not very familiar with IO-link.

RE: IO-Link driver using UARTE and EndTx event.

robertfirma — Tue, 13 Aug 2019 07:56:46 GMT

Hi,

Yes, problem is that TXEND and TXDRDY are fired after last data bit and not after parity and stop bit witch is important in my situation.

In IO-link and also in RS-485 communication you must enable transmiter before first byte was send (this is not a problem) and disable after all bits are sent including parity and stop bit.

RE: IO-Link driver using UARTE and EndTx event.

Hung Bui — Mon, 12 Aug 2019 13:59:30 GMT

Hi Robert,

I double checked the spec and it says:

When all bytes in the TXD buffer, as specified in the TXD.MAXCNT register, have been transmitted, the
UARTE transmission will end automatically and an ENDTX event will be generated.

This meant the ENDTX will be triggered after the last byte is clocked out. Not when it's transmitting.

So ENDTX and the last TXDRDY will come at the same time. My last suggestion was wrong.

I did a logic trace here and it confirmed what in the spec:

You can see that TXDRDY and ENDTX came at the same time. And they come after the last bit of the last byte is clocked. I'm not sure why in your question you mentioned " Event ENDTX is fired before all transmited bytes are send."

RE: IO-Link driver using UARTE and EndTx event.

robertfirma — Sat, 10 Aug 2019 10:34:39 GMT

Hi,

Yes, I do this sequence with ENDTX.

1. Wait for ENDTX.

2. Enable TXRDY interrupt and wait for them. But this interrupt never came.

Regarding this picture I was shore that this interrupt came after ENDTX.

Could you test, if this sequence work.

Regarding this picture, I think that TXRDY interrupt must came after last stop bit was send.

Is this true?

This is my interrupt service rutine. Code came only to EVENTS_ENDTX.

inline void clNRF52Uart::isr (void)
{
	volatile u32_t dummy;
	volatile u32_t inten = port->INTEN;

	/*if(port->EVENTS_RXSTARTED){
		port->EVENTS_RXSTARTED = 0;
		dummy = port->EVENTS_RXSTARTED;
		//port->RXD.PTR = (u32_t)buf1;
	}*/

	/*if(port->EVENTS_RXDRDY){
		port->EVENTS_RXDRDY = 0;
		dummy = port->EVENTS_RXDRDY;
		//if(port->EVENTS_ERROR == false){
			//port->TASKS_FLUSHRX = 1;
			//LedBLUE->OutToggle();
		//}
	}*/

	if(inten & (1<<17) ){
		if(port->EVENTS_RXTO){
			port->INTENCLR = (1<<17);
			port->EVENTS_RXTO = 0;
			dummy = port->EVENTS_RXTO;
			k_sem_give(&sem);
		}
	}

	if(inten & (1<<9) ){
		if(port->EVENTS_ERROR){
			port->INTENCLR = (1<<9);
			port->EVENTS_ERROR = 0;
			dummy = port->EVENTS_ERROR;
			comerr = port->ERRORSRC;
			port->ERRORSRC = comerr;
			port->INTENSET = (1<<17);
			port->TASKS_STOPRX = 1;
		}
	}

	if(inten & (1<<4) ){
		if(port->EVENTS_ENDRX){
			port->INTENCLR = (1<<4);
			port->EVENTS_ENDRX = 0;
			dummy = port->EVENTS_ENDRX;
			if(comerr == 0) k_sem_give(&sem);
			//q.Fire(&onrx, (void*)((u32_t)buf[0]));
		}
	}

	if(inten & (1<<20) ){
		if(port->EVENTS_TXSTARTED){
			port->INTENCLR = (1<<20);
			port->EVENTS_TXSTARTED = 0;
			dummy = port->EVENTS_TXSTARTED;
			//LedBLUE->OutClr();
			//tc->AlarmSet(txtime, 0, this);
		}
	}

	if(inten & (1<<7) ){
		if(port->EVENTS_TXDRDY){
			port->INTENCLR = (1<<7);
			port->EVENTS_TXDRDY = 0;
			dummy = port->EVENTS_TXDRDY;
			k_sem_give(&semtx);
		}
	}

	if(inten & (1<<8) ){
		if(port->EVENTS_ENDTX){
			port->INTENCLR = (1<<8);
			port->EVENTS_ENDTX = 0;
			dummy = port->EVENTS_ENDTX;

			port->EVENTS_TXDRDY = 0;
			dummy = port->EVENTS_TXDRDY;
			port->INTENSET = (1<<7); // enable txdrdy
			//k_sem_give(&semtx);
			//tc->AlarmSet(txtime, 0, this);
		}
	}

}

int clNRF52Uart::Write ( u8_t * Data , u16_t Size )
{
	port->EVENTS_ENDTX = 0;
	volatile u32_t dummy = port->EVENTS_ENDTX;
	port->INTENSET = (1<<8); //enable endtx

	//txtime = tc->TicksFrom_us(420);
	port->TXD.PTR = (u32_t)Data;
	port->TXD.MAXCNT = Size;
	port->TASKS_STARTTX = 1;

	k_sem_take(&semtx, K_FOREVER);

	return port->TXD.AMOUNT;
}

RE: IO-Link driver using UARTE and EndTx event.

Hung Bui — Fri, 09 Aug 2019 13:41:46 GMT

Hi Robert,

You are right, ENDTX comes when the last byte is being clocked out. But the TXDRDY event of the last byte should come after the byte is clocked. Maybe you can catch the TXDRDY after you receive ENDTX. It will be the TXDRDY of the last byte.

I'm not aware of that RX buffer is being affected even TASK_STARTRX is not called. Is it possible to reproduce it using our example ? Have you made sure there is no PPI or SHORT that can trigger the task ?