/**
	Girouette16pos ()
 
	pour  ESP32 30 pins
 
 
--------------------------------------------------------------------------------------------
 
--------------------------------------------------------------------------------------------	
*/
 
 
#include <WiFi.h>
#include "ESPAsyncWebServer.h"
 
const char* ssid = "WIND_srv"; 
const char* password = "62z4exW58";
 
AsyncWebServer server(80); // Create AsyncWebServer object on port 80
 
 
const int GPIO_input0 = 13; 
bool input0_etat;
 
const int GPIO_input1 = 12; 
bool input1_etat;
 
const int GPIO_input2 = 14; 
bool input2_etat;
 
const int GPIO_input3 = 27; 
bool input3_etat;
 
 
 
uint8_t v_inputs=0; // états des inputs
 
String angle_txt;
char angle_array[3];
int nb1, nb2;
int angle;
 
uint8_t compte1=0;
 
String s1;
 
 
/*
void test1()
{
	String s1;
	float nombre1;
	int nb_decimales;
 
	nombre1= 12.6831;
	nb_decimales =3;
 
	s1 = String(nombre1, nb_decimales);
	Serial.println(s1);
}
*/
 
 
 
 
 
void setup()
{
	Serial.begin(115200);
 
	pinMode(GPIO_input0, INPUT_PULLUP);
	pinMode(GPIO_input1, INPUT_PULLUP);
	pinMode(GPIO_input2, INPUT_PULLUP);
	pinMode(GPIO_input3, INPUT_PULLUP);
 
 
	Serial.println("Setup");
	delay(300);
 
 
	WiFi.persistent(false);
	WiFi.softAP(ssid, password);  // ok, ça marche, crée un réseau. mode privé
	IPAddress IP = WiFi.softAPIP();
 
 
	server.on("/AGL", HTTP_GET, [](AsyncWebServerRequest *request)
	{
		request->send_P(200, "text/plain", angle_array);
	});
 
    server.begin();
 
 
    //Serial.println("Serveur WiFi actif!");
	delay(300);
 
 
 
}
 
 
 
void teste_inputs()
{
	char array_inputs[5]= {'0','0','0','0'};
 
 
	//array_out[0] = 'G';
	//array_out[1] = '=';
 
	nb1=0;
 
	input0_etat = digitalRead(GPIO_input0);
	if (input0_etat==1) {array_inputs[0]='1'; nb1+=1;}
 
	input1_etat = digitalRead(GPIO_input1);
	if (input1_etat==1) {array_inputs[1]='1'; nb1+=2;}
 
 
	input2_etat = digitalRead(GPIO_input2);
	if (input2_etat==1) {array_inputs[2]='1'; nb1+=4;}
 
	input3_etat = digitalRead(GPIO_input3);
	if (input3_etat==1) {array_inputs[3]='1'; nb1+=8;}
 
	array_inputs[4]=0; // zéro terminal
 
	Serial.println("");
	Serial.print("bits=");
	Serial.println(array_inputs);
 
/*
code gray :
	0000 
	0001
	0101 
	0100 0111
	0110 1111
	0111 1101
	1111 1001
	1110 1000
	1100 1010
	1101 1011
	1000 0011
	1010 0010
	1011 0000
	0011 0001
	0010 0011
	0000 0111
		 1111	
*/
}
 
 
int decode_gray(int nb_i)
{
	if (nb_i == 0) {return 0;}
	if (nb_i == 8) {return 1;}
	if (nb_i == 10) {return 2;}
	if (nb_i == 2) {return 3;}
	if (nb_i == 6) {return 4;}
	if (nb_i == 14) {return 5;}
	if (nb_i == 15) {return 6;}
	if (nb_i == 7) {return 7;}
	if (nb_i == 3) {return 8;}
	if (nb_i == 11) {return 9;}
	if (nb_i == 9) {return 10;}
	if (nb_i == 1) {return 11;}
	if (nb_i == 5) {return 12;}
	if (nb_i == 13) {return 13;}
	if (nb_i == 12) {return 14;}
	if (nb_i == 4) {return 15;}
	return 0;
}
 
 
void encodage_array()
{
	angle_txt="angle=";
	if (angle<10) {angle_txt+="0";}	// formatage sur 2 chiffres 
	angle_txt += (String) angle;
 
	for(int n=0; n<8; n++)	{angle_array[n]=angle_txt[n];}
 
	angle_array[8]=0;  // zéro terminal  -> chaine C
}
 
 
 
void loop()
{
 
	nb2=0;
	teste_inputs();
	angle = decode_gray(nb1); // = 0..15 -> 16 positions de 22,5 deg chacune
	encodage_array(); // prépare pour envoi par wifi (qui n'interviendra qu'à la demande du client)
 
	Serial.println(angle_array);
	//Serial.print("nb1="); Serial.println(nb1);
	//Serial.print("nb2="); Serial.println(nb2);
	compte1++;
 
 
	delay(500);
 
 
}
 
 
 

/*
	Horloge_TFT () + client girouette
 
	pour  ESP32 Wroom + afficheur 3.5 TFT 480x320
 
	par Silicium628
 
*/
 
 
/*=====================================================================================================
CONCERNANT L'AFFICHAGE TFT: connexion:
 
(Pensez à configurer le fichier User_Setup.h de la bibliothèque ~/Arduino/libraries/TFT_eSPI/ )
 
les lignes qui suivent ne sont qu'un commentaire pour vous indiquer la config à utiliser
placée ici, elle ne sont pas fonctionnelles
Il FAUT modifier le fichier User_Setup.h installé par le système Arduino dans ~/Arduino/libraries/TFT_eSPI/
 
// ESP32 pins used for the parallel interface TFT
#define TFT_CS   27  // Chip select control pin
#define TFT_DC   14  // Data Command control pin - must use a pin in the range 0-31
#define TFT_RST  26  // Reset pin
 
#define TFT_WR   12  // Write strobe control pin - must use a pin in the range 0-31
#define TFT_RD   13
 
#define TFT_D0   16  // Must use pins in the range 0-31 for the data bus
#define TFT_D1   4  // so a single register write sets/clears all bits
#define TFT_D2   2  // 23
#define TFT_D3   22
#define TFT_D4   21
#define TFT_D5   15 // 19
#define TFT_D6   25 // 18
#define TFT_D7   17
=====================================================================================================*/
 
 
String version="1.0";
 
#include <stdint.h>
#include <TFT_eSPI.h> // Hardware-specific library
#include "Free_Fonts.h"
 
TFT_eSPI TFT480 = TFT_eSPI(); // Configurer le fichier User_Setup.h de la bibliothèque TFT480_eSPI au préalable
 
#include <WiFi.h>
#include <HTTPClient.h>
 
 
const char* ssid2 = "WIND_srv"; 
const char* password2 = "62z4exW58";
 
//IP address with URL path
const char* srvName_ANGLE  = "http://192.168.4.1/AGL"; //.4.2  ?
 
const uint32_t connectTimeoutMs = 10000;
 
uint8_t mode = 0; // 0 ou 1
 
String recp_HR = "{}";
String recp_ANGLE = "{}";
 
uint8_t WiFi_status=0;
 
uint32_t memoMillis = 0;
uint32_t currentMillis;
 
 
uint16_t compte1=1;
float angle1=0;
 
 
 
#define NOIR   		0x0000
#define MARRON   	0x9240
#define ROUGE  		0xF800
#define ROSE		0xFBDD
#define ORANGE 		0xFBC0
#define JAUNE   	0xFFE0
#define JAUNE_PALE  0xF7F4
#define VERT   		0x07E0
#define VERT_FONCE  0x02E2
#define OLIVE		0x05A3
#define CYAN    	0x07FF
#define BLEU_CLAIR  0x455F
#define AZUR  		0x1BF9
#define BLEU   		0x001F
#define MAGENTA 	0xF81F
#define VIOLET1		0x781A
#define VIOLET2		0xECBE
#define GRIS_TRES_CLAIR 0xDEFB
#define GRIS_CLAIR  0xA534
#define GRIS   		0x8410
#define GRIS_FONCE  0x5ACB
#define GRIS_TRES_FONCE  0x2124
#define BLANC   	0xFFFF
 
 
 
static void smartdelay(unsigned long ms)
{
	unsigned long start = millis();
	while (millis() - start < ms) {;}
}
 
 
 
void httpGetAngle()
{
//	Serial.println("envoi req HR");
	TFT480.fillCircle(470, 20, 5,BLEU );
	delay(200);
 
 
	HTTPClient http2;
	http2.begin(srvName_ANGLE);
 
	int httpResponseCode = http2.GET();
 
	if (httpResponseCode>0)
	{
		recp_ANGLE = http2.getString();
		TFT480.fillCircle(470, 20, 5,VERT );
	}
	http2.end();
 
}
 
 
void affi_pointe(uint16_t x0, uint16_t y0, uint16_t r, double angle_i, float taille, uint16_t couleur_i)
{
// trace une pointe de flèche sur un cercle de rayon r
// angle_i en degrés décimaux - sens trigo
 
	float angle =angle_i/57.3;  // (57.3 ~ 180/pi)
	int16_t x1, x2, x3;
	int16_t y1, y2, y3;
 
	x1=x0+r* cos(angle); // pointe
	y1=y0-r* sin(angle); // pointe
 
	x2=x0+(r-7)* cos(angle-taille); // base A
	y2=y0-(r-7)* sin(angle-taille); // base A		
 
	x3=x0+(r-7)* cos(angle+taille); // base B
	y3=y0-(r-7)* sin(angle+taille); // base B
 
	TFT480.fillTriangle(x1, y1,  x2, y2,  x3, y3,	couleur_i);	
}
 
 
void affi_angle()
{
	String s1, s2;
 
	//s1="";
	//if(angle_i<10){s1+="0";}
	//s1 += String(angle_i);
 
	s1 = String(angle1);
	s2= recp_ANGLE;
 
	TFT480.setTextColor(NOIR, BLANC);
	TFT480.setFreeFont(FF5);
	TFT480.setTextSize(1);
	TFT480.drawString("  ANGLE >  ",0,90);
 
	TFT480.fillRect(120, 90, 90, 14, NOIR); // efface
	TFT480.setTextColor(VERT);
	TFT480.drawString(s1, 120, 90);
}
 
 
 
 
void affi_boussole(int x0, int y0, int dx, int dy, float angle_i)
{
	int a1;
 
	TFT480.drawRect(x0, y0, dx, dy, BLANC);
 
	TFT480.fillRect(x0+1, y0+1, dx-2, dy-2, NOIR); // efface
 
	TFT480.setFreeFont(FF0);
	TFT480.setTextSize(1);
	TFT480.drawString("N", x0+35, y0+5);
 
	TFT480.setTextColor(BLANC);
 
	TFT480.setFreeFont(FF5);
	TFT480.setTextSize(1);
 
	TFT480.fillRect(x0+15, y0+1, 50, 53, NOIR); // efface
 
	affi_pointe(x0+dx/2, y0+dy/2, (dy/2)-5, 90-angle_i, 2.5, CYAN);
 
	TFT480.drawCircle(x0+dx/2, y0+dy/2, (dy/2)-2, BLANC);
 
	TFT480.setTextColor(ROUGE);
	TFT480.drawString("N", -6+x0+dx/2, y0+5);
	TFT480.setTextColor(JAUNE);
	TFT480.drawString("W", x0+6, -8+y0+dy/2);
	TFT480.setTextColor(JAUNE);
	TFT480.drawString("E", x0+dx-14, -8+y0+dy/2);
	TFT480.setTextColor(BLEU);
	TFT480.drawString("S", -6+x0+dx/2, y0+dy-20);
 
	TFT480.setFreeFont(FF0);
	TFT480.setTextSize(1);
	TFT480.setTextColor(BLANC);
 
	a1=(int)angle_i; 
	String s1 =String(a1);
	TFT480.fillRect(x0+60, y0+5, 25, 8, NOIR); // efface
	TFT480.drawString(s1, x0+65, y0+5);
}
 
 
 
void connexion_serveur_ANGLE()
{
	//TFT480.fillScreen(NOIR);
	TFT480.fillRect(0, 0, 480, 75, GRIS_TRES_FONCE); // efface
	TFT480.setCursor(0, 20, 4);
	TFT480.setFreeFont(FF5);
	TFT480.setTextSize(1);
	TFT480.setTextColor(JAUNE, NOIR);
	TFT480.print("Connexion au serveur ANGLE :");
 
	WiFi.persistent(false);
	WiFi.begin(ssid2, password2);
 
	delay(100);
 
	TFT480.setTextColor(BLANC, NOIR);
	TFT480.setCursor(0, 40, 1);
	while(WiFi.status() != WL_CONNECTED)
	{ 
		delay(100);
		TFT480.print(".");
	}
 
	TFT480.setCursor(0, 60, 1);
	TFT480.print(WiFi.localIP());
}
 
 
void affi_accueil()
{
	TFT480.fillScreen(NOIR);
 
	TFT480.setTextColor(BLANC, NOIR);
 
	TFT480.setFreeFont(FF1);
	uint16_t y=0;
	TFT480.drawString("TEST  AFFI", 0, y);
	y+=20;
	String s1="version " + version;
	TFT480.drawString(s1, 0, y);
	y+=20;
	TFT480.setTextColor(JAUNE, NOIR);
	TFT480.drawString("Client WiFi", 0, y);
	y+=40;
 
}
 
 
 
void setup()
{
	Serial.begin(115200);
	Serial.println("Setup");
 
	TFT480.init();
	TFT480.setRotation(3); // 0..3 à voir, suivant disposition de l'afficheur et sa disposition
	affi_accueil();
	delay (2000);
 
 
    TFT480.fillScreen(NOIR);
 
 	TFT480.setCursor(130, 0, 2); // Set "cursor" at top left corner of display (0,0) and select font 4
	TFT480.setTextColor(TFT_BLUE, TFT_BLACK);
	TFT480.println("Client WiFi");   
 
	delay(500);
 
	TFT480.fillScreen(NOIR);
 
}
 
int angl_1 =0;
 
void loop()
{
	//if ((compte1 % 5)==0) // toutes les 5s
	//if(0) // POUR TEST
	{
		WiFi.disconnect();
		connexion_serveur_ANGLE();
		recp_ANGLE = "{}";
		if(WiFi.status()== WL_CONNECTED )
		{
			httpGetAngle();
		}
	}
 
	Serial.println(recp_ANGLE);
	String s1=recp_ANGLE.substring(0, 6);
	Serial.println(s1);
 
	if(recp_ANGLE.substring(0, 6)=="angle=")
	{
		Serial.println("ok");
		String s2=recp_ANGLE.substring(6, 8);
		Serial.println(s2);
		angl_1 = s2.toInt();
	}
 
	angle1 = 22.5*angl_1;
	//angle1=22.5 * compte1; // POUR TEST
 
	affi_angle();
 
	//affi_boussole(10, 10, 15*compte1, 10*compte1, angle1); // POUR TEST de la taille
 
	affi_boussole(10, 150, 150, 100, angle1);
 
	//delay(500);
	//angle1+=22.5;
	//if (angle1>359) {angle1=0;}
 
	compte1++; if (compte1>30)
	{
		compte1=1;
		TFT480.fillScreen(NOIR);
	}
 
	smartdelay(300);
 
}