Eclairage "poussé" pour aquarium

[AmadeusHF]

Bon, j'ai pas mal avancé ce soir. Je suis content, ça faisait plus de 10 ans que j'avais pas fait un PCB...mais c'est un peu comme le vélo, ça s'oublie pas.

Je vous ai fait quelques photos, mais avec l'iPhone et trop peu de lumière (soir), ça donne pas grand chose. On a quand meme une idée du résultat :

1.jpg

2.jpg

3.jpg

4.jpg

5.jpg

Les petits circuits (4 exemplaires) ce sont les drivers de leds. 2cm x 2cm en taille réelle.

Le plus grand (enfin...5 par 4...) c'est la carte embarquant le 16F690, ainsi que les condos de filtrage du 12v (pour gagner de la place sur les drivers), le régulateur pour produire le 5V du pic ainsi que les picots qui vont recevoir tous les fils (5 par driver, il y a du diming...) et les 4 fils en provenance du futur coeur de controle.

J'ai pris le temps d'assembler un driver, pour donner une idée du résultat. La carte PIC est terminée quant à elle...mais je n'ai plus le courage de faire des tests pour ce soir.

@Termi : voila un exemple de source pour ta carte 16F690. Il compilera directement sous MPLAB avec le compilateur HiTec. Si tu utilises un compilo autre, il faudra adapter les includes et les noms des flags du word de config (voir certains noms de registres / bits de registres). Dis moi ce que tu en penses

Tu peux modifier le résultat obtenu en choisissant la fonction appelée (il y a trois appels, n'en garde qu'un seul actif, les deux autres restent en commentaire.

C'est dans la fonction "timer1" que ça se passe :

Code : Tout sélectionner

		//chenillard();
		//gradateur();
		variateur();

ATTENTION : c'est du code très porc, j'ai fait ça sans structurer quoi que ce soit...mais çà marche.

Code : Tout sélectionner

#include <htc.h>
#include <pic16f685.h>

//
// INTCON bits
//

#define INTERRUPT_CONTROL_GLOBAL_INTERRUPT_ENABLE		0b10000000
#define INTERRUPT_CONTROL_PERIPHERAL_INTERRUPT_ENABLE	0b01000000
#define INTERRUPT_CONTROL_TIMER0_OVERFLOW_ENABLE		0b00100000
#define INTERRUPT_CONTROL_EXTERNAL_INTERRUPT_ENABLE		0b00010000
#define INTERRUPT_CONTROL_PORTA_PORTB_ENABLE			0b00001000
#define INTERRUPT_CONTROL_TIMER0_0VERFLOW_FLAG			0b00000100
#define INTERRUPT_CONTROL_EXTERNAL_INTERRUPT_FLAG		0b00000010
#define INTERRUPT_CONTROL_PORTA_PORTB_FLAG				0b00000001

//
// PIE1 bits
//

#define PERIPHERAL_INTERRUPT_ENABLE_1_TIMER1			0b00000001

//
// T1CON bits
//

#define TIMER1_CONTROL_GATE_INVERTED					0b10000000
#define TIMER1_CONTROL_GATE_ENABLE						0b01000000
#define TIMER1_CONTROL_PRESCALE_1_8						0b00110000
#define TIMER1_CONTROL_PRESCALE_1_4						0b00100000
#define TIMER1_CONTROL_PRESCALE_1_2						0b00010000
#define TIMER1_CONTROL_PRESCALE_1_1						0b00000000
#define TIMER1_CONTROL_LP_OSCILLATOR_ENABLE				0b00001000
#define TIMER1_CONTROL_EXTERNAL_NOSYNC					0b00000100
#define TIMER1_CONTROL_EXTERNAL_CLOCK					0b00000010
#define TIMER1_CONTROL_ENABLE							0b00000001

__CONFIG
( 
	INTIO 		// Internal clock, no clock output
  & MCLRDIS		// Master Clear is disabled
  & WDTDIS 		// Watchdog timer disabled
  & PWRTDIS 	// Power-Up timer disabled
  & BORDIS 		// Brown Out Detect disabled
  & UNPROTECT	// Code is not protected
);

char volatile enabled = 1;
int volatile counter = 1;
int volatile direction = 1;

void chenillard(void)
{
	if (enabled)
	{
		if (direction == +1)
			counter <<= 1;
		else
			counter >>= 1;

		if (counter == 0x8)
		{
			direction = -1;
		}
		else if (counter == 1)
		{
			direction = +1;
		}

		// Write port output

		PORTC = counter;
	}
}

int niveaux[4] = { 1, 5, 10, 20};
int divider = 0;
int cpt2[4] = { 0, 5, 10, 15};
int delta[4] = { 1, 1, 1, 1};

const char bitsets[21][20]=
{
	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 0
	{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 1
	{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 2
	{ 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 }, // 3
	{ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 }, // 4
	{ 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 }, // 5
	{ 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0 }, // 6
	{ 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0 }, // 7
	{ 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0 }, // 8
	{ 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0 }, // 9
	{ 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 }, // 10
	{ 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0 }, // 11
	{ 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0 }, // 12
	{ 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0 }, // 13
	{ 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0 }, // 14
	{ 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0 }, // 15
	{ 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0 }, // 16
	{ 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0 }, // 17
	{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0 }, // 18
	{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 }, // 19
	{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }  // 20
};

void gradateur(void)
{
	char bits = 0;
	int mask = 1;

	if (enabled==1)
	{
		for (int i=0;i<4;i++)
		{
			int n = niveaux[i];
			char flag = bitsets[n][counter];
			if (flag == 1)
			{
				bits |= mask;
			}
	
			mask <<= 1;		
		}

		counter++;
		if (counter>=20)
			counter = 0;
			
	}

	PORTC = bits;

	TMR1H = 0xFF;
	TMR1L = 0x80;
}

void variateur(void)
{
	char bits = 0;
	char mask = 1;

	if (enabled==1)
	{
		for (int i=0;i<4;i++)
		{
			char flag = bitsets[cpt2[i]][counter];
			if (flag == 1)
			{
				bits |= mask;
			}
			mask <<= 1;
		}			
	
		counter++;
		if (counter>=20)
		{
			counter = 0;
			divider++;

			if (divider == 1)
			{
				divider = 0;

				for (int j=0;j<4;j++)
				{
					cpt2[j] += delta[j];
					if ((cpt2[j] >= 20) || (cpt2[j]<=0))
					{
						delta[j] = -delta[j];
					}
				}
			}
		}
	}

	PORTC = bits;

	TMR1H = 0xFF;
	TMR1L = 0x80;
}

void interrupt timer1(void)
{
	if ((TMR1IE)&&(TMR1IF))
	{
		//chenillard();
		//gradateur();
		variateur();

		// Clear the timer interrupt bit
		TMR1IF=0;
	}
}

void init(void)
{
	// Enable port A as output
	TRISA = 0b00000000;
	PORTA = 0b00000000;
	TRISA = 0b11111111;
	ANSEL = 0b00000000;
	IOCA = 0b00000000;

	// Enable port C as output
	TRISC = 0b00000000;
	PORTC = 0b00000001;


	// Setup timer 1 
	OPTION = 0b10000000;
	T1CON = TIMER1_CONTROL_PRESCALE_1_1 | TIMER1_CONTROL_ENABLE;

	// Enable timer1 interruption and peripheral interruption (timer1 is a peripheral)
	PIE1 |= PERIPHERAL_INTERRUPT_ENABLE_1_TIMER1;
	INTCON |= INTERRUPT_CONTROL_PERIPHERAL_INTERRUPT_ENABLE;
}

char lastA = 0;

void main(void)
{
	init();
	ei();

	lastA = PORTA & 0x08;

	while (1)
	{
		_delay(5000);

		char newA = PORTA & 0x08;

		if (newA != lastA)
		{
			lastA = newA;
			if (enabled)
			{
				enabled = 0;
			}
			else
			{
				enabled = 1;
			}
		}
	}
}

[Termi87]

OUllllaaa , merci ^^! Moi je suis sous MikroC comme JC, j'ai aussi MPLAB, mais lui il n'est pas conçu pour du language C...
Je te remercie pour tout ce code. ^^

[AmadeusHF]

Pour MPLAB, tu télécharges le compilateur HiTec C depuis le site de Microchip et tu l'installes (en version LITE), et tu auras le support du C sous MPLAB avec ce compilo. C'est ce que je fais perso...

[jC_Omega]

oui MPLAB est un IDE, c'est a dire juste une interface de programmation, sous MPLAB on peut programmer avec plein de compilateur ( a condition qu'il soit installer) compilo C18, HITECH, etc) et en language C, ASM...

Amadeus, il y a un truc que je comprend pas dans ton programme : a quoi te serve toute tes table et matrise? c'est les animations enregistré? (ca manque un peu de commentaire^^ )

Pour Termi : vus que la plupart de mes vieux projet a base de led RGB ( à 24 sortie PWM ) on été fait sous MIKROC, je peut te passer les sources.
Je fait un peu comme Amadeus, j'utilise 1 Timer en interruption, pour me générer mes top et ainsi faire mon PWM, mais je fait légèrement différents, je trouve bcp plus simplement (dans ma boucle interruption je fait juste des comparaison de valeurs (entre valeur timer et valeur PWM qu'on veut) et je mets à 1 ou 0 la sortie correspondante).


Mais Termi pour faire ca, il te faudra te perfectionner un peu plus en language C et surtout comprendre les fonctions avancer d'un PIC (registre, timer, interruptions...). (le programme d'Amadeus peut très bien être convertie aussi)



Sur la carte drivers de led, j'ai crus comprend que tu utilisé des LM3404, ca reviens pas trops cher le drivers de led? (car je viens de voir les prix chez farnell... et ca reviens bien cher le drivers + les compo autour), ou alors a tu des bonnes adresse pour les compo? (moi par exemple je cherche des PIC18LF4550 en CMS pas cher(PIC 18F en basse tension avec USB à 44 pattes)

[AmadeusHF]

Pour les LM3404, comme je te l'ai dit dans un autre post, c'est parce que j'étais parti sur cette option déjà avant de trouver d'autres solutions. Y a des drivers moins cher, toute une floppée...mais bon sur le budget total du projet, ça n'est pas tellement un problème. Et puis il a l'avantage d'être assez connu et donc on trouve des réalisations qui marchent déjà avec, des aides pour calculer les composants....c'est un plus aussi !
Dans l'ensemble, chaque driver va me revenir 'en gros' à 7€ pièce.

Concernant les tables dans le code : il y a différentes manières de calculer la pulsation pour un PWM. On peut faire une base de temps fixe, et faire un delta horloge, comme tu le fais. Pour faire simple dans mon code, j'ai pré-calculé une équi-répartition des pulsations pour 21 palliers de luminosité : 0, 5%, 10%.....95%, 100%. De cette manière, je n'ai aucun calcul à faire. J'ai la même base de temps pour chaque canal (j'en pilote 4) et pour un canal donné, je maintiens juste un index dans la table. J'étais au point "N", à l'interruption suivante je passe au point "N+1" qui me dit tout de suite si le canal est à 0 ou à 1. Cette manière permet d'éviter tout calcul dans l'interruption, et donc d'être très rapide (meme si le calcul de temps n'est pas bien méchant). Comme le PIC a une flash conséquente, qui ne sert finalement pas beaucoup (le code est très court), je déclare la table en "const", et donc elle est dans la flash...pas dans la RAM ou l'EEPROM. Ca permet de maximiser le temps disponible pour toute autre fonction. Ca permet également de ne pas être lié à la fréquence d'horloge...on peut modifier la vitesse du timer à volonté, ça ne change pas le taux de pulsation. La seule contrainte c'est de ne pas tomber trop bas, sinon on voit apparaitre le clignotement...

Comme je l'ai indiqué dans mon post, c'est du code "porc" fait en 2 heures au total, installation, lecture de la doc, débug et tests inclus. J'ai juste fait mumuse avec la carte de développement, donc oui il n'y a pas de commentaires. Ca c'est pour la version finale, et le code sera propre, structuré et commenté, c'est certain

[Termi87]

Ok ok, c'est du boulot de chefs ça ^^, je suis encore quelques crans en dessous de vous moi les gas . Effectivement, il faut que j'apprenne...encore et encore... c'est pour cela que de toute façon je ne suis pas pressé. J'ai déjà mes 2 autres projets à finir, d'ailleurs je vais câbler mon tabouret cette aprem . Je vous tiendrez au courant bien-sûr.

Les méthodes décrites par JC me semble plus "structuré"/compréhensible, pour moi. En plus sans commentaires ... m'enfin il y en aura à dit le chef amadeusHF ^^ . L'avantage avec JC, c'est que je me suis adapté à ce qu'il a, et donc, j'essaye de fonctionner comme lui... ce qui est plus pratique pour évoluer et comprendre, quand on a les même choses.

[AmadeusHF]

Boah l'important c'est que tu t'y retrouves. De toute façon il y a autant de manière de programmer que...de programmeurs ! Et chacun est persuadé que c'est sa propre approche la meilleure. C'est ce qui fait le charme de notre boulot.

Alors si tu t'y retrouves, changes rien

Après, ben tu as des exemples de sources, ça peut te donner des idées / t'aider à comprendre. C'est ça l'important.

[Termi87]

Voilà, on est d'accord . Merci

[jC_Omega]

Boah l'important c'est que tu t'y retrouves. De toute façon il y a autant de manière de programmer que...de programmeurs ! Et chacun est persuadé que c'est sa propre approche la meilleure. C'est ce qui fait le charme de notre boulot.

Alors si tu t'y retrouves, changes rien
.

oui tout a fait, comme je l'ai deja dit a termi peut importe le compilateur ou language, le but est de faire simple et surtout de comprendre ce qu'on fait.

Pour un non electronicien en numérique, c'est dur dur de commencer au debut (je me souviens a mes debut a l'école), mais il y aller progressivement.
j'ai conseiller MikroC, c'est c'est un compilateur qui va bien au debutant, pas besoin de ce soucier des librairies, de certaines configurations (bien sur il y a moyen de tout faire manuellement).
par exemple hop j'ai besoin d'une tempo de 1s... hop Delay_MS(1000); besoin de mettre le PWM (hardware bien sur) à 50%, hop PWM1_Set_Duty(128);

car je me rend compte sous des compilo pro, c'est bcp plus la misère (en tout cas sous C18), pour faire une simple tempo, ou une mesure analogique.... on est obliger de tout créer soit même

[AmadeusHF]

Une bonne nouvelle pour mon projet : Luxeonstar m'a notifié de l'expédition de ma commande. Avec un peu de chance j'aurais reçu mes 40 leds d'ici à la fin de la semaine prochaine. Faut que je me fasse la main sur l'assemblage au four !