Parallel to Serial Converter

RE: Parallel to Serial Converter

Simon — Thu, 28 Feb 2019 14:24:15 GMT

Why don't you set the output pins in the for (;;) function in main()? Using the interrupt handler requires some extra cycles as explained earlier. Regarding the question about Out1 and Out2, you could take a look at the fork mechanims of PPI.

I simplified the IRQHandler, but I don't think it will make much difference regarding speed:

void optimized_TIMER2_IRQHandler(void)
{
	NRF_TIMER2->EVENTS_COMPARE[0] = 0;	       //Clear compare register 0 event
	NRF_GPIO->OUTSET = (1UL << 30);
	
	if(b[lect]){
		NRF_GPIO->OUTSET = (1UL << 28) | (1UL << 29);  
	}else{
		NRF_GPIO->OUTCLR = (1UL << 28) | (1UL << 29);	
	}
	if(lect<7){
		lect++;
	}else{
		lect=0;
	}
}

Best regards,

Simon

RE: Parallel to Serial Converter

norbe13 — Tue, 26 Feb 2019 15:44:41 GMT

Thank you all for your help!

Finally I achieved that I wanted but only for 1 MHZ. I attach the code. I have to say that now (in the code is included) I need that Out has to be Out1 and Out2 with the same value but for two output pins. If somebody find a way to optimize the code, please tell me!

static void GPIO_TIMER_Init(void)
{  

		
		nrf_gpio_cfg_output(28); //Out1
		nrf_gpio_cfg_output(29); //Out2
		nrf_gpio_cfg_output(30); //Enable
		

	
	//GPIOTE FOR FLAG SIGNAL
						nrf_gpio_cfg_input(17, NRF_GPIO_PIN_NOPULL); // Enable pullup on the GPIO
						NRF_GPIOTE->CONFIG[0] = (GPIOTE_CONFIG_MODE_Event << GPIOTE_CONFIG_MODE_Pos) | 
																		(GPIOTE_CONFIG_POLARITY_HiToLo << GPIOTE_CONFIG_POLARITY_Pos) | 
																		(17 << GPIOTE_CONFIG_PSEL_Pos);
	//GPIOTE FOR CLOCK SIGNAL
						nrf_gpio_cfg_input(22, NRF_GPIO_PIN_NOPULL); // Enable pullup on the GPIO
						NRF_GPIOTE->CONFIG[1] = (GPIOTE_CONFIG_MODE_Event << GPIOTE_CONFIG_MODE_Pos) | 
																		(GPIOTE_CONFIG_POLARITY_LoToHi << GPIOTE_CONFIG_POLARITY_Pos) | 
																		(22 << GPIOTE_CONFIG_PSEL_Pos); 

														
														
	NVIC_DisableIRQ(TIMER2_IRQn);
  NVIC_ClearPendingIRQ(TIMER2_IRQn);

//TIMER FOR CLOCK 

  NRF_TIMER2->MODE = TIMER_MODE_MODE_Counter;              // Set the timer in Counter Mode
	NRF_TIMER2->SHORTS = TIMER_SHORTS_COMPARE0_CLEAR_Enabled << TIMER_SHORTS_COMPARE0_CLEAR_Pos;
  NRF_TIMER2->TASKS_CLEAR = 1;                             // clear the task first to be usable for later
	NRF_TIMER2->BITMODE = TIMER_BITMODE_BITMODE_08Bit;		   //Set counter to 16 bit resolution
	NRF_TIMER2->CC[0] = 1;                               //Set value for TIMER2 compare register 0
	

 NRF_TIMER2->INTENSET = (TIMER_INTENSET_COMPARE0_Enabled << TIMER_INTENSET_COMPARE0_Pos);
 NVIC_EnableIRQ(TIMER2_IRQn);
  
  //TIMER FOR ENABLE
	
	NRF_TIMER1->MODE = TIMER_MODE_MODE_Counter;              // Set the timer in Counter Mode
	NRF_TIMER1->SHORTS = (TIMER_SHORTS_COMPARE1_CLEAR_Enabled << TIMER_SHORTS_COMPARE1_CLEAR_Pos) |
											 (TIMER_SHORTS_COMPARE1_STOP_Enabled << TIMER_SHORTS_COMPARE1_STOP_Pos);
  NRF_TIMER1->TASKS_CLEAR = 1;                             // clear the task first to be usable for later
	NRF_TIMER1->BITMODE = TIMER_BITMODE_BITMODE_08Bit;		   //Set counter to 16 bit resolution
	NRF_TIMER1->CC[1] = 8;                               //Set value for TIMER2 compare register 1 


	NRF_PPI->CH[0].TEP = (uint32_t)&NRF_TIMER2->TASKS_START; //Start TIMER2
	NRF_PPI->CH[0].EEP = (uint32_t)&NRF_GPIOTE->EVENTS_IN[0];
	NRF_PPI->CHEN |= PPI_CHEN_CH0_Enabled << PPI_CHEN_CH0_Pos;

	NRF_PPI->CH[1].TEP = (uint32_t)&NRF_TIMER1->TASKS_START; //START TIMER1
	NRF_PPI->CH[1].EEP = (uint32_t)&NRF_GPIOTE->EVENTS_IN[0];
	NRF_PPI->CHEN |= PPI_CHEN_CH1_Enabled << PPI_CHEN_CH1_Pos;

	NRF_PPI->CH[2].TEP = (uint32_t)&NRF_TIMER2->TASKS_COUNT; //COUNT TIMER2
	NRF_PPI->CH[2].EEP = (uint32_t)&NRF_GPIOTE->EVENTS_IN[1];
	NRF_PPI->CHEN |= PPI_CHEN_CH2_Enabled << PPI_CHEN_CH2_Pos;
	
	NRF_PPI->CH[3].TEP = (uint32_t)&NRF_TIMER1->TASKS_COUNT; //COUNT TIMER1
	NRF_PPI->CH[3].EEP = (uint32_t)&NRF_GPIOTE->EVENTS_IN[1];
	NRF_PPI->CHEN |= PPI_CHEN_CH3_Enabled << PPI_CHEN_CH3_Pos;
	
	
	NRF_PPI->CH[6].TEP = (uint32_t)&NRF_TIMER2->TASKS_STOP; //STOP TIMER2
  NRF_PPI->CH[6].EEP = (uint32_t)&NRF_TIMER1->EVENTS_COMPARE[1];
  NRF_PPI->CHEN |= PPI_CHEN_CH6_Enabled << PPI_CHEN_CH6_Pos;
	

	
}

void TIMER2_IRQHandler(void)
{
		NRF_TIMER2->EVENTS_COMPARE[0] = 0;	       //Clear compare register 0 event
	
		
	
	if(lect<7)
    {
			
				if(b[lect]){
					NRF_GPIO->OUTSET = (1UL << 30);
					NRF_GPIO->OUTSET = (1UL << 28) | (1UL << 29);  
					
				}
				else{
					NRF_GPIO->OUTSET = (1UL << 30);
					NRF_GPIO->OUTCLR = (1UL << 28) | (1UL << 29);
					
				}
				lect++;
				}
				else{
					if(b[lect]){
					NRF_GPIO->OUTSET = (1UL << 30);
					NRF_GPIO->OUTSET = (1UL << 28) | (1UL << 29);  
					
				}
				else{
					NRF_GPIO->OUTSET = (1UL << 30);
					NRF_GPIO->OUTCLR = (1UL << 28) | (1UL << 29);
					}
				lect=0;
    }
    
}

 int main(void)
{
	
	// VARIABLE INITIALIZATION 
      lect=0;
			NRF_GPIO->OUTCLR = (1UL << 30);
			
	
	 // WAIT FOR HFCLK START
			NRF_CLOCK->TASKS_HFCLKSTART = 1;
			while(NRF_CLOCK->EVENTS_HFCLKSTARTED != 1){}
				
			GPIO_TIMER_Init();

        for (;;)
    {
				
				NRF_GPIOTE->EVENTS_IN[0]=0;
				
				
        if(NRF_TIMER1->EVENTS_COMPARE[1]){
				lect=0;
				NRF_GPIO->OUTCLR = (1UL << 30);}
				while(NRF_GPIOTE->EVENTS_IN[0] != 1){}
					
				}
		
		}
    }

RE: Parallel to Serial Converter

Dmitry — Mon, 25 Feb 2019 11:58:50 GMT

You can try to configure two GPIOTE OUT tasks via two PPI channels - one for setting, another for clearing output, and switch between them using PPI.CHEN register. A number of mcu cycles will be about the same, but you will get synchronous switching done by hardware, and a "window" to prepare PPI.CHEN according to next bit. Another point to optimize - all hardware registers are defined as volatile, so try to save EVENTS_IN[0] into a variable instead of reading it twice in two if() statements - you will save some cycles.

RE: Parallel to Serial Converter

Simon — Mon, 25 Feb 2019 10:28:52 GMT

It seems like the project with polling is the best way to go, since you achieved a higher frequency than the one using the interrupt handler. I am not sure how to solve it using PPI and EasyDMA.

In the code where you are polling the input, try switching out nrf_gpio_pin_toggle(..) with TASK_OUT[..], which will save you some clock cycles. First you need to create two different tasks, one for setting the pin low, and one for setting it high, then you call the appropriate task depending on b[a]. Also, turn on optimization when compiling your code, in order to make it a little faster.

[quote user="norbe13"]Another question that I have... what is the maximum frequency for a event_handler of GPIOTE? [/quote]

I have not calculated this, but it depends on the amount of code running in the interrupt handler. I think the interrupt latency on entry and the interrupt latency on exit is 12+10=22 cycles. If you add those cycles to the amount of cycles in the handler + everything running in the background, and eventually divide the CPU clock frequency (64MHz for the nRF52832) with the amount of cycles, you will get the frequency of the GPIOTE handler.

Best regards,

Simon

RE: Parallel to Serial Converter

norbe13 — Wed, 20 Feb 2019 16:03:08 GMT

I have just achieve to sent the information that I need to transfer but a maximum clock frequency of 500 kHz. This is the code that I employ. When I employ higher frequencies than 500 kHz, for example 1 MHz, the output code is correct, but the duration of the pulses is different for each value. I would like to know if there is a way to read a signal of 2 MHz by GPIO or GPIOTE and do and action related with a value of the RAM, Could I do something related with DMA? For example --> Clock --> GPIOTE --> DMA (read) --> RAM --> DMA (write) --> GPIOTE.

Another question that I have... what is the maximum frequency for a event_handler of GPIOTE?

static void gpio_init(void)
{

	
	nrf_gpio_cfg_input(22, NRF_GPIO_PIN_NOPULL);

	NRF_GPIOTE->CONFIG[0] =  (GPIOTE_CONFIG_POLARITY_LoToHi << GPIOTE_CONFIG_POLARITY_Pos)
                      | (22 << GPIOTE_CONFIG_PSEL_Pos)   
                      | (GPIOTE_CONFIG_MODE_Event << GPIOTE_CONFIG_MODE_Pos);
	
}


/**
 * @brief Function for application main entry.
 */
int main(void)
{
	
		NRF_CLOCK->TASKS_HFCLKSTART = 1;
		int a=7;
		bool b[8] = {1,0,1,0,1,0,1,0};
		
  
    nrf_drv_gpiote_init();
		nrf_gpio_cfg_output(28);

		gpio_init();;

    while (true)
    { 
			
			
			if(NRF_GPIOTE->EVENTS_IN[0] && a<7){
				NRF_GPIOTE->EVENTS_IN[0] = 0;
				if(b[a]){
					nrf_gpio_pin_set(28);
					a=a+1;
				}
				else{
					nrf_gpio_pin_clear(28);
					a=a+1;
				}}
			
				else if(NRF_GPIOTE->EVENTS_IN[0] && a==7)
				{ NRF_GPIOTE->EVENTS_IN[0] = 0;
				if(b[a]){
					nrf_gpio_pin_set(28);
					a=0;
				}
				else{
					nrf_gpio_pin_clear(28);
					a=0;
		}}





}}

Thank you!

RE: Parallel to Serial Converter

norbe13 — Wed, 20 Feb 2019 08:37:50 GMT

Is not possible because you can't change the clock of the SPI to 2 MHz

RE: Parallel to Serial Converter

norbe13 — Tue, 19 Feb 2019 20:12:35 GMT

Do you mean this connection? FLAG --> GPIOTE (INPUT RISING EDGE) --> PPI --> SPI (MASTER). Because the Flag is a bit that comes from a custom IC that is High when you can write in their Serial to parallel register, and I don't have anymore outputs from the IC.

RE: Parallel to Serial Converter

awneil — Tue, 19 Feb 2019 17:59:19 GMT

Could you not just use the SPI peripheral ... ?