#include <SoftwareSerial.

h>
#include <TinyGPS++.h>
#include <AltSoftSerial.h>
#include <avr/wdt.h>

TinyGPSPlus gps; // Decalaramos -gps- para TinyGPSPlus

SoftwareSerial ModGSM(7, 6); //<<-- Definimos los pines para el puerto
ModGSM (rx, tx)
AltSoftSerial ModGPS; // Los pines por defecto de AltsoftSerial
son (8, 9)

String telefono ="0034600111222"; //<<-- cambiar por el telfono del

administrador
String centromensajes ="0034656000313"; //<<-- Cambiar por el telfono del centro
de mensajes SMS de la operadora
double Lat_inicial; // Variable inicial Latitud
double Lon_inicial; // Variable inicial Longitud
int Hor_inicial; // Variable inicial Hora
int Min_inicial; // Variable inicial Minuto
int Seg_inicial; // Variable inicial Segundo
int Dia_inicial; // Variable inicial Da
int Mes_inicial; // Variable inicial Mes
int Ano_inicial; // Variable inicial Ao
int Interruptor = 0; // Interruptor para el estado de los datos
iniciales
char LecturaEntrada = 0; // Variable que guarda los caracteres del
puerto serie ModGSM
String mensaje = ""; // Variable para trasbasar los mensajes SMS
int ContadorSMSdistancia = 0; // Contador de mensajes para alertas en
general
int ContadorSMSentina = 0; // Contador de mensajes para alertas de
agua en sentina
int ContadorSMSpuertas = 0; // Contador de mensajes para alertas de
puertas abiertas
int ContadorSMSmovimiento = 0; // Contador de mensajes para alertas de
movimiento dentro del barco
int FlotadorSentina = A1; //<<-- Definimos el pin del flotador en
sentina
int preEstado220v = 0; // Estado anterior de la toma de corriente
int Estado220v = 0; // Estado actual de la toma de corriente
int Toma220v = A0; //<<-- Definimos el pin del rel de la toma
de corriente
int SensorPuertas = A3; //<<-- Definimos el pin de los sensores de
las puertas
int SensorMovimiento = A2; //<<-- Definimos el pin del sensor de
movimiento
int ReleNevera = 3; //<<-- Definimos el pin del rel de la
nevera
int EstadoNevera = 0; // Estado actual del rel nevera.
int MicrosdCS = 10; //<<-- Definimos el pin CS de la memoria
microSD
int MicrosdMOSI = 11; //<<-- Definimos el pin MOSI de la memoria
microSD
int MircosdMISO = 12; //<<-- Definimos el pin MISO de la memoria
microSD
int MicrosdSCK = 13; //<<-- Definimos el pin SCK de la memoria
micro SD
int CamaraTX = 4; //<<-- Definimos el pin TX para la camara
de fotos
int CamaraRX = 5; //<<-- Definimos el pin RX para la camara
de fotos
int Termistor = 6; //<<-- Definimos el pin analgico para el
sensor de temperatura exterior
// (restan 4 pines libres 2 digitales/analogicos, 1 digital y 1 analgico)
//-------------------------------------------------------------------
// ---------Los valores que contienen <<-- deben de ser modificados o revisados
para cada configuracin en particular.
// ---------------------COMANDOS PARA GESTIONAR EL PIN Y EL PUK DEL MODULO
GSM--------------------------------------
// ---------AT+CPIN="2222" --- Lo primero es insertar el pin (cuidado porque solo
hay 3 intentos)
// ---------AT+CPIN=? --- con este comando se sabe el estado del pin (si aparece
SIM PUK es que hay que insertar el PUK)
// ---------AT+CPIN="<puk>","<new pin>" --- para insertar el PUK y cambiar el pin
// ---------AT+CLCK="SC",0,"2222"---- Desactiva el pin (hay que insertar el pin
actual) -preferible desactivar el pin-.
//-------------------------------------------------------------------
void setup()
{
wdt_disable(); // Desactivamos el timer de watchDog si
previamente fue activado
Serial.begin(19200); //<<-- Inisializa el puerto serie
ModGSM.begin(19200); //<<-- Inicializa el puerto serie del GSM
ModGPS.begin(9600); //<<-- Inicializa el puerto serie del GPS
delay(8000); // Retardo 8 segundos. El modulo GSM tarda
unos
// 14 segundos en conectarse a la red desde
que se enchufa.
// El modulo GPS tarda unos 6 segundos en
empezar a capturar
// datos desde que se reinicia -en
caliente- y 30 segundos -en frio-
//ModGSM.listen(); // Cuando se necesite cambiar el puerto a
la escucha
// cada 4 segundos aparece un RING en el
puerto serie al recibir una llamada
// tarda 5 segundos en borrar un mensaje si
el mensaje es grande.
ModGSM.print(F("AT\r")); // Se enva un AT de control para que el
modulo GSM ajuste la velocidad del puerto
delay(100);
ModGSM.print((String)"AT+CSCA=\""+centromensajes+"\",145\r"); // Se configura
el numero del centro de mensajes de la operadora.
delay(100);
ModGSM.print(F("AT+CMGF=1\r")); // Se configura el modulo
en modo Texto para los SMS.
delay(100);
ModGSM.print(F("AT+CNMI=2,2,0,0,0\r")); // Imprime el contenido del
mensaje del SMS por el puerto serie del GPRS
// Cono norma general el
mensaje cuando llega solo se muestra un +CNMR,2
// Con esta configuracin,
aparece todo en el puerto serie y se puede leer.
//delay(100);
//ModGSM.print(F("AT+CLIP=1")); // Para activar el
identificador de numero de llamada
//delay(100);
pinMode(FlotadorSentina, INPUT); // Declaramos el pin
FlotadorSentina como entrada
pinMode(Toma220v, INPUT); // Declaramos el pin
Toma220v como entrada
pinMode(SensorPuertas, INPUT); // Declaramos el pin
SensorPuertas como entrada
pinMode(SensorMovimiento, INPUT); // Declaramos el pin
SensorMovimiento como entrada
pinMode(ReleNevera, OUTPUT); // Declaramos el pin
ReleNevera como salida

}
//--------------------------------------------------------------
void loop() {
if (Interruptor == 0){
GuardarCoordenadas(); // Subrutina que guarda los datos iniciales en
diversas variables.
}
else if (Interruptor != 0){
LanzadordeFunciones(); // Subrutina general desde donde se lanzan las
funciones llamadas.
}
}
//--------------------------------------------------------------
void GuardarCoordenadas() {
PausaLigera(1000);
if (gps.location.isValid()) {
Lat_inicial = (gps.location.lat());
Lon_inicial = (gps.location.lng());
Dia_inicial = (gps.date.day());
Mes_inicial = (gps.date.month());
Ano_inicial = (gps.date.year());
Hor_inicial = (gps.time.hour());
Min_inicial = (gps.time.minute());
Seg_inicial = (gps.time.second());
Interruptor = 1;
}
}
//-----------------------------------------------------------
void LanzadordeFunciones() {
while (ModGSM.available() > 0)
{
LecturaEntrada = ModGSM.read(); // Guardamos los caracteres del puerto
ModGSM en la variable incoming_char
// Cabe decir que el valor "read" lee el
serial y luego vaca o borra lo que
// ha leido, cuando se vuelve a ejecutar,
solo lee lo nuevo que ha llegado.
Serial.print(LecturaEntrada); // Mostramos los caracteres guardados en
el monitor serie.
mensaje = mensaje + LecturaEntrada ; // Aadimos al mensaje el nuevo ultimo
caracter leido
}
ComandosSMS(); // Subrutina que lee los sms y extrae
informacion
delay(20000); // Retardo necesario entre funciones para
ahorrar bateria (proceso)
Distancia(); // Subrutina que mide la distancia entre
punto inicial y actual
SensorAguaSentina(); // Comprueba el agua en sentinas
DetectorMovimiento(); // Sensor de movimiento zona interior
DetectorPuertas(); // Sensor de apertura de puertas
EstadoToma220v(); // Sensor estado de la toma de corriente.
}
//---------------------------------------------------------
static void PausaLigera(unsigned long ms) // Esta version de delay() espera a que
el GPS capture.
{ // Esto es porque el GPS tarda en
iniciar.
unsigned long start = millis(); // Esto es porque el GPS refresca cada 1
segundo y hay que esperar los datos
do // No se debe subir el refresco a mas de
1 segundo porque pierde precisin.
{ // No se debe subir la velocidad del GPS
(9600) por incompatibilidad entre
while (ModGPS.available()) // Softwareserial y Altsoftserial, el
puerto de
gps.encode(ModGPS.read()); // Softwareserial debe ser 10 veces mas
rapido para evitar sus
} while (millis() - start < ms); // interrupciones, cosa que no sucede con
Altsofserial. (5s vs 130s)
} // Este programa ejecuta (do) en loop
hasta que (while) se cumpla
//------------------------------------------------------
static void ComandosSMS()
{
int localizar = mensaje.indexOf("Localizar"); // Definimos el parametro a
buscar dentro de la variable
int estado = mensaje.indexOf("Estado");
int armar = mensaje.indexOf("Armar");
int desarmar = mensaje.indexOf("Desarmar");
int neveraon = mensaje.indexOf("Neveraon");
int neveraoff = mensaje.indexOf("Neveraoff");
//int seguimiento = mensaje.indexOf("Seguimiento");
//int foto = mensaje.indexOf("Foto");
//int escucha = mensaje.indexOf("Escuchar");

if (localizar >= 0)
{
Localizador(); // Ejecuta subrutina
Localizador
mensaje = "" ; // Reinicia la variable
delay(1000);
ModGSM.println(F("AT+CMGDA=\"del all\"\n")); // Borra todos los SMS de
la SIM
}
if (estado >= 0)
{
EstadoGeneral(); // Ejecuta subrutina
EsadoGeneral
mensaje = "" ; // Reinicia la variable
delay(1000);
ModGSM.println(F("AT+CMGDA=\"del all\"\n")); // Borra todos los SMS de
la SIM
}
if (armar >= 0)
{
Armado(); // Ejecuta subrutina Armado
mensaje = "" ; // Reinicia la variable
 delay(1000);
ModGSM.println(F("AT+CMGDA=\"del all\"\n")); // Borra todos los SMS de
la SIM
}
if (desarmar >= 0)
{
Desarmado(); // Ejecuta subrutina
Desarmado
mensaje = "" ; // Reinicia la variable
mensaje
delay(1000);
ModGSM.println(F("AT+CMGDA=\"del all\"\n")); // Borra todos los SMS de
la SIM
}
if (neveraon >= 0)
{
ActivarNevera(); // Ejecuta subrutina
ActivarNevera
mensaje = "" ; // Reinicia la variable
delay(1000);
ModGSM.println(F("AT+CMGDA=\"del all\"\n")); // Borra todos los SMS de
la SIM
}
if (neveraoff >= 0)
{
DesactivarNevera(); // Ejecuta subrutina
DesactivarNevera
mensaje = "" ; // Reinicia la variable
delay(1000);
ModGSM.println(F("AT+CMGDA=\"del all\"\n")); // Borra todos los SMS de
la SIM
}
}
//------------------------------------------------------
static void Distancia()
{
PausaLigera(1000);
double CalculoDistancia = TinyGPSPlus::distanceBetween(
gps.location.lat(), gps.location.lng(),Lat_inicial, Lon_inicial);
if (CalculoDistancia >= 50.0)
{
if (ContadorSMSdistancia == 10)
{
ModGSM.println((String)"ATD"+telefono+";\r");
// Llamada de aviso final para captar atencin.
ContadorSMSdistancia++;
// Suma 11 al contador y desactiva el envio de mensajes.
}
if (ContadorSMSdistancia > 5 && ContadorSMSdistancia <= 9)
// Se aade un retardo hasta la llamada (1 minuto)
ContadorSMSdistancia++;
if (ContadorSMSdistancia == 5)
{
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r");
// Inicia el envo de SMS
delay(100);
ModGSM.println(F("((ULTIMO AVISO)) zona de seguridad sobrepasada!!"));
// Contenido del SMS maximo 160 caracteres.
ModGSM.print(CalculoDistancia);
// Contenido del SMS.
ModGSM.println(F(" Metros"));
// Contenido del SMS.
ModGSM.println(F("((ALERTAS DESACTIVADAS)) Puede (localizar)"));
// Contenido del SMS.
ModGSM.println(F(" y luego (armar) para rearmar"));
// Contenido del SMS.
ModGSM.println((char)26);
// Finaliza el mensaje
delay(100);
ContadorSMSdistancia++;
// Suma 1 envio de SMS al contador.
}
if (ContadorSMSdistancia > 0 && ContadorSMSdistancia <= 4)
// Se aade un retardo para el proximo SMS (1 minuto)
ContadorSMSdistancia++;
if (ContadorSMSdistancia == 0)
{
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r");
// Inicia el envo de SMS
delay(100);
ModGSM.println(F("((ALERTA)) zona de seguridad (50 Metros)
sobrepasada!!")); // Contenido del SMS.
ModGSM.print(CalculoDistancia);
// Contenido del SMS.
ModGSM.println(F(" Metros"));
// Contenido del SMS.
ModGSM.println((char)26);
// Finaliza el mensaje
delay(100);
ContadorSMSdistancia++;
// Suma 1 envio de SMS al contador.
}
}
// Contenido del SMS.

}
//---------------------------------------------------------------------------------
-----------
static void Localizador(){
PausaLigera(1000);
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r"); // Inicia el
envo de SMS
delay(100);
ModGSM.println(F("Posicion actual:")); // Contenido
del SMS maximo 160 caracteres.
ModGSM.print(F("https://www.google.com/maps/place/"));
ModGSM.print(gps.location.lat(), 6);
ModGSM.print(F(","));
ModGSM.println(gps.location.lng(), 6);
ModGSM.println((char)26); // Finaliza el
mensaje
}
//---------------------------------------------------------------------------------
-----
static void EstadoGeneral(){
PausaLigera(1000);
double CalculoDistancia = TinyGPSPlus::distanceBetween(
gps.location.lat(), gps.location.lng(),Lat_inicial, Lon_inicial);
 ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r"); // Inicia el envo de
SMS
delay(100);
ModGSM.println(F("ESTADO")); // Contenido del SMS
maximo 160 caracteres (usados 125 restan 35)
ModGSM.print(F("Volt-Alarma: "));
ModGSM.print(leerVcc() * 0.001);
ModGSM.println(F("v"));
ModGSM.print(F("Volt-Barco: "));
ModGSM.print(F("Estado Nevera: "));
ModGSM.print(F("Temp: "));
ModGSM.print(F("Distancia: "));
ModGSM.print(CalculoDistancia);
ModGSM.println(F(" Mt"));
ModGSM.print(F("Sats: "));
ModGSM.println(gps.satellites.value());
ModGSM.print(F("Iniciado el: "));
char fechactual[80];
sprintf(fechactual, "%02d/%02d/%4d", Dia_inicial, Mes_inicial, Ano_inicial);
ModGSM.print(fechactual);
char horactual[80];
sprintf(horactual, " a las %02d:%02d:%02d UTC", Hor_inicial, Min_inicial,
Seg_inicial);
ModGSM.println(horactual);
ModGSM.println((char)26);
}
//---------------------------------------------------------------------------------
-----
static void Desarmado(){
ContadorSMSdistancia = 11; // Desactiva las alertas de distancia.
//ContadorSMSentina = 11; // Desactiva las alertas de agua en sentina.
<<--no desactivar.
if (EstadoNevera == 1){ // Desactiva la nevera si estuviese activa.
digitalWrite(ReleNevera, HIGH);
delay(500);
digitalWrite(ReleNevera, LOW);
EstadoNevera = 0;
}
ContadorSMSpuertas = 11; // Desactiva las alertas de Sensor puertas.
ContadorSMSmovimiento = 11; // Desactiva las alertas de Sensor movimiento.
}
//---------------------------------------------------------------------------------
-----
static void Armado(){
wdt_enable(WDTO_1S); // Iniciamos el Wathdog para 1 Segundo.
while(1){ } // Creamos un bucle infinito para que Watchdog
caduque y reinice
}
//---------------------------------------------------------------------------------
-----
long leerVcc() {
// Lee 1.1V referencia sobre AVCC
// Calcula el voltaje VCC tomando como refernncia el voltaje interno de 1.1V
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) ||
defined(__AVR_ATmega2560__)
ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) ||
defined(__AVR_ATtiny84__)
ADMUX = _BV(MUX5) | _BV(MUX0);
 #elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) ||
defined(__AVR_ATtiny85__)
ADMUX = _BV(MUX3) | _BV(MUX2);
#else
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif

delay(2);
ADCSRA |= _BV(ADSC);
while (bit_is_set(ADCSRA,ADSC)); // midiendo

uint8_t low = ADCL;

uint8_t high = ADCH;

long result = (high<<8) | low;

result = 1085300L / result; // Calcula los voltios (en mV); 1125300 =

1.1*1023*1000
return result; // Vcc en milivoltios--> Sim800: (3.4v-4.4v) (alarma batera baja
a 3.7v)
}
//---------------------------------------------------------------------------------
----
static void SensorAguaSentina() {
if (digitalRead(FlotadorSentina)==HIGH){
if (ContadorSMSentina == 10)
{
ModGSM.println((String)"ATD"+telefono+";\r"); //
Llamada de aviso final para captar atencin.
ContadorSMSentina++; //
Suma 11 al contador y desactiva el envio de mensajes.
}
if (ContadorSMSentina > 5 && ContadorSMSentina <= 9) //
Se aade un retardo hasta la llamada (1 minuto)
ContadorSMSentina++; //
Sumamos uno a la variable CondadorSMSentina
if (ContadorSMSentina == 5)
{
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r"); //
Inicia el envo de SMS
delay(100);
ModGSM.println(F("((ULTIMO AVISO)) Agua en sentina!!")); //
Contenido del SMS maximo 160 caracteres.
ModGSM.println(F("((ALERTAS DESACTIVADAS)) Revise el barco y luego")); //
Contenido del SMS.
ModGSM.println(F(" envie (armar) o rearne manualmente")); //
Contenido del SMS.
ModGSM.println((char)26); //
Finaliza el mensaje
delay(100);
ContadorSMSentina++; //
Suma 1 envio de SMS al contador.
}

if (ContadorSMSentina > 0 && ContadorSMSentina <= 4) //

Se aade un retardo para el proximo SMS (1 minuto)
ContadorSMSentina++;

if (ContadorSMSentina == 0)
 {
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r"); //
Inicia el envo de SMS
delay(100);
ModGSM.println(F("((ALERTA)) Agua detectada en sentina!!")); //
Contenido del SMS.
ModGSM.println((char)26); //
Finaliza el mensaje
delay(100);
ContadorSMSentina++; //
Suma 1 envio de SMS al contador.
}
}
}
//--------------------------------------------------------------------------------
static void EstadoToma220v(){
if (digitalRead(Toma220v)==HIGH)
Estado220v = 1;
if (digitalRead(Toma220v)==LOW)
Estado220v = 0;
if (preEstado220v == 1 && Estado220v == 0){
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r"); // Inicia el
envo de SMS
delay(100);
ModGSM.println(F("((ALERTA)) Toma de red desconectada!!")); // Contenido
del SMS.
ModGSM.println((char)26); // Finaliza
el mensaje.
preEstado220v = 0; // Modifica
la funcin
}
if (preEstado220v == 0 && Estado220v == 1){
Serial.println(F("Toma de red Conectada")); // Imprime en
serial cuando se conecta la red de 220v
preEstado220v = 1;
}
}
//------------------------------------------------------------------------------
static void DetectorMovimiento(){
if (digitalRead(SensorMovimiento)==HIGH){
if (ContadorSMSmovimiento == 10)
{
ModGSM.println((String)"ATD"+telefono+";\r");
// Llamada de aviso final para captar atencin.
ContadorSMSmovimiento++;
// Suma 11 al contador y desactiva el envio de mensajes.
}
if (ContadorSMSmovimiento > 5 && ContadorSMSmovimiento <= 9)
// Se aade un retardo hasta la llamada (1 minuto)
ContadorSMSmovimiento++;
// Sumamos uno a la variable CondadorSMSentina
if (ContadorSMSmovimiento == 5)
{
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r");
// Inicia el envo de SMS
delay(100);
ModGSM.println(F("((ULTIMO AVISO)) Movimiento detectado!!"));
// Contenido del SMS maximo 160 caracteres.
ModGSM.println(F("((ALERTAS DESACTIVADAS)) Revise el barco y luego"));
// Contenido del SMS.
ModGSM.println(F(" envie (Armar) o rearme manualmente"));
// Contenido del SMS.
ModGSM.println((char)26);
// Finaliza el mensaje
delay(100);
ContadorSMSmovimiento++;
// Suma 1 envio de SMS al contador.
}

if (ContadorSMSmovimiento > 0 && ContadorSMSmovimiento <= 4)

// Se aade un retardo para el proximo SMS (1 minuto)
ContadorSMSmovimiento++;

if (ContadorSMSmovimiento == 0)
{
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r");
// Inicia el envo de SMS
delay(100);
ModGSM.println(F("((ALERTA)) Detectado movimiento dentro del barco!!"));
// Contenido del SMS.
ModGSM.println((char)26);
// Finaliza el mensaje
delay(100);
ContadorSMSmovimiento++;
// Suma 1 envio de SMS al contador.
}
}
}
//------------------------------------------------------------------------------
static void DetectorPuertas(){
if (digitalRead(SensorPuertas)==HIGH){
if (ContadorSMSpuertas == 10)
{
ModGSM.println((String)"ATD"+telefono+";\r");
// Llamada de aviso final para captar atencin.
ContadorSMSpuertas++;
// Suma 11 al contador y desactiva el envio de mensajes.
}
if (ContadorSMSpuertas > 5 && ContadorSMSpuertas <= 9)
// Se aade un retardo hasta la llamada (1 minuto)
ContadorSMSpuertas++;
// Sumamos uno a la variable CondadorSMSentina
if (ContadorSMSpuertas == 5)
{
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r");
// Inicia el envo de SMS
delay(100);
ModGSM.println(F("((ULTIMO AVISO)) Apertura de puertas detectada!!"));
// Contenido del SMS maximo 160 caracteres.
ModGSM.println(F("((ALERTAS DESACTIVADAS)) Revise el barco y luego"));
// Contenido del SMS.
ModGSM.println(F(" envie (Armar) o rearme manualmente"));
// Contenido del SMS.
ModGSM.println((char)26);
// Finaliza el mensaje
delay(100);
ContadorSMSpuertas++;
// Suma 1 envio de SMS al contador.
 }

if (ContadorSMSpuertas > 0 && ContadorSMSpuertas <= 4)

// Se aade un retardo para el proximo SMS (1 minuto)
ContadorSMSpuertas++;

if (ContadorSMSpuertas == 0)
{
ModGSM.println((String)"AT+CMGS=\""+telefono+"\"\r");
// Inicia el envo de SMS
delay(100);
ModGSM.println(F("((ALERTA)) Detectada apertura de puertas!!"));
// Contenido del SMS.
ModGSM.println((char)26);
// Finaliza el mensaje
delay(100);
ContadorSMSpuertas++;
// Suma 1 envio de SMS al contador.
}
}
}
//-----------------------------------------------------------------------------
static void ActivarNevera(){ // Activamos la nevera
digitalWrite(ReleNevera, HIGH);
delay(500);
digitalWrite(ReleNevera, LOW);
EstadoNevera = 1; // Guardamos el estado de la nevera
}
//------------------------------------------------------------------------------
static void DesactivarNevera(){ // Desactivamos la nevera
digitalWrite(ReleNevera, HIGH);
delay(500);
digitalWrite(ReleNevera, LOW);
EstadoNevera = 0; // Guardamos el estado de la nevera
}
//-----------------------------------------------------------------------------