Arduino for STM32

Code: Select all

        NVIC_DisableIRQ(TIM1_IRQn);  // Disable TIM1  interrupt
        NVIC_DisableIRQ(TIM2_IRQn);  
        NVIC_DisableIRQ(TIM3_IRQn);
        NEOPIXEL CODE HERE  //<<<NOTE THIS CODE doesnt use any timer
        NVIC_EnableIRQ(TIM1_IRQn);  // Disable TIM1  interrupt
        NVIC_EnableIRQ(TIM2_IRQn);  
        NVIC_EnableIIRQ(TIM3_IRQn);

Code: Select all

   __disable_irq();
   NEOPIXEL CODE HERE  // //<<<NOTE THIS CODE doesnt use any timer
   __enable_irq();

Code: Select all

TIM3->CR1 &= ~TIM_CR1_CEN;
TIM3->CCER &= ~(TIM_CCER_CC1E | TIM_CCER_CC2E | TIM_CCER_CC3E | TIM_CCER_CC4E);

   NEOPIXEL CODE HERE  // //<<<NOTE THIS CODE doesnt use any timer

TIM3->CCER |= (TIM_CCER_CC1E | TIM_CCER_CC2E | TIM_CCER_CC3E | TIM_CCER_CC4E);
TIM3->CR1 |= TIM_CR1_CEN;   //    

Code: Select all

while (SysTick->VAL > cyc);

Code: Select all

  // ...                       So a kind of horrible thing is done here...
  // since interrupts are turned off anyway and it's generally accepted
  // by now that we're gonna lose track of time in the NeoPixel lib,
  // the SysTick timer is reconfigured for a period matching the NeoPixel
  // bit timing (either 800 or 400 KHz) and we watch SysTick->VAL very
  // closely (just a threshold, no subtract or MOD or anything) and that
  // seems to work just well enough.  When finished, the SysTick
  // peripheral is set back to its original state.

Code: Select all

	uint8_t *p = pixels, *end = p + numBytes, pix = *p++, mask = 0x80;
	uint32_t cyc;
	uint32_t saveLoad = SysTick->LOAD, saveVal = SysTick->VAL;

	if (is800KHz) {

		uint32_t top = (F_CPU / 800000);       // 1.25µs
		uint32_t t0 = top - (F_CPU / 2500000); // 0.4µs
		uint32_t t1 = top - (F_CPU / 1250000); // 0.8µs
		SysTick->LOAD = top - 1; // Config SysTick for NeoPixel bit freq
		SysTick->VAL = 0;        // Set to start value
		for (;;) {
		  LL_GPIO_SetOutputPin(gpioPort, gpioPin);
		  cyc = (pix & mask) ? t1 : t0;
		  while (SysTick->VAL > cyc)
			;
		  LL_GPIO_ResetOutputPin(gpioPort, gpioPin);
		  if (!(mask >>= 1)) {
			if (p >= end)
			  break;
			pix = *p++;
			mask = 0x80;
		  }
		  while (SysTick->VAL <= cyc)
			;
		}

	} else {                                 // 400 kHz bitstream
		uint32_t top = (F_CPU / 400000);       // 2.5µs
		uint32_t t0 = top - (F_CPU / 2000000); // 0.5µs
		uint32_t t1 = top - (F_CPU / 833333);  // 1.2µs
		SysTick->LOAD = top - 1; // Config SysTick for NeoPixel bit freq
		SysTick->VAL = 0;        // Set to start value
		for (;;) {
		  LL_GPIO_SetOutputPin(gpioPort, gpioPin);
		  cyc = (pix & mask) ? t1 : t0;
		  while (SysTick->VAL > cyc)
			;
		  LL_GPIO_ResetOutputPin(gpioPort, gpioPin);
		  if (!(mask >>= 1)) {
			if (p >= end)
			  break;
			pix = *p++;
			mask = 0x80;
		  }
		  while (SysTick->VAL <= cyc)
			;
		}
	}

Code: Select all

	uint8_t *p = pixels, *end = p + numBytes, pix = *p++, mask = 0x80;
	uint32_t cyc;
	uint32_t saveLoad = SysTick->LOAD, saveVal = SysTick->VAL;

	if (is800KHz) {

		uint32_t top = (F_CPU / 800000);       // 1.25µs
		uint32_t t0 = top - (F_CPU / 2500000); // 0.4µs
		uint32_t t1 = top - (F_CPU / 1250000); // 0.8µs
		SysTick->LOAD = top - 1; // Config SysTick for NeoPixel bit freq
		SysTick->VAL = 0;        // Set to start value
		for (;;) {
		  LL_GPIO_SetOutputPin(gpioPort, gpioPin);
		  cyc = (pix & mask) ? t1 : t0;
		  while (SysTick->VAL > cyc)
			;
		  LL_GPIO_ResetOutputPin(gpioPort, gpioPin);
		  if (!(mask >>= 1)) {
			if (p >= end)
			  break;
			pix = *p++;
			mask = 0x80;
		  }
		  while (SysTick->VAL <= cyc)
			;
		}

	} else {                                 // 400 kHz bitstream
		uint32_t top = (F_CPU / 400000);       // 2.5µs
		uint32_t t0 = top - (F_CPU / 2000000); // 0.5µs
		uint32_t t1 = top - (F_CPU / 833333);  // 1.2µs
		SysTick->LOAD = top - 1; // Config SysTick for NeoPixel bit freq
		SysTick->VAL = 0;        // Set to start value
		for (;;) {
		  LL_GPIO_SetOutputPin(gpioPort, gpioPin);
		  cyc = (pix & mask) ? t1 : t0;
		  while (SysTick->VAL > cyc)
			;
		  LL_GPIO_ResetOutputPin(gpioPort, gpioPin);
		  if (!(mask >>= 1)) {
			if (p >= end)
			  break;
			pix = *p++;
			mask = 0x80;
		  }
		  while (SysTick->VAL <= cyc)
			;
		}
	}

Code: Select all

		uint32_t top = (F_CPU / 800000);       // 1.25µs
		uint32_t t0 = top - (F_CPU / 2500000); // 0.4µs
		uint32_t t1 = top - (F_CPU / 1250000); // 0.8µs
		

Code: Select all

#include <Adafruit_NeoPixel.h>
#define PIN_NEOPIXELS PB15
#define PIN_T3_CH_3_PWM PB0_ALT1

#define CONF_DELAY_MS_NEOPIXELS_PARA_SHOW 1
#define DATOS_NUM_NEOPIXELS_RELOJ 30

Adafruit_NeoPixel neopixels_(DATOS_NUM_NEOPIXELS_RELOJ, PIN_NEOPIXELS, NEO_GRBW + NEO_KHZ800);

uint32_t T3_channel_3;
HardwareTimer *gTimer3PWM = new HardwareTimer(TIM3); 


void setup() {
    pinMode(PIN_NEOPIXELS, OUTPUT); 
    neopixels_.begin();

    T3_channel_3 = STM_PIN_CHANNEL(pinmap_function(digitalPinToPinName(PIN_T3_CH_3_PWM), PinMap_PWM));
        
    gTimer3PWM->setMode(T3_channel_3, TIMER_OUTPUT_COMPARE_PWM1, PIN_T3_CH_3_PWM);   
    gTimer3PWM->setOverflow(10000, MICROSEC_FORMAT); 
    gTimer3PWM->setCaptureCompare(T3_channel_3, 50, PERCENT_COMPARE_FORMAT); 
    gTimer3PWM->attachInterrupt(IRQ_T3_Update_IT_callback); ///OVERFLOW IRQ
    gTimer3PWM->attachInterrupt(T3_channel_3, IRQ_T3_Compare_IT_callback);
    gTimer3PWM->resume();   //<<se activa el timer en PUESTA EN CONTACTO


}

void loop() {

    Set_neopixels_Color_NO_PWM( 210,230,0,100);
    delay(250);
    Set_neopixels_Color_NO_PWM(0,0,0,0);
    delay(1);    
    Set_neopixels_Color_PWM( 80,107,200,90);
    delay(250);
    Set_neopixels_Color_PWM(0,0,0,0);
    delay(1);

}



       
void Set_neopixels_Color_NO_PWM(byte a_r, byte a_g, byte a_b, byte a_w){
    /*aca se quiere poner un color de neopixels, que puede venir de un array, o con los bytes individuales*/
    byte byte_r = 0;
    byte byte_g = 0;
    byte byte_b = 0;
    byte byte_w = 0;

    byte_r = a_r;
    byte_g = a_g;
    byte_b = a_b;
    byte_w = a_w;

    for(int i_led=0; i_led<DATOS_NUM_NEOPIXELS_RELOJ; i_led++) {
        neopixels_.setPixelColor(i_led, neopixels_.Color(byte_r, byte_g, byte_b, byte_w));
        //DEF_DELAY_MICROSECONDS_ENTRE_NEOPIXELS
    }///for

    TIM3->CR1 &= ~TIM_CR1_CEN;
    TIM3->CCER &= ~(TIM_CCER_CC1E | TIM_CCER_CC2E | TIM_CCER_CC3E | TIM_CCER_CC4E);
    
    neopixels_.show();

    TIM3->CCER |= (TIM_CCER_CC1E | TIM_CCER_CC2E | TIM_CCER_CC3E | TIM_CCER_CC4E);
    TIM3->CR1 |= TIM_CR1_CEN;   //        

    delay(CONF_DELAY_MS_NEOPIXELS_PARA_SHOW); ///ver este delay

}


void Set_neopixels_Color_PWM(byte a_r, byte a_g, byte a_b, byte a_w){
    /*aca se quiere poner un color de neopixels, que puede venir de un array, o con los bytes individuales*/
    byte byte_r = 0;
    byte byte_g = 0;
    byte byte_b = 0;
    byte byte_w = 0;

    byte_r = a_r;
    byte_g = a_g;
    byte_b = a_b;
    byte_w = a_w;

    for(int i_led=0; i_led<DATOS_NUM_NEOPIXELS_RELOJ; i_led++) {
        neopixels_.setPixelColor(i_led, neopixels_.Color(byte_r, byte_g, byte_b, byte_w));
        //DEF_DELAY_MICROSECONDS_ENTRE_NEOPIXELS
    }///for

    
    neopixels_.show();
    delay(CONF_DELAY_MS_NEOPIXELS_PARA_SHOW); ///ver este delay

}

void IRQ_T3_Update_IT_callback(void){ // Update event correspond to Rising edge of PWM when configured in PWM1 mode
}

void IRQ_T3_Compare_IT_callback(void){ // Compare match event correspond to falling edge of PWM when configured in PWM1 mode
}