[avr] library van c++ naar c omzetten

void delay_ms(unsigned int ms)
{
    for (; ms > 0; ms--) {
	_delay_ms(0.99);
    }
}

	delay_ms(wait);

if(pixels != NULL) free(pixels);
// Omzetten naar
if(pixels) free(pixels);

if(pixels != NULL) free(pixels);
// Omzetten naar
if(pixels) free(pixels), pixels = NULL;

implicit declaration of function 'memset' [-Wimplicit-function-declaration]
incompatible implicit declaration of built-in function 'memset' [enabled by default]
'b' may be used uninitialized in this function [-Wuninitialized]
'g' may be used uninitialized in this function [-Wuninitialized]
'r' may be used uninitialized in this function [-Wuninitialized]

uint32_t Wheel(uint16_t WheelPos)
{
	uint8_t r, g, b;
	switch(WheelPos / 128)
	{
		case 0:
		r = 127 - WheelPos % 128;   //Red down
		g = WheelPos % 128;      // Green up
		b = 0;                  //blue off
		break;
		case 1:
		g = 127 - WheelPos % 128;  //green down
		b = WheelPos % 128;      //blue up
		r = 0;                  //red off
		break;
		case 2:
		b = 127 - WheelPos % 128;  //blue down
		r = WheelPos % 128;      //red up
		g = 0;                  //green off
		break;
	}
	return(Color(r,g,b));
}

/****************************************************

LPD8806 RGB Ledstrip library

****************************************************/

#define F_CPU 8000000UL

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>


uint16_t numLEDs, numBytes;
uint8_t *pixels;


void SPI_init(void){

	DDRB = ((1<<DDB3)|(1<<DDB5)|(1<<DDB2)); //spi pins on port b MOSI SCK,SS outputs

	SPCR = ((1<<SPE)|(1<<MSTR)|(1<<SPR0)|(1<<CPOL)|(1<<CPHA));  // SPI enable, Master, f/16

}

char SPI_Transmit(char cData){

	SPDR = cData;
	while(!(SPSR & (1<<SPIF)))
	;
	return SPDR;
}

void delay_ms(unsigned int ms)
{
	for (; ms > 0; ms--) {
		_delay_ms(0.99);
	}
}

void updateLength(uint16_t n) {
	uint8_t latchBytes = (n + 31) / 32;
	if(pixels != NULL) free(pixels); // Free existing data (if any)
	numLEDs    = n;
	n         *= 3; // 3 bytes per pixel
	numBytes   = n + latchBytes;
	if(NULL != (pixels = (uint8_t *)malloc(numBytes))) { // Alloc new data
	memset( pixels   , 0x80, n);          // Init to RGB 'off' state
	memset(&pixels[n], 0   , latchBytes); // Clear latch bytes
} else numLEDs = numBytes = 0; // else malloc failed
// 'begun' state does not change -- pins retain prior modes
}


// Set pixel color from 'packed' 32-bit GRB (not RGB) value:
void setPixelColor(uint16_t n, uint32_t c) {
	if(n < numLEDs) { // Arrays are 0-indexed, thus NOT '<='
	uint8_t *p = &pixels[n * 3];
	*p++ = (c >> 16) | 0x80;
	*p++ = (c >>  8) | 0x80;
	*p++ =  c        | 0x80;
}
}

void show(void) {
	uint8_t  *ptr = pixels;
	uint16_t i    = numBytes;

	while(i--) {
		SPI_Transmit(*ptr++);
	}
}

uint16_t numPixels(void) {
	return numLEDs;
}

// Convert separate R,G,B into combined 32-bit GRB color:
uint32_t Color(uint8_t r, uint8_t g, uint8_t b) {
	return ((uint32_t)(g | 0x80) << 16) |
	((uint32_t)(r | 0x80) <<  8) |
	b | 0x80 ;
}

// Chase one dot down the full strip.
void colorChase(uint32_t c, uint8_t wait) {
	int i;

	// Start by turning all pixels off:
	for(i=0; i<numPixels(); i++) setPixelColor(i, 0);

	// Then display one pixel at a time:
	for(i=0; i<numPixels(); i++) {
		setPixelColor(i, c); // Set new pixel 'on'
		show();              // Refresh LED states
		setPixelColor(i, 0); // Erase pixel, but don't refresh!
		delay_ms(wait);
	}

	show(); // Refresh to turn off last pixel
}

// Fill the dots progressively along the strip.
void colorWipe(uint32_t c, uint8_t wait) {
	int i;

	for (i=0; i < numPixels(); i++) {
		setPixelColor(i, c);
		show();
		delay_ms(wait);
	}
}

//Input a value 0 to 384 to get a color value.
//The colours are a transition r - g -b - back to r
uint32_t Wheel(uint16_t WheelPos)
{
	uint8_t r, g, b;
	switch(WheelPos / 128)
	{
		case 0:
		r = 127 - WheelPos % 128;   //Red down
		g = WheelPos % 128;      // Green up
		b = 0;                  //blue off
		break;
		case 1:
		g = 127 - WheelPos % 128;  //green down
		b = WheelPos % 128;      //blue up
		r = 0;                  //red off
		break;
		case 2:
		b = 127 - WheelPos % 128;  //blue down
		r = WheelPos % 128;      //red up
		g = 0;                  //green off
		break;
	}
	return(Color(r,g,b));
}

void rainbow(uint8_t wait) {
  int i, j;
   
  for (j=0; j < 384; j++) {     // 3 cycles of all 384 colors in the wheel
    for (i=0; i < numPixels(); i++) {
      setPixelColor(i, Wheel( (i + j) % 384));
    }  
    show();   // write all the pixels out
    delay_ms(wait);
  }
}

// Slightly different, this one makes the rainbow wheel equally distributed
// along the chain
void rainbowCycle(uint8_t wait) {
	uint16_t i, j;
	
	for (j=0; j < 384 * 5; j++) {     // 5 cycles of all 384 colors in the wheel
	for (i=0; i < numPixels(); i++) {
		// tricky math! we use each pixel as a fraction of the full 384-color wheel
		// (thats the i / strip.numPixels() part)
		// Then add in j which makes the colors go around per pixel
		// the % 384 is to make the wheel cycle around
		setPixelColor(i, Wheel( ((i * 384 / numPixels()) + j) % 384) );
	}
	show();   // write all the pixels out
	delay_ms(wait);
}
}