Yep!
Alors je dois m'y prendre comme un pied car je tourne en rond depuis ce week-end.
Le cycle est relativement simple, binaire, mais comme tout ce qui est simple, je le complique...
Il s'agit d'une séquence binaire d'allumage/extinction de leds avec un peu de dimming afin d'anticiper le cycle suivant.
Ce qui m'énerve énormement, c'est de taper de nombreuses lignes de code identique.
J'ai pensé à créer une classe, une fonction dynamique, cependant mes connaissances du c++ sont presques au bout ou à bout.
Je sens que je passe à côté d'une solution simple et évidente. Peut-être que vous la verrez avant moi ???
/*
ATTiny2313
OC0A PB2
OC1A PB3
OC1B PB4
### PINS CONFIGURATION ###
DDRB
*/
#include <avr/io.h>
#include <util/delay.h>
//#include <avr/pgmspace.h>
#define _wait 500
#define _ms 50
#define _sleep 5000
#define dim 50
byte redVal = 0;
byte greenVal = 0;
byte blueVal = 0;
boolean _init = true;
void setup()
{
TCCR0A = 0x81;
TCCR1A = 0xA1;
TCCR1B = 0x3;
DDRB = B00011100;
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t");
}
void loop()
{
if(_init)
{
for(byte i = 0; i < dim; i++)
{
fade(i, 0, 0);
}
_init = false;
}
else
{
// ##################### 100 #####################
for(byte i = dim; i < 255; i++)
{
fade(i, 0, 0);
}
_delay_ms(_sleep);
for(byte i = 255; i > dim; i--)
{
fade(i, 0, 0);
}
for(byte i = dim; i > 0; i--)
{
fade(i, (dim-i), 0); _delay_ms(_ms);
}
// ##################### 010 #####################
for(byte i = dim; i < 255; i++)
{
fade(0, i, 0);
}
_delay_ms(_sleep);
for(byte i = 255; i > dim; i--)
{
fade(0, i, 0);
}
for(byte i = dim; i > 0; i--)
{
fade(0, i, (dim-i)); _delay_ms(_ms);
}
// ##################### 001 #####################
for(byte i = dim; i < 255; i++)
{
fade(0, 0, i);
}
_delay_ms(_sleep);
for(byte i = 255; i > dim; i--)
{
fade(0, 0, i);
}
for(byte i = dim; i > 0; i--)
{
fade((dim-i), i, i); _delay_ms(_ms);
}
// ##################### 101 #####################
for(byte i = dim; i < 255; i++)
{
fade(i, 0, i);
}
_delay_ms(_sleep);
for(byte i = 255; i > dim; i--)
{
fade(i, 0, i);
}
for(byte i = dim; i > 0; i--)
{
fade(i, (dim-i), i); _delay_ms(_ms);
}
// ##################### 011 #####################
for(byte i = dim; i < 255; i++)
{
fade(0, i, i);
}
_delay_ms(_sleep);
for(byte i = 255; i > dim; i--)
{
fade(0, i, i);
}
for(byte i = dim; i > 0; i--)
{
fade((dim-i), i, i); _delay_ms(_ms);
}
// ##################### 110 #####################
// ##################### 111 #####################
}
}
void fade(byte redVal, byte greenVal, byte blueVal)
{
OCR1A = redVal;
OCR1B = greenVal;
OCR0A = blueVal;
delay(_wait);
}
/*
COMPUTATION
100 {a}
^ 110 {b}
---
010
byte c = a ^ b;
a & (1 << 3) ? i : 0; // test bit 3 from {a}
*/
Il y a une routine évidente, la difficulté est de placer les variables de la fonction fade() au bon endroit au bon moment à partir d'un cycle prédefini:
for(byte i = dim; i < 255; i++)
{
fade(0, i, 0);
}
_delay_ms(_sleep);
for(byte i = 255; i > dim; i--)
{
fade(0, i, 0);
}
for(byte i = dim; i > 0; i--)
{
fade(0, i, (dim-i)); _delay_ms(_ms);
}
Merci pour votre aide.
@+
Zoroastre.
Je me disais bien qu'il y avait quelque chose de bizarre. 
:*
