/***********************************************************************
par Silicium628
 
========================================================================
ATmega32 + afficheur LCD 5110 Nokia
Enregistreur d'octets rapide sur SDcard en mode RAW
 
************************************************************************/
 
/**
REMARQUE CONCERNANT L'UTILISATION DE CE PROGRAMME POUR LE CONTROLE DE LA MACHINE CNC :
 
	Mémorisation numérique (dans une SDcard) du tracé pour contôle sans tracé physique puis tracé à l'écran par un soft en Qt4.
	La fréquence max envoyée aux cartes EasyDriver en vitesse rapide est = 2500Hz soit 5000 évènements/s (puisque 2 moteurs)
	Si l'on veut mémoriser toutes les impulsions moteur envoyées, chaque évènement étant défini par 2bits (moteur , sens ),
	chaque octet peut mémoriser 8bits/2bits = 4 évènements, 
	5000/4 = 1250 octets/s (= 10 kbits/s)
	si on veut mémoriser 1/2h de tracé, il faut 1250 octets/s * 1800s = 2.25MB. -> la RAM du Mega2560 = 8kB soit 280 fois moins !!
	utiliser un processeur ARM ? un Raspberry Pi2 quad core ?
	Plus simplement cette acquisition externe par un ATmega8 connecté sur les sorties des signaux, qui mémorise dans une SDcard.
	1250 octets/s * 1800s / (512 octets/blocs) = un peu moins de 4400 blocs.
	(1250 oct/s) / (512 oct/blocs) =  2.44 blocs/s -> écriture de 1 bloc toutes les 0.41s 
 
	4400 blocs x (512 octets/bloc) = 2252800  octets = 2200 kB = 2MB.
	vitesse d'enregistrement max : les 2252800 octets peuvent être écrits en 24s soit 184 blocs/s ou 94 kB/s = 750 kbits/s (750kHz) soit 75 fois plus rapide que la vitesse requise ici.
	En pratique, et sans utiliser le double buffering, ce programme peut enregistrer à 22 kB/s (22kHz). On enregistre dans le buffer que l'on est en train de graver sur la SDcard...
 
	Le resultat enregistré sur la SDcard (non partitionnée !) est récupérable sous linux par la commande "dd" suivante:
	"sudo dd if=/dev/sdc of=nom_fichier bs=512 count=100"  en adaptant bien sûr "sdc" à la valeur correspondant réellement à la SDcard dans le système.
	On obtient un fichier lisible sous linux avec jeex puisque écrit en binaire.
	Ce fichier est interprétable (et traçable) par le soft en Qt4 associé à ce programme.
**/
 
/*
 ==================  PARAMETRES NUMERIQUE DE CE PROGRAMME ============================================================================================
 
(Les tempo sont mesurées à l'oscillo et/ou fréquencemètre) et non pas calculées exactement au simulateur
OCR0 = 10; -> un octet est présenté toutes les 45us c.a.d avec une fréquence de 22kHz (pour test avec acquisition interne par Timer0))
-Un enregistrement de 1 block (=512 octets) se fait en 8ms en moyenne avec quelques rares "coups" à 16ms (? deux blocs à la fois ????)
-Le buffer de 512 octet se remplit en 512 x 45us = 23ms
-Le temps de repos pendant lequel il n'y a pas d'écriture sur la carte = 23ms-8ms= 15ms; On voit très bien ce temps de 15ms à l'oscillo
-Chaque octet est enregistré sur la carte en 8ms/512 = 15us soit moins que la période d'arrivée des octets qui est rappelons le de 45us soit 3x plus longue.
 
CE QUI SE PASSE:
A l'instant où le buffer est plein, on dispose de 45us avant qu'un octet ne se présente à l'enregistrement en début du buffer.
Lorsque cet octet incident arrive, on a déjà enregistré les trois premier octets du buffer sur la carte, lorsque le deuxième octet arrive on a enregistré 6 octets
et ainsi de suite, de telle manière que l'adresse de stockage des octets entrants dans le buffer ne rattrape jamais celle des octets lus pour être expédié dans la SDcard.
Ceci es important de façon à ce que les octets arrivant n'écrasent pas des octets pas encore enregistrés: Le serpent ne doit pas se mordre la queue !
Il n'y a donc aucune perte de signal, tout ce qui arrive est enregistré sur la carte.
 
======================================================================================================================================================
//*/
 
 
//#define F_CPU 16000000
 
 
//#define ACQ_INTERNE
 
#include <avr/io.h>
#include <stdint.h> 
#include <stdlib.h>
#include "timeout.h"   // comprend : #define F_CPU 16000000UL  // 16 MHz
#include <avr/interrupt.h>
#include "LCD_5110-628b.cpp" // penser à paramétrer correctement les ports et bits popur le LCD dans le fichier "LCD_5110-628b.h"
#include <math.h>
 
#include "SDcard_628_2.c"
 
const char * version = "v:3.1";
 
 
#define PORT_led PORTD
#define bit_LED_verte 0b00010000
#define bit_LED_rouge 0b00100000
 
 
	uint16_t err;
	uint8_t octet_out;
	uint8_t n_evnt; // (=0..3) à mesure que l'octet_out se construit
	uint16_t adr_octet; // dans le block (=0..511)
	volatile uint32_t num_block;
	uint8_t compteur1;
	volatile uint16_t compteur2 = 0x0000;
	volatile uint8_t flag_ecrire_block = 0x00;  //  'volatile' afin qu'elle soit prise en compte par l'interruption
	volatile uint8_t c;
	volatile char string1[16+1] = "00000_dataRecord";
	uint8_t flag_acquisition;
 
// static uint8_t buffer[BLOCK_SIZE];  // BLOCK_SIZE est défini dans "sdCard.h"
 
 
void init_ports (void)
// 0 = entree, 1=sortie   ;   les 1 sur les pins en entrees activent les R de Pull Up (tirage à VCC)
{
	DDRB  = 0b10111111;	// PB6 en entrée (MISO)
	PORTB = 0b11101111;	// PB4=0 (CS)
 
// le pin_CS est définit dans le fichier SD_routines628.h	
 
  DDRC = 	0b11111111;	
  PORTC = 0b00000000;
 
  DDRD =  0b11110000; // PortD[0..3] = entrées (int0=STEP moteur1, int1=STEP moteur2 , DIR moteur1 et DIR moteur1)
  PORTD = 0b00000000;
}
 
 
void InitINTs (void)
{
 
	GICR 		|=  0b11000000;  // gere les INTs - bit6  ->INT0 request - bit7  ->INT1 request;  voir page 68 du pdf ATmega8A
  MCUCR		|=  0b00001010;  // Falling edge of INT0 (et INT1) generates an interrupt request.  p:67 du pdf
 
 
	TCCR0 = 0;
	TCCR0  |= 0b00001000;	// Timer0 en mode CTC (Clear Timer on Compare Match): WGM00=1 (bit6) et WGM01=0 (bit3) voir p:74 et 80
	TCCR0  |= 0b00000011;	// Timer0 prescaller = f=clk/64.	0CS0[2,1,0] = 011 voir p:80 et p:82
	TIMSK  = 0b00000010;	// Timer/Counter0, Output Compare Match Interrupt Enable; Voir datasheet ATmega32 p:82	
 
	OCR0 = 10;	// Timer0 (freq = 250/n environ) : n=249->1kHz;  126->2kHz;    50->5kHz;   30->8kHz;   20 -> 12kHz;  10-> 22kHz;  5->41kHz;   2->83kHz;
 
}
 
 
void init_variables(void)
{
	flag_ecrire_block=0;
	flag_acquisition=0;
	err=0;
	octet_out=0;
	n_evnt=0; 
	adr_octet=0;
	num_block=1; // je reserve le bloc zero
	compteur1=0;
	compteur2=0;
}
 
 
 
void num2string(uint16_t nb_i, volatile char str_i[17])  // remarque: ce tableau de caractères est implicitement passé par adresse, son contenu sera donc changé chez l'appelant
{
/** RAPPEL :
	Lors du passage d'un tableau en paramètre d'une fonction, la conversion implicite a lieu, les tableaux sont donc toujours passés par variable, jamais par valeur.
	Il est donc faux d'utiliser des pointeurs pour les passer en paramètre, car le paramètre aurait le type pointeur de tableau.
	On ne modifierait pas le tableau, mais bel et bien le pointeur du tableau.	Le programme aurait donc de fortes chances de planter.
**/	
//surcharge les 5 premiers caratères de la chaine avec les caratères	représentant le nombre transmis
	uint8_t i, r;
	for (i=1; i<=5; i++) 
	{
		r=48 + nb_i % 10; // % c'est le modulo (reste de la division)
		nb_i /= 10; // quotient
		str_i[5-i]=r;  // surcharge le début de la ligne (les "0") avec le num
	}
}
 
 
void num2string_bin(uint16_t nb_i, volatile char str_i[17])  // remarque: ce tableau de caractères est implicitement passé par adresse, son contenu sera donc changé chez l'appelant
{
/** RAPPEL :
	Lors du passage d'un tableau en paramètre d'une fonction, la conversion implicite a lieu, les tableaux sont donc toujours passés par variable, jamais par valeur.
	Il est donc faux d'utiliser des pointeurs pour les passer en paramètre, car le paramètre aurait le type pointeur de tableau.
	On ne modifierait pas le tableau, mais bel et bien le pointeur du tableau.	Le programme aurait donc de fortes chances de planter.
**/	
//surcharge les 2 premiers caratères de la chaine avec le nombre trransmis  
 
	str_i[0] = nb_i >> 8;
	str_i[1] = nb_i & 0xFF;
}
 
 
 
void bufferise_octet(uint8_t octet_i)
{
// buffer est définit dans "sdCard_628.h"  c'est -> volatile uint8_t buffer[512];
 
	buffer[adr_octet] = octet_i;
 
	compteur1++;	if (compteur1 > 50) {compteur1 =0;   PORT_led  ^= bit_LED_verte; }
	adr_octet++;
	if (adr_octet > 511)
	{
		adr_octet =0;
		flag_ecrire_block = 1;  // l'écriture du block se fera dans la boucle principale, hors de l'INT donc.
	}
}
 
 
 
void complete_octet(uint8_t bibit)
{
	octet_out <<= 2; // décallage de deux bits à gauche, des zéros sont insérés à droite. Attention : si oubli du '=' pas de modif de la variable
	octet_out += bibit;
 
	n_evnt++;
	if (n_evnt > 3)
	{
		n_evnt=0;
		bufferise_octet(octet_out);
		octet_out=0;
	}
}
 
 
 
ISR (BADISR_vect)
{
// évite de planter si une int est enable et pas de procedure associée écrite (ce qui fait reseter l'ATmega)
}
 
 
 
ISR (INT0_vect) 
{
#ifndef ACQ_INTERNE
//interruption sur front descendant sur l'entree Int0
	if (flag_acquisition==1) // bloque lors de la phase d'init
	{
		uint8_t etat;
		etat = PIND & 0b00000001; 
		if (etat == 0)	{	complete_octet(0b01);	}	else {	complete_octet(0b00);	}
	}
#endif
}
 
 
ISR (INT1_vect) 
{
#ifndef ACQ_INTERNE
 
//interruption sur front descendant sur l'entree Int1
	if (flag_acquisition==1) // bloque lors de la phase d'init
	{
		uint8_t etat;
		etat = PIND & 0b00000010; 
		if (etat == 0)	{	complete_octet(0b11);	}	else {	complete_octet(0b10);	}
	}
 
#endif	
}
 
 
 
ISR (TIMER0_COMP_vect) // acquisition "interne "pour tests
{
#ifdef ACQ_INTERNE
	if (flag_acquisition==1) // bloque lors de la phase d'init
	{
		PORT_led |= bit_LED_verte;
//complete_octet(compteur2 & 0b00000011); // (compteur2 && 0b00000011) = [00..01..10..11..]
 
//		char string1[16+1] = "00000_dataRecord";
 
		//num2string(compteur2, string1);
		num2string_bin(compteur2, string1);
 
		bufferise_octet(string1[c]);
		c++;
		if (c > 15)
		{
			c = 0;
			compteur2++;
		}
		PORT_led &= ~bit_LED_verte;
	}
#endif		
}
 
 
 
 
void raz_buffer()
{
	uint16_t i;
	for (i=0; i<=512; i++)
	{
		buffer[i] = '-';
	}
}
 
 
 
 
void fill_buffer_Char(uint16_t num) // num est le numéro de block qui sera écrit en début de ligne
{
	uint8_t c, r;
	uint16_t k;
 
	//--------------------"1234567890123456"
//char string1[16+1] = "00000solarImpuls";
//char string1[16+1] = "00000silicium628";
//char string1[16+1] = "00000tagadapouet";
//char string1[16+1] = "00000tartalacrem";
//char string1[16+1] = "00000hello World";
//char string1[16+1] = "00000doremifasol";
//char string1[16+1] = "00000_dataRecord";
char string1[16+1] = "00000===========";
 
 
	num2string(num, string1);
 
	c = 0;
	for (k=0; k<=512; k++)
	{
		buffer[k] = string1[c]; 
		c++;
		if (c > 15) { c = 0; }
	}
}
 
 
 
void fill_buffer_Int()
{
	uint16_t i;
	uint8_t c;
	c = 0;
	for (i=0; i<=512; i++)
	{
		buffer[i] = c;
		c++;  // c = 1 octet = 0..255
	}
}
 
 
 
int main (void)
{
	uint16_t i;
	uint32_t adresse1;
	uint8_t ok=0;
 
 
	unsigned char option, error, data, FAT32_active;
 
	init_variables(); 
	init_ports();
	InitINTs();
	lcd_init();
 
	lcd_clear();
	_delay_ms(300);
 
	lcd_puts("SDcrd Recorder");
	lcd_goto_LC(1, 0);
	lcd_puts(version);
	_delay_ms(1000);
	lcd_clear();
 
	sei();
 
	cardType = 0;
 
	lcd_puts("init...");
	lcd_goto_LC(1,0);
 
	SPI_SetSlow();
 
	for (i=0; i<10; i++)
	{
		error = SD_init();
		if(!error) break;
	}
 
	if(error)
	{
		if(error == 1)	{	lcd_puts("SD no detect");	}
		if(error == 2) 	{	lcd_puts("SD Init fail");	}
		lcd_goto_LC(2, 0);
    lcd_puts("faire un reset");
		while(1) { ; }  
	}
 
	switch (cardType)
	{
		case 1:lcd_puts("Std Card 1.x");
		break;
		case 2:lcd_puts("SDHC Card ok");
		break;
		case 3:lcd_puts("Std Card 2.x");
		break;
		default:lcd_puts("SDcard ?");
		break; 
	}
 
	SPI_SetFast();
 
	_delay_ms(1000);
	lcd_clear();
 
	lcd_goto_LC(1, 0);
	lcd_puts("Effacement...");
 
	uint16_t n;
 
	fill_buffer_Int();
	SD_writeSingleBlock(0); // remplit le bloc zéro avec des entiers [0..511] On pourra y enregistrer tout autre chose, comme la longueur de l'enregistrement par exemple
 
	for (n=1; n<2000; n++)  //200 pour tests;  ensuite 2000 ou plus... à voir
	{
		fill_buffer_Char(n);
//PORT_led  |= bit_LED_verte;
		SD_writeSingleBlock(n);
//PORT_led  &= ~bit_LED_verte;
		lcd_goto_LC(2,0);
		lcd_aff_nb (n, 4, 0);
	}
 
 
	lcd_goto_LC(2, 0);
	lcd_puts("Erase SDcrd ok");
	_delay_ms(1000);
	lcd_goto_LC(4, 1);
	lcd_puts("RECORDING...");
 
	_delay_ms(100);
 
	num_block=1;
	flag_acquisition=1;
 
	while(1)
	{
		if (flag_ecrire_block == 1)
		{
PORT_led |= bit_LED_rouge;
//_delay_us(200);
 
//flag_acquisition=0;
		SD_writeSingleBlock(num_block);  // écriture du buffer plein (qui n'est plus en cours) sur la SDcard.
		num_block++;
//flag_acquisition=1;
 
 
PORT_led &= ~bit_LED_rouge;			
 
			flag_ecrire_block = 0;
		}
		//_delay_ms(300);
	}
}
 
 

/*
Enregistreur SDcard
Programme écrit par Silicium628
ce logiciel est libre et open source
*/
 
#include "mainwindow.h"
#include "math.h"
#include <QFile>
#include <QFileDialog>
#include <QTextStream>
#include <QDebug>
#include "boutonled.cpp"
#include "qled.cpp"
#include <QMessageBox>
#include <QTextCodec>
#include <QTimer>
 
#include <QMouseEvent>
 
 
QString version = "3.5";
 
QColor blanc = QColor::fromRgb(0xFFFFFF);
QColor noir = QColor::fromRgb(0x000000);
QColor gris_fonce = QColor::fromRgb(0x4D4D4D);
QColor gris_clair = QColor::fromRgb(0xBFBFBF);
QColor rouge = QColor::fromRgb(0xFF0000);
QColor vert = QColor::fromRgb(0x008000);
QColor vert_clair = QColor::fromRgb(0x90EE90);
QColor vert_fonce = QColor::fromRgb(0x003300);
QColor vert_tres_fonce = QColor::fromRgb(0x001A00);
QColor bleu = QColor::fromRgb(0x0000FF);
QColor bleu_clair = QColor::fromRgb(0x1E90FF);
QColor bleu_fonce = QColor::fromRgb(0x000066);
QColor bleu_tres_fonce = QColor::fromRgb(0x00001A);
QColor orange = QColor::fromRgb(0xFF9500);
QColor jaune = QColor::fromRgb(0xFFFF00);
QColor jaune_clair = QColor::fromRgb(0xFFFFBF);
QColor jaune_fonce = QColor::fromRgb(0xB9B100);
QColor cyan = QColor::fromRgb(0x00FFFF);
QColor cyan_fonce = QColor::fromRgb(0x00CCCC);
QColor violet = QColor::fromRgb(0x800080);
QColor rose_pale = QColor::fromRgb(0xFFC0CB);
 
//----------------------------------------------
QColor couleur_ecran = bleu_tres_fonce;
 
QColor couleur_piste = jaune;
//QColor couleur_piste = gris_fonce;
 
QColor couleur_quadrillage1 = QColor::fromRgb(0x303030);
QColor couleur_quadrillage2 = QColor::fromRgb(0x508888);
QColor couleur_texte = QColor::fromRgb(0x888888);
 
QPen pen_trace(couleur_piste, 0, Qt::SolidLine);
QPen pen_texte(couleur_texte, 1, Qt::SolidLine);
QPen pen_quadrillage(couleur_quadrillage1,0, Qt::SolidLine);
//--------------------;--------------------------
 
 
int x_scene, y_scene;
 
QList <Element> liste_elements; // tous types confondus, segments et pastilles
QString fileName_en_cours;
 
 
 
float zoom;
quint8 ech; // echelle = 4, 8, 80 pour 1/4, 1/8, 1/80 ;  1/4 signifie 4 pas pour 1 pixel à lécran.
quint8 systeme_mesure; // 1 (mm) ou 2 (mils US)
 
char datas_in[2000000];
quint32 nb_octets=1000; // ajusté à la valeur exacte plus bas
quint32 compteur_pas=0;
qint32 pos_moteur1, pos_moteur2;
QPointF pos_actuelle;
qint32 X_max =0;
qint32 Y_max =0;
 
qint16 offset_X =800;
qint16 offset_Y =800;
 
int x_0, y_0;
int x_clic_scene, y_clic_scene; // coordonnees du pixel clique
int x_dyn, y_dyn, delta_x, delta_y;
qint32 y_max = 10000;
 
 
 
QString msg ="";
 
 
qreal sqr(qreal r1)
{
    return r1 * r1;
}
 
 
QString valeur2txt2(int v1)
{
    QString s;
    s.setNum(v1);  // conversion num -> txt
    s = "00"+s;
    s = s.right(2);
    return s;
}
 
 
QString valeur2txt4(int v1)
{
    QString s;
    s.setNum(v1);  // conversion num -> txt
    s = "0000"+s;
    s = s.right(4);
    return s;
}
 
 
 
 
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent)
{
 
    setupUi(this);
    setWindowTitle("Traceur SDcard v:" + version + "  - Silicium628");
    window()->setGeometry(0,0,1280,900);
 
    pixmap1 = new QPixmap(10300,10300 );
    scene1 = new SceneCliquable(this);
 
 
   // QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
 
  //  QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
  //  QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
    QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
 
    pen_trace.setCapStyle(Qt::RoundCap); // plume ronde
 
    lecture_fichier_init();
 
    lineEdit_1->setText(fileName_en_cours);
    lire_fichier(fileName_en_cours);
 
    systeme_mesure = 1;
    zoom = 1;
    ech=8;
    effacer_ecran(); // et crée les groupes héritiers de la scene ainsi que la connexion entre les clics et le slot ici concerné
 
 
}
 
 
 
MainWindow::~MainWindow()
{
 
}
 
 
 
void MainWindow::effacer_ecran()
{
    pixmap1->fill(vert_tres_fonce); // rappel :  pixmap1 = 12010,12010
 
    scene1->clear();
    scene1 = new SceneCliquable(this);
    connect(scene1, SIGNAL(envoiPosition_survol(int, int) ), this, SLOT (onReceptPos_survol(int, int) ));
    connect(scene1, SIGNAL(envoiPosition_clic(int, int) ), this, SLOT (onReceptPos_clic(int, int) ));
    connect(scene1, SIGNAL(envoiPosition_release(int, int) ), this, SLOT (onReceptPos_release(int, int) ));
 
    scene1->setBackgroundBrush(couleur_ecran);
    scene1->setSceneRect(-100,-100,10500,10500); // plus grand que la partie affichée
    graphicsView1->setScene(scene1);
    graphicsView1->setGeometry(5,25,1000,800); // POSITION et dimensions de l'écran
    graphicsView1->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
 
 
    scene1->addPixmap(*pixmap1);
 
    groupe_quadrillage = new QGraphicsItemGroup();
    scene1->addItem(groupe_quadrillage);
    tracer_quadrillage();
 
    groupe_quadrillage->setZValue(1);
 
    QPointF P(600,y_max);
    graphicsView1->centerOn(P);
 
}
 
 
 
void MainWindow::effacer_quadrillage()
{
    foreach( QGraphicsItem *item,  groupe_quadrillage->childItems() )
    {
         delete item;
    }
}
 
 
 
/**
void MainWindow::tracer_mire_origine()
{ // à l'écran
    QPoint P;
 
    P.setX(0);
    P.setY(0);
    P /= ech;
 
 
    QGraphicsLineItem *segment_pointage1 = new QGraphicsLineItem(groupe_pointage);
    segment_pointage1->setPen(pen_pointage);
    segment_pointage1->setLine(P.x()-10, P.x()-10, P.x()+10, P.x()+10);
 
    QGraphicsLineItem *segment_pointage2 = new QGraphicsLineItem(groupe_pointage);
    segment_pointage2->setPen(pen_pointage);
    segment_pointage2->setLine(P.x()-10, P.x()+10, P.x()+10, P.x()-10);
    tracer_texte(-20, -20, "(x=0; y=0)");
 
}
**/
 
 
/**
void MainWindow::tracer_texte(int x, int y, QString texte_i)
{ // à l'écran
    y=-y;
 
    x /= ech;
    y /= ech;
 
    QGraphicsTextItem *gtexte = new QGraphicsTextItem(groupe_trace);
    gtexte->setDefaultTextColor(bleu);
    gtexte->setPos(x,y);
    gtexte->setPlainText(texte_i);
}
**/
 
 
void MainWindow::tracer_quadrillage()
{
    int n, n_max;
    int c;
    float x,dx, x_max;
    float y,dy;
    float facteur=1;
    float offset_x, offset_y;
    quint8 gradu_bold;
    quint16 unite;
    quint16 step_grad; // nb de lignes d'espacement pour les textes de graduation
    quint16 grad_max;
    QString sti;
    QPainter painter1(pixmap1);  // rappel: pixmap1 = 12010,12010
  //  painter1.setPen(pen_quadrillage);
 
 
// valeurs par defaut :
    facteur = 8;  // largeur des cases
    gradu_bold=10;
    unite = 10;
    n_max = 100;
    step_grad =10;
    y_max = 8000;
    grad_max=10;
 
    if (systeme_mesure == 1) // mm
    {
        if (ech == 1)
        {
            facteur = 8;  // largeur des cases
            gradu_bold=10;
            unite = 10;
            n_max = 100;
            step_grad =10;
            y_max = 8000;
            grad_max=10;
        }
 
       if (ech == 4)
       {
           facteur = 2;  // largeur des cases
           gradu_bold=10;
           unite = 10;
           n_max = 500;
           y_max = 10000;
           step_grad =10;
           grad_max=50;
       }
       if (ech == 8)
       {
           facteur = 10;
           gradu_bold=10;
           unite = 10;
           n_max =100;
           y_max = 10000;
           step_grad =1;
           grad_max=100;
       }
       if (ech == 80)
       {
           facteur = 10;
           gradu_bold=10;
           unite = 100;
           n_max =10;
           y_max = 1000;
           step_grad =1;
           grad_max=100;
       }
    }
 
    if (systeme_mesure == 2) // 25mils
    {
        facteur = 6.35;
        gradu_bold=4;
        unite=250;
        n_max = 160; // 1000 /facteur;
        step_grad =1;
        y_max = 10160; // 3110;
        grad_max=4000;
 
    }
 
    if(systeme_mesure == 3) // grille en 0.8mm pour vérifier les smd en 0.8
    {
        facteur = 8;
        gradu_bold=10;
        unite = 0;
        n_max =100;
        step_grad =1;
    }
 
 
 
   // n_max = 1000 /facteur;
 
    dx=10*facteur;  // largeur des cases
    x_max = dx * n_max;
 
    dy=10*facteur; // hauteur des cases
    //y_max = dy * n_max;
 
    offset_x = 100+spinBox_X->value();
    offset_y = 100+spinBox_Y->value();
 
    ellipse_i = new QGraphicsEllipseItem(100-1,y_max+100-2,3,3);
    pen_quadrillage.setColor(rouge);
    ellipse_i->setPen(pen_quadrillage);
    groupe_quadrillage->addToGroup(ellipse_i);
    //painter1.setPen(pen_quadrillage);
    //painter1.drawEllipse(0,0,3,3);
 
 
// lignes verticales
    for (n=0; n<=n_max; n++)
    {
        if ((n % gradu_bold) == 0) {pen_quadrillage.setColor(couleur_quadrillage2);} else {pen_quadrillage.setColor(couleur_quadrillage1);}
        x = dx * n;
        ligne_i = new QGraphicsLineItem(x+offset_x, offset_y, x+offset_x, y_max+offset_y);
        ligne_i->setPen(pen_quadrillage);
        groupe_quadrillage->addToGroup(ligne_i);
//painter1.drawLine(x+offset, offset, x+offset, y_max+offset);
 
        sti.setNum((unite *  n)/10);
        if (((unite *  n)/10) == 1 ) {sti += "mm";}
 
//painter1.setPen(pen_texte);
 
        text_gradu = new QGraphicsTextItem(sti);
        text_gradu->setDefaultTextColor(couleur_texte);
        text_gradu->setPos(step_grad*x +offset_x+2, y_max+offset_y+1 );
        groupe_quadrillage->addToGroup(text_gradu);
 
        if (ech == 1)
        {
            for (c=0; c<=n_max; c++)
            {
                y = dy * c;
                text_gradu = new QGraphicsTextItem(sti);
                text_gradu->setDefaultTextColor(couleur_texte);
                text_gradu->setPos(step_grad*x +offset_x+2, offset_y+1 + step_grad*y );
                groupe_quadrillage->addToGroup(text_gradu);
//painter1.drawText(step_grad*x +offset+2, step_grad*y +offset+20, sti);
            }
        }
    }
 
// lignes horizontales
    for (n=0; n<=n_max; n++)
    {
        if (((n_max-n) % gradu_bold) == 0) {pen_quadrillage.setColor(couleur_quadrillage2);} else {pen_quadrillage.setColor(couleur_quadrillage1);}
        painter1.setPen(pen_quadrillage);
        y = dy * n;
//painter1.drawLine(offset, y+offset, x_max+offset, y+offset);
        ligne_i = new QGraphicsLineItem(offset_x, y+offset_y, x_max+offset_x, y+offset_y);
        ligne_i->setPen(pen_quadrillage);
        groupe_quadrillage->addToGroup(ligne_i);
        sti.setNum(grad_max-((unite *  n)/10));
 
//painter1.setPen(pen_texte);
//painter1.drawText(offset+10, step_grad*y +offset+20, sti);
 
        text_gradu = new QGraphicsTextItem(sti);
        text_gradu->setDefaultTextColor(couleur_texte);
        text_gradu->setPos(offset_x+10, step_grad*y +offset_y+1);
        groupe_quadrillage->addToGroup(text_gradu);
 
 
    }
    //scene1->addPixmap(*pixmap1);
    scene1->addItem(groupe_quadrillage);
}
 
 
 
void MainWindow::tracer1pas()
{
    quint32 x, y;
    float z1, z2, z3;
    quint8  R1,G1,B1, R2, G2, B2;
    QColor couleur_piste2;
 
    QPainter painter1(pixmap1);
    painter1.setPen(pen_trace);
 
    x = pos_moteur1;
    y = pos_moteur2;
 
    x /= ech;
    y /= ech;
 
    y=y_max-y;
 
 
 
    if (checkBox_1->isChecked()) // couleur évolutive afin de repérer le parcours du tracé.
    {
        R1=130;
        G1=130;
        B1=130;
 
        z3=124*cos((float)compteur_pas/10000.0);
        z2=124*cos((float)(compteur_pas/10000.0)+(M_PI/3.0));
        z1=124*cos((float)(compteur_pas/10000.0)+(2*M_PI/3.0));
 
        R2= R1+z1;
        G2= G1+z2;
        B2= B1+z3;
        couleur_piste2 = QColor::fromRgb(R2,G2,B2);
 
        pen_trace.setColor(couleur_piste2);
    }
    else { pen_trace.setColor(couleur_piste); }
 
  //  if (((x % 100)==0) || ((y % 100)==0)) {pen_trace.setColor(blanc);}
    if( ! checkBox_2->isChecked()){pen_trace.setWidth(30);} else {pen_trace.setWidth(1);}
 
    painter1.drawPoint(x+100,y+100);
 
    compteur_pas++;
}
 
 
 
 
 
void MainWindow::tracer_circuit()
{
    compteur_pas=0;
 
    quint32 i, i_max, k;
    quint8 octet_i;
    quint8 evt[4]; //chaque octet du fichier code pour 4 evenements codés sur deux bits chacun
    quint8 evt_k;
    quint8 fin_trace;
    quint8 stop;
    QString s1;
 
    pos_moteur1=0;
    pos_moteur2=0;
 
    i_max = 800000; // nb_octets;  // 4000000 et plus... A VOIR
    if (radioButton_6->isChecked()) {i_max=60000;} // tracer début seulement (pour gagner du temps...)
 
 
    i=512; // pour commencer la lecture au block_n; le block0 est réservé pour une entête
    fin_trace=0;
    stop=0;
 
 
    while ((i<i_max) && (stop == 0) )
    {
        octet_i= datas_in[i];
        i++;
// detection fin de trace
        if(octet_i == '=') {fin_trace++ ;} else {fin_trace=0;}
        if(fin_trace>10) {stop = 1;} // se produit si 10x '=' à la suite, ce qui fera sortir de la boucle
 
        evt[0] =  octet_i & 0b00000011;
        evt[1] = (octet_i & 0b00001100) >>2;
        evt[2] = (octet_i & 0b00110000 )>>4;
        evt[3] = (octet_i & 0b11000000) >>6;
 
        for (k=0; k<4; k++)
        {
            evt_k=evt[k];
            if (evt_k == 0b00) {pos_moteur1++; }
            if (evt_k == 0b01) {pos_moteur1--; }
            if (evt_k == 0b10) {pos_moteur2++; }
            if (evt_k == 0b11) {pos_moteur2--; }
 
//qDebug() << "M1=" << pos_moteur1 << " M2=" << pos_moteur2;
 
            tracer1pas();
        }
    }
 
    s1.setNum(i);
    lineEdit_3->setText(s1);
 
 
    scene1->addPixmap(*pixmap1);
    QPointF P(600,y_max);
    graphicsView1->centerOn(P);
 
}
 
 
 
 
void MainWindow::lecture_fichier_init()
{
    QString line, tx1, tx2;
    int p2;
    tx1 = "";
 
    QFile file1(QDir::homePath() + "/.cnc_traces/traces.ini");
 
    if (file1.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        QTextStream in(&file1);
        in.reset();
        while ( !in.atEnd() )
        {
            line = in.readLine();
            if (line.left(1) !="#")
            {
                if (line.indexOf("fileName_en_cours") != -1)
                {
                    if ( (p2 = line.indexOf('=')) != -1)
                    {
                        line.remove(0,p2+1);
                        fileName_en_cours = line;
                    }
                }
            }
        }
        file1.close();
    } else { fileName_en_cours = "";	tx1 = "fichier .ini non trouve, ce n'est pas grave !"; }
 
    if (tx1 !="")
    {
        QMessageBox msgBox;
        msgBox.setText(tx1);
        msgBox.exec();
    }
//    statusBar1->showMessage(tx1 + "    "+ tx2);
}
 
 
 
void MainWindow::enregistrer_fichier_init()
{
    QDir dossierIni(QDir::homePath() + "/.cnc_traces/");
    if (!dossierIni.exists())
 
    {
        QMessageBox msgBox;
        msgBox.setText("Le repertoire :  ~/" + dossierIni.dirName() + "  n'existe pas, je vais le creer, et y placer le fichier de configuration 'cnc_gerber.ini' ");
        msgBox.exec();
        QDir dossierPerso(QDir::homePath());
        dossierPerso.mkdir(".cnc_traces");
    }
 
    QFile file1(QDir::homePath() + "/.cnc_traces/traces.ini");
    if (file1.open(QIODevice::WriteOnly | QIODevice::Text))
    {
        QTextStream out(&file1);
        QString V;
 
        out << "# les lignes commeneant par # sont ignorees";
        out << '\n';
        out << "# Ce fichier est genere automatiquement par le programme";
        out << '\n';
        out << "#";
        out << '\n';
 
        out << "fileName_en_cours=" << fileName_en_cours;
        out << '\n';
    }
    file1.close();
}
 
 
 
int MainWindow::lire_fichier(QString nom_fichier1)
{
    QFile file1(nom_fichier1);
    QString s1;
 
    if( !file1.exists() )
    {
        qDebug() << "Le fichier (" << nom_fichier1<< ") n'existe pas.";
        return 1;
    }
 
    if (!file1.open(QIODevice::ReadOnly )) return 1;
    QDataStream in1(&file1);
 
    nb_octets = file1.size();
    if (nb_octets> 2000000) {nb_octets = 2000000;}
 
    s1.setNum(nb_octets);
    lineEdit_2->setText(s1);
 
    in1.readRawData(datas_in, nb_octets);
 
    file1.close();
    return 0;
}
 
 
 
 
int MainWindow::on_actionOuvrir_triggered()  // menu "Fichier/ouvrir.."
{
    int fich_charge_ok;
   // fileName_en_cours = lineEdit_6->text();
    fileName_en_cours = QFileDialog::getOpenFileName(this, tr("Open File"), fileName_en_cours, tr("Files (*.bin *.dat)"));
 
    lineEdit_1->setText(fileName_en_cours);
 
    fich_charge_ok = lire_fichier(fileName_en_cours); // <<------------
 
    qDebug() << fich_charge_ok;
 
    if (fich_charge_ok != 0) {return 1;}
 
    enregistrer_fichier_init();
 
    effacer_ecran();
    tracer_quadrillage();
    tracer_circuit();
 
    return 0;
}
 
 
 
int MainWindow::on_actionRecharger_triggered()
{
    int fich_charge_ok;
   // lineEdit_6->setText(fileName_en_cours);
 
    fich_charge_ok = lire_fichier(fileName_en_cours); // <<------------
    if (fich_charge_ok != 0) {return 1;}
 
    effacer_ecran();
    tracer_quadrillage();
    tracer_circuit();
 
    return 0;
}
 
 
 
void MainWindow::onReceptPos_clic(int px, int py) // emis depuis un clic sur scene1, voir ma class "scene_cliquable"
{
    QString s1,s2;
    QPoint P;
 
    x_clic_scene = px; // ne change qu'ici lors du clic
    y_clic_scene = py; // ne change qu'ici lors du clic
 
    s1.setNum(px);// conversion num -> txt
    s2.setNum(-py);
  //  lineEdit_4->setText("x="+s1+" y="+s2);
 
    P.setX(px);
    P.setY(py);
 
    graphicsView1->centerOn(P);
 //   P.setX(px * ech);
 //   P.setY(-py*ech);
 
}
 
 
 
void MainWindow::onReceptPos_release(int px, int py)
{
px=px; // pour éviter les warnings à la compilation. c'est ce que j'ai trouvé de mieux...
py=py;
 
}
 
 
 
void MainWindow::onReceptPos_survol(int px, int py) // emis lors d'un survol avec clic appuyé de scene1, voir ma class "scene_cliquable"
{
    QString s1,s2;
    QPoint P;
 
    x_dyn = px;
    y_dyn = py;
 
    delta_x = x_clic_scene - x_dyn;
    delta_y = y_clic_scene - y_dyn;
 
    s1.setNum(delta_x);// conversion num -> txt
    s2.setNum(delta_y);
    lineEdit_4->setText("dx="+s1+" dy="+s2);
 
    P.setX(delta_x);
    P.setY(delta_y);
}
 
 
 
 
 
 
 
void MainWindow::on_Btn_tracer_clicked()
{
    tracer_quadrillage();
    tracer_circuit();
 
}
 
 
void MainWindow::on_Btn_effacer_clicked()
{
    effacer_ecran();
}
 
 
void MainWindow::on_Btn_redessiner_clicked()
{
    effacer_ecran();
    tracer_quadrillage();
    tracer_circuit();
}
 
 
void MainWindow::on_spinBox_posX_valueChanged(int arg1)
{
arg1=arg1;
 
}
 
void MainWindow::on_Btn_test_clicked()
{
    QPointF P;
    P.setX(delta_x);
    P.setY(delta_y);
 
  // graphicsView1->translate(delta_x, delta_y);
 
   graphicsView1->centerOn(P);
}
 
 
 
 
 
void MainWindow::on_radioButton_1_clicked()
{
    ech=4;
    effacer_ecran();
}
 
 
void MainWindow::on_radioButton_2_clicked()
{
    ech=8;
    effacer_ecran();
}
 
 
void MainWindow::on_radioButton_3_toggled(bool checked)
{
checked=checked;
    if (radioButton_3->isChecked()) {systeme_mesure = 1;}  // mm
    if (radioButton_4->isChecked()) {systeme_mesure = 2;}  // mils
    if (radioButton_8->isChecked()) {systeme_mesure = 3;}  // mils
    effacer_ecran();
}
 
 
 
void MainWindow::on_radioButton_4_clicked()
{
    radioButton_2->setChecked(true);
    on_radioButton_2_clicked();
}
 
 
 
void MainWindow::on_radioButton_5_clicked()
{
    ech=80;
    effacer_ecran();
}
 
void MainWindow::on_radioButton_8_clicked()
{
    systeme_mesure = 3;
    effacer_ecran();
}
 
void MainWindow::on_radioButton_9_clicked()
{
    ech=1;
    effacer_ecran();
}
 
 
 
void MainWindow::on_Btn_eff_quadrillage_clicked()
{
    effacer_quadrillage();
}
 
void MainWindow::on_Btn_tracer_quadrillage_clicked()
{
    tracer_quadrillage();
}
 
void MainWindow::on_spinBox_X_valueChanged(int arg1)
{
arg1=arg1;
    effacer_quadrillage();
    tracer_quadrillage();
}
 
void MainWindow::on_spinBox_Y_valueChanged(int arg1)
{
arg1=arg1;
    effacer_quadrillage();
    tracer_quadrillage();
}