Control de emisoras de radioaficionado con Arduino [4]: Código y vídeo demostrativo

14 Feb 20154 octubre 2020 giltesa 30 comentarios

[notification type=»alert-info» close=»false» ]Actualización: 2016/10/24
He resumido el código de este menú en la siguiente entrada: Menú con submenus para Shield LCD en Arduino[/notification]

/**
 * Name:     Arduino - Control de emisoras de radioaficionado
 * Autor:    Alberto Gil Tesa
 * Web:      http://giltesa.com
 * License:  CC BY-NC-SA 3.0
 * Version:  0.9
 * Date:     2015/02/15
 *
 * Arduino Micro, Pinout:
 *                   _______________
 *                  |      USB      |
 *         RELE A1  |13           12|  RELE A2
 *                  |3V3          11|  RELE A3
 *                  |AREF         10|  RELE A4
 *         RELE B1  |A0            9|  RELE A5
 *         RELE B2  |A1            8|  RELE MSG
 *         RELE B3  |A2            7|  RELE AUX
 *         RELE B4  |A3            6|  RELE PEDAL
 *           PEDAL  |A4            5|  ENCODER IZQUIERDA
 *  ENCODER CENTRO  |A5            4|  ENCODER DERECHA
 *                  |          3/SCL|  LCD
 *                  |          2/SDA|  LCD
 *                  |5V          GND|
 *                  |RST         RST|
 *                  |GND   1/INT2/RX|
 *                  |VIN   0/INT3/TX|
 *                  |MISO         SS|
 *                  |SCK        MOSI|
 *                  |_______________|
 *
*/



/*******************************/
/***** LIBRERIAS Y OBJETOS *****/
/*******************************/
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>

LiquidCrystal_I2C lcd( 0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE );



/*******************************/
/********* CONSTANTES **********/
/*******************************/
#define pRELE_MSG    8  // Rele para el mensaje temporizado
#define pRELE_AUX    7  // Rele de los equipos auxiliares
#define pRELE_PEDAL  6  // Rele del microfono del pedal
#define pENCO_LEFT   5  // Encoder izquierda
#define pENCO_CENTER A5 // Encoder centro
#define pENCO_RIGHT  4  // Encoder derecha
#define pPEDAL       A4 // Pedal
#define TYPE_RELEA   1
#define TYPE_RELEB   2
#define TYPE_BOOL    3
#define TYPE_INT     4



// Generador de iconos: http://mikeyancey.com/hamcalc/lcd_characters.php
byte ico0[8] = { B00000, B00010, B00010, B00010, B11111, B11111, B11111, B00000 }; // Emisora
byte ico1[8] = { B00000, B01110, B01010, B01110, B00100, B00100, B00100, B00000 }; // Microfono
byte ico2[8] = { B00001, B00011, B00101, B00001, B11101, B10100, B10100, B11100 }; // Digital
byte ico3[8] = { B00000, B00000, B11100, B11111, B10001, B11111, B11111, B00000 }; // Grabadora
byte ico4[8] = { B00000, B00010, B00110, B11110, B11110, B00110, B00010, B00000 }; // Llamador
byte ico5[8] = { B00000, B00000, B11111, B11111, B10101, B10001, B11111, B00000 }; // Mensaje
byte ico6[8] = { B00000, B00000, B10000, B11000, B11110, B11111, B00000, B00000 }; // Pedal
byte ico7[8] = { B00000, B00100, B00110, B11111, B00110, B00100, B00000, B00000 }; // Flecha
const byte icoEmisora=0, icoMicrofono=1, icoDigital=2, icoGrabadora=3, icoLlamador=4, icoMensaje=5, icoPedal=6, icoFlecha=7;



/* RELES A */
const byte  zRELE_A   = 5;                     // Numero de reles del GrupoA
const byte  pRELE_A[] = { 13, 12, 11, 10, 9 }; // Pines de los reles del GrupoA
const char *nRELE_A[] = {                      // Nombre de cada rele del GrupoA, maximo 18 caracteres por nombre.
    "1. KENWOOD TS-850 ",
    "2. YAESU FT-897   ",
    "3. KENWOOD TM-742 ",
    "4. KENWOOD TR-50  ",
    "5. AUXILIAR       "
};
const byte iRELE_A[] = {
    icoEmisora,
    icoEmisora,
    icoEmisora,
    icoEmisora,
    icoEmisora
};

/* RELES B */
const byte  zRELE_B   = 4;                     // Numero de reles del GrupoB
const byte  pRELE_B[] = { A0, A1, A2, A3 };    // Pines de los reles del GrupoB
const char *nRELE_B[] = {                      // Nombre de cada rele del GrupoB, maximo 18 caracteres por nombre.
    "1. MICROFONO      ",
    "2. MODOS DIGITALES",
    "3. GRABADORA      ",
    "4. LLAMADOR CQ    "
};
const char iRELE_B[] = {
    icoMicrofono,
    icoDigital,
    icoGrabadora,
    icoLlamador
};

/* TEXTOS MENUS */
const char *nMENU[] = {
    "Rele Grupo A       ",
    "Rele Grupo B       ",
    "Rele Msg Estado    ",
    "Rele Msg T. reposo ",
    "Rele Msg T. func.  ",
    "Rele Aux           ",
    "Rele Pedal T. apag ",
    "Guardar y salir    ",
    "No guardar y salir ",
    "Salir              "
};



/*******************************/
/** ESTRUCTURAS CONFIGURACION **/
/*******************************/
struct MYDATA{
    int initialized;
    int sGroupA;       // Estado rele grupo A          -1(OFF), 0(R1), 1(R2), 2(R3), 3(R4), 4(R5)
    int sGroupB;       // Estado rele grupo B          -1(OFF), 0(R1), 1(R2), 2(R3), 3(R4)
    int sMsg;          // Estado rele mensaje          0, 1
    int tMsgSleep;     // Tiempo pausa rele mensaje    0~32767 segundos
    int tMsgWork;      // Tiempo trabajo rele mensaje  0~32767 segundos
    int sAux;          // Estado rele auxiliar         0, 1
    int tPedalWork;    // Tiempo trabajo rele pedal    0~32767 segundos
};
union MEMORY{
   MYDATA d;
   byte b[sizeof(MYDATA)];
}
memory;



/*******************************/
/***** VARIABLES GLOBALES ******/
/*******************************/
unsigned long tNow            = 0;
unsigned long tPedalBefore    = 0;
unsigned long tMsgSleepBefore = 0;
unsigned long tMsgWorkBefore  = 0;
boolean updateStatus          = true;
boolean btnLeft               = false;
boolean btnRight              = false;
boolean btnCenter             = false;
boolean btnPedal              = false;
boolean bPedal                = false;
boolean exitMenu              = false;
byte menuPosition             = 0;
const byte menuOptions        = 10;     // Numero de opciones de configuracion del menu principal
const byte rowsLCD            = 4;      // Numero de filas del LCD
const byte columnsLCD         = 20;     // Numero de columnas del LCD



/**
 * Configura el Arduino y carga la ultima configuracion.
 */
void setup()
{
    // Configura los pines de salida y entrada:
    for( int i=0 ; i < zRELE_A ; i++ )
        pinMode( pRELE_A[i], OUTPUT );

    for( int i=0 ; i < zRELE_B ; i++ )
        pinMode( pRELE_B[i], OUTPUT );

    pinMode( pRELE_MSG  , OUTPUT );
    pinMode( pRELE_AUX  , OUTPUT );
    pinMode( pRELE_PEDAL, OUTPUT );

    pinMode( pENCO_LEFT  , INPUT );
    pinMode( pENCO_CENTER, INPUT );
    pinMode( pENCO_RIGHT , INPUT );
    pinMode( pPEDAL      , INPUT );

    // Carga la configuracion de la EEPROM, y la configura la primera vez:
    readConfiguration();

    // Inicia el LCD:
    lcd.begin(columnsLCD, rowsLCD);
    lcd.backlight();
    lcd.createChar( icoEmisora,   ico0 );
    lcd.createChar( icoMicrofono, ico1 );
    lcd.createChar( icoDigital,   ico2 );
    lcd.createChar( icoGrabadora, ico3 );
    lcd.createChar( icoLlamador,  ico4 );
    lcd.createChar( icoMensaje,   ico5 );
    lcd.createChar( icoPedal,     ico6 );
    lcd.createChar( icoFlecha,    ico7 );

    // Imprime la informacion del proyecto:
    lcd.setCursor(0,0); lcd.print("Control de emisoras ");
    lcd.setCursor(0,1); lcd.print("  radioaficionado   ");
    lcd.setCursor(0,3); lcd.print(" giltesa.com - v0.9 ");
    delay(2500);
    lcd.clear();
}



/**
 *
 */
void loop()
{
    tNow = seconds();
    readButtons();


    if( btnPedal && !bPedal ){
        bPedal = true;
        tPedalBefore = tNow;
    }
    else if( btnPedal && bPedal ){
        bPedal = false;
    }
    if( btnCenter )
        openMenu();


    // Tareas que se ejecutan solo cada 1 segundo:
    if( millis()%990 == 0 )
    {
        // Actualiza LCD linea 1 y 2: Con estado de los reles del grupo A y B:
        lcd.setCursor(0,0);
        if( memory.d.sGroupA == -1 ){
            lcd.print(" OFF              ");
        }else{
            lcd.write(iRELE_A[memory.d.sGroupA]);
            lcd.print(nRELE_A[memory.d.sGroupA]);
        }
        lcd.setCursor(0,1);
        if( memory.d.sGroupB == -1 ){
            lcd.print(" OFF              ");
        }else{
            lcd.write(iRELE_B[memory.d.sGroupB]);
            lcd.print(nRELE_B[memory.d.sGroupB]);
        }

        // Actualiza LCD linea 3: Con tiempo restante para emitir el mensaje:
        if( memory.d.sMsg && memory.d.tMsgSleep > 0 && memory.d.tMsgWork > 0 )
        {
            if( tMsgSleepBefore + memory.d.tMsgSleep > tNow )
            {
                digitalWrite( pRELE_MSG, LOW );
                lcd.setCursor(0,2);
                lcd.write(icoMensaje);
                lcd.print("Msg conexi:        ");
                lcd.setCursor(13,2);
                lcd.print( tMsgSleepBefore + memory.d.tMsgSleep - tNow );
                lcd.print("s");
                tMsgWorkBefore = tNow;
            }
            else if( tMsgWorkBefore + memory.d.tMsgWork > tNow )
            {
                digitalWrite( pRELE_MSG, HIGH );
                lcd.setCursor(0,2);
                lcd.write(icoMensaje);
                lcd.print("Msg descon:        ");
                lcd.setCursor(13,2);
                lcd.print( tMsgWorkBefore + memory.d.tMsgWork - tNow );
                lcd.print("s");
            }
            else
            {
                tMsgSleepBefore = tNow;
            }
        }

        // Actualiza LCD linea 4: Con tiempo para la desconexion del pedal:
        if( bPedal && tPedalBefore + memory.d.tPedalWork > tNow )
        {
            lcd.setCursor(0,3);
            lcd.write(icoPedal);
            lcd.print("Pedal desc:        ");
            lcd.setCursor(13,3);
            lcd.print( tPedalBefore + memory.d.tPedalWork - tNow );
            lcd.print("s");
            digitalWrite( pRELE_PEDAL, HIGH );
        }
        else
        {
            bPedal = false;
            lcd.setCursor(0,3);
            lcd.print("                    ");
            digitalWrite( pRELE_PEDAL, LOW );
        }

    }// Fin tareas 1 segundo.


    // Establece los nuevos estados I/O
    if( updateStatus )
    {
        updateStatus    = false;
        tMsgSleepBefore = tNow;
        tMsgWorkBefore  = tNow;

        for( int i=0 ; i < zRELE_A ; i++ )
            digitalWrite( pRELE_A[i], LOW );
        if( memory.d.sGroupA > -1 )
            digitalWrite( pRELE_A[memory.d.sGroupA], HIGH );

        for( int i=0 ; i < zRELE_B ; i++ )
            digitalWrite( pRELE_B[i], LOW );
        if( memory.d.sGroupB > -1 )
            digitalWrite( pRELE_B[memory.d.sGroupB], HIGH );

        digitalWrite( pRELE_MSG, memory.d.sMsg );
        digitalWrite( pRELE_AUX, memory.d.sAux );
    }

}



/**
 * Muestra el Menu principal en el LCD.
 */
void openMenu()
{
    lcd.clear();

    while( !exitMenu )
    {
        readButtons();

        if( btnPedal )
        {
            exitMenu = true;
        }
        else if( btnLeft && menuPosition-1 >= 0 )
        {
            menuPosition--;
        }
        else if( btnRight && menuPosition+1 < menuOptions )
        {
            menuPosition++;
        }
        else if( btnCenter )
        {
            switch( menuPosition )
            {
                case 0: openSubMenu( 0, TYPE_RELEA, &memory.d.sGroupA,   -1, 4     ); break; // Rele Grupo A
                case 1: openSubMenu( 1, TYPE_RELEB, &memory.d.sGroupB,   -1, 3     ); break; // Rele Grupo B
                case 2: openSubMenu( 2, TYPE_BOOL,  &memory.d.sMsg,       0, 1     ); break; // Rele Msg Estado
                case 3: openSubMenu( 3, TYPE_INT,   &memory.d.tMsgSleep,  0, 32767 ); break; // Rele Msg T. reposo
                case 4: openSubMenu( 4, TYPE_INT,   &memory.d.tMsgWork,   0, 32767 ); break; // Rele Msg T. func.
                case 5: openSubMenu( 5, TYPE_BOOL,  &memory.d.sAux,       0, 1     ); break; // Rele Aux
                case 6: openSubMenu( 6, TYPE_INT,   &memory.d.tPedalWork, 0, 32767 ); break; // Rele Pedal T. apag
                case 7: writeConfiguration(); exitMenu = true;                        break; // Guarda y sale
                case 8: readConfiguration();  exitMenu = true;                        break; // Cancela los cambios y sale
                case 9:                       exitMenu = true;                        break; // Sale, pero mantiene los cambios temporalmente
            }
        }


        if( !exitMenu && millis()%500 == 0 )
        {
            if(  menuPosition % rowsLCD == 0 )
            {
                for( int i=menuPosition ; i<(menuPosition+rowsLCD) ; i++ )
                {
                    lcd.setCursor(1, i % rowsLCD);
                    lcd.print( i<menuOptions ? nMENU[i] : "                   " );
                }
            }

            if( (menuPosition-(rowsLCD-1)) % rowsLCD == 0 )
            {
                for( int i=(menuPosition-(rowsLCD-1)) ; i<((menuPosition-(rowsLCD-1))+rowsLCD) ; i++ )
                {
                    lcd.setCursor(1, i % rowsLCD);
                    lcd.print( i<menuOptions ? nMENU[i] : "                   " );
                }
            }


            for( int i=0 ; i<rowsLCD ; i++ )
            {
                lcd.setCursor(0,i);
                lcd.print(" ");
            }
            lcd.setCursor(0, menuPosition % rowsLCD );
            lcd.write(icoFlecha);
        }
    }

    exitMenu     = false;
    menuPosition = 0;
    updateStatus = true;
    lcd.clear();
}



/**
 * Muestra el SubMenu en el LCD.
 * @param nameID    Indice del array que contiene el titulo del submenu.
 * @param typeMenu  Segun el tipo, se representara el submenu de una forma u otra.
 * @param value     Puntero a la variable que almacena el dato, y que se modificara.
 * @param minValue  Valor minimo que puede tener la variable.
 * @param maxValue  Valor maximo que puede tener la variable.
 */
void openSubMenu( byte nameID, byte typeMenu, int *value, int minValue, int maxValue )
{
    lcd.clear();

    while( !exitMenu )
    {
        readButtons();

        if( btnCenter || btnPedal )
        {
            exitMenu = true;
        }
        else if( btnLeft  && (*value)-1 >= minValue )
        {
            (*value)--;
        }
        else if( btnRight && (*value)+1 <= maxValue )
        {
            (*value)++;
        }


        if( !exitMenu && millis()%250 == 0 )
        {
            lcd.setCursor(0,0);
            lcd.print(nMENU[nameID]);

            lcd.setCursor(0,1);
            lcd.print("<");
            lcd.setCursor(columnsLCD-1,1);
            lcd.print(">");

            if( typeMenu == TYPE_RELEA )
            {
                lcd.setCursor(1,1);
                lcd.print(*value > minValue ? nRELE_A[*value] : "OFF               " );
            }
            else if( typeMenu == TYPE_RELEB )
            {
                lcd.setCursor(1,1);
                lcd.print(*value > minValue ? nRELE_B[*value] : "OFF               " );
            }
            else if( typeMenu == TYPE_BOOL )
            {
                lcd.setCursor(columnsLCD/2-2,1);
                lcd.print(*value == 0 ? "OFF" : "ON ");
            }
            else if( typeMenu == TYPE_INT )
            {
                lcd.setCursor(columnsLCD/2-4,1);
                lcd.print(*value);
                lcd.print(" seg    ");
            }

        }
    }

    exitMenu     = false;
    menuPosition = 0;
    lcd.clear();
}



/**
 *
 */
void readConfiguration()
{
    for( int i=0 ; i < sizeof(memory.d) ; i++  )
        memory.b[i] = EEPROM.read(i);

    if( !memory.d.initialized )
    {
        memory.d.initialized = true;
        memory.d.sGroupA     = -1;
        memory.d.sGroupB     = -1;
        memory.d.sMsg        = false;
        memory.d.tMsgSleep   = 0;
        memory.d.tMsgWork    = 0;
        memory.d.sAux        = false;
        memory.d.tPedalWork  = 0;
    }
}



/**
 *
 */
void writeConfiguration()
{
    for( int i=0 ; i<sizeof(memory.d) ; i++  )
        EEPROM.write( i, memory.b[i] );
}



/**
 *
 */
void readButtons()
{
    btnLeft   = digitalRead(pENCO_LEFT);
    btnRight  = digitalRead(pENCO_RIGHT);
    btnCenter = digitalRead(pENCO_CENTER);
    btnPedal  = digitalRead(pPEDAL);

    if( btnLeft || btnRight || btnCenter || btnPedal )
    {
        while( digitalRead(pENCO_LEFT) || digitalRead(pENCO_RIGHT) || digitalRead(pENCO_CENTER) || digitalRead(pPEDAL) );
        delay(50);
    }
}



/**
 * @return Segundos que lleva el Arduino encendido.
 */
unsigned long seconds()
{
    return millis()/1000;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

/**

* Name: Arduino - Control de emisoras de radioaficionado

* Autor: Alberto Gil Tesa

* Web: http://giltesa.com

* License: CC BY-NC-SA 3.0

* Version: 0.9

* Date: 2015/02/15

* Arduino Micro, Pinout:

* _______________

* | USB |

* RELE A1 |13 12| RELE A2

* |3V3 11| RELE A3

* |AREF 10| RELE A4

* RELE B1 |A0 9| RELE A5

* RELE B2 |A1 8| RELE MSG

* RELE B3 |A2 7| RELE AUX

* RELE B4 |A3 6| RELE PEDAL

* PEDAL |A4 5| ENCODER IZQUIERDA

* ENCODER CENTRO |A5 4| ENCODER DERECHA

* | 3/SCL| LCD

* | 2/SDA| LCD

* |5V GND|

* |RST RST|

* |GND 1/INT2/RX|

* |VIN 0/INT3/TX|

* |MISO SS|

* |SCK MOSI|

* |_______________|

/*******************************/

/***** LIBRERIAS Y OBJETOS *****/

/*******************************/

#include <Wire.h>

#include <LCD.h>

#include <LiquidCrystal_I2C.h>

#include <EEPROM.h>

LiquidCrystal_I2C lcd( 0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE );

/*******************************/

/********* CONSTANTES **********/

/*******************************/

#define pRELE_MSG 8 // Rele para el mensaje temporizado

#define pRELE_AUX 7 // Rele de los equipos auxiliares

#define pRELE_PEDAL 6 // Rele del microfono del pedal

#define pENCO_LEFT 5 // Encoder izquierda

#define pENCO_CENTER A5 // Encoder centro

#define pENCO_RIGHT 4 // Encoder derecha

#define pPEDAL A4 // Pedal

#define TYPE_RELEA 1

#define TYPE_RELEB 2

#define TYPE_BOOL 3

#define TYPE_INT 4

// Generador de iconos: http://mikeyancey.com/hamcalc/lcd_characters.php

byte ico0[8] = { B00000, B00010, B00010, B00010, B11111, B11111, B11111, B00000 }; // Emisora

byte ico1[8] = { B00000, B01110, B01010, B01110, B00100, B00100, B00100, B00000 }; // Microfono

byte ico2[8] = { B00001, B00011, B00101, B00001, B11101, B10100, B10100, B11100 }; // Digital

byte ico3[8] = { B00000, B00000, B11100, B11111, B10001, B11111, B11111, B00000 }; // Grabadora

byte ico4[8] = { B00000, B00010, B00110, B11110, B11110, B00110, B00010, B00000 }; // Llamador

byte ico5[8] = { B00000, B00000, B11111, B11111, B10101, B10001, B11111, B00000 }; // Mensaje

byte ico6[8] = { B00000, B00000, B10000, B11000, B11110, B11111, B00000, B00000 }; // Pedal

byte ico7[8] = { B00000, B00100, B00110, B11111, B00110, B00100, B00000, B00000 }; // Flecha

const byte icoEmisora=0, icoMicrofono=1, icoDigital=2, icoGrabadora=3, icoLlamador=4, icoMensaje=5, icoPedal=6, icoFlecha=7;

/* RELES A */

const byte zRELE_A = 5; // Numero de reles del GrupoA

const byte pRELE_A[] = { 13, 12, 11, 10, 9 }; // Pines de los reles del GrupoA

const char *nRELE_A[] = { // Nombre de cada rele del GrupoA, maximo 18 caracteres por nombre.

"1. KENWOOD TS-850 ",

"2. YAESU FT-897 ",

"3. KENWOOD TM-742 ",

"4. KENWOOD TR-50 ",

"5. AUXILIAR "

};

const byte iRELE_A[] = {

icoEmisora,

icoEmisora

};

/* RELES B */

const byte zRELE_B = 4; // Numero de reles del GrupoB

const byte pRELE_B[] = { A0, A1, A2, A3 }; // Pines de los reles del GrupoB

const char *nRELE_B[] = { // Nombre de cada rele del GrupoB, maximo 18 caracteres por nombre.

"1. MICROFONO ",

"2. MODOS DIGITALES",

"3. GRABADORA ",

"4. LLAMADOR CQ "

};

const char iRELE_B[] = {

icoMicrofono,

icoDigital,

icoGrabadora,

icoLlamador

};

/* TEXTOS MENUS */

const char *nMENU[] = {

"Rele Grupo A ",

"Rele Grupo B ",

"Rele Msg Estado ",

"Rele Msg T. reposo ",

"Rele Msg T. func. ",

"Rele Aux ",

"Rele Pedal T. apag ",

"Guardar y salir ",

"No guardar y salir ",

"Salir "

};

/*******************************/

/** ESTRUCTURAS CONFIGURACION **/

/*******************************/

struct MYDATA{

int initialized;

int sGroupA; // Estado rele grupo A -1(OFF), 0(R1), 1(R2), 2(R3), 3(R4), 4(R5)

int sGroupB; // Estado rele grupo B -1(OFF), 0(R1), 1(R2), 2(R3), 3(R4)

int sMsg; // Estado rele mensaje 0, 1

int tMsgSleep; // Tiempo pausa rele mensaje 0~32767 segundos

int tMsgWork; // Tiempo trabajo rele mensaje 0~32767 segundos

int sAux; // Estado rele auxiliar 0, 1

int tPedalWork; // Tiempo trabajo rele pedal 0~32767 segundos

};

union MEMORY{

MYDATA d;

byte b[sizeof(MYDATA)];

}

memory;

/*******************************/

/***** VARIABLES GLOBALES ******/

/*******************************/

unsigned long tNow = 0;

unsigned long tPedalBefore = 0;

unsigned long tMsgSleepBefore = 0;

unsigned long tMsgWorkBefore = 0;

boolean updateStatus = true;

boolean btnLeft = false;

boolean btnRight = false;

boolean btnCenter = false;

boolean btnPedal = false;

boolean bPedal = false;

boolean exitMenu = false;

byte menuPosition = 0;

const byte menuOptions = 10; // Numero de opciones de configuracion del menu principal

const byte rowsLCD = 4; // Numero de filas del LCD

const byte columnsLCD = 20; // Numero de columnas del LCD

/**

* Configura el Arduino y carga la ultima configuracion.

void setup()

{

// Configura los pines de salida y entrada:

for( int i=0 ; i < zRELE_A ; i++ )

pinMode( pRELE_A[i], OUTPUT );

for( int i=0 ; i < zRELE_B ; i++ )

pinMode( pRELE_B[i], OUTPUT );

pinMode( pRELE_MSG , OUTPUT );

pinMode( pRELE_AUX , OUTPUT );

pinMode( pRELE_PEDAL, OUTPUT );

pinMode( pENCO_LEFT , INPUT );

pinMode( pENCO_CENTER, INPUT );

pinMode( pENCO_RIGHT , INPUT );

pinMode( pPEDAL , INPUT );

// Carga la configuracion de la EEPROM, y la configura la primera vez:

readConfiguration();

// Inicia el LCD:

lcd.begin(columnsLCD, rowsLCD);

lcd.backlight();

lcd.createChar( icoEmisora, ico0 );

lcd.createChar( icoMicrofono, ico1 );

lcd.createChar( icoDigital, ico2 );

lcd.createChar( icoGrabadora, ico3 );

lcd.createChar( icoLlamador, ico4 );

lcd.createChar( icoMensaje, ico5 );

lcd.createChar( icoPedal, ico6 );

lcd.createChar( icoFlecha, ico7 );

// Imprime la informacion del proyecto:

lcd.setCursor(0,0); lcd.print("Control de emisoras ");

lcd.setCursor(0,1); lcd.print(" radioaficionado ");

lcd.setCursor(0,3); lcd.print(" giltesa.com - v0.9 ");

delay(2500);

lcd.clear();

}

/**

void loop()

{

tNow = seconds();

readButtons();

if( btnPedal && !bPedal ){

bPedal = true;

tPedalBefore = tNow;

}

else if( btnPedal && bPedal ){

bPedal = false;

}

if( btnCenter )

openMenu();

// Tareas que se ejecutan solo cada 1 segundo:

if( millis()%990 == 0 )

{

// Actualiza LCD linea 1 y 2: Con estado de los reles del grupo A y B:

lcd.setCursor(0,0);

if( memory.d.sGroupA == -1 ){

lcd.print(" OFF ");

}else{

lcd.write(iRELE_A[memory.d.sGroupA]);

lcd.print(nRELE_A[memory.d.sGroupA]);

}

lcd.setCursor(0,1);

if( memory.d.sGroupB == -1 ){

lcd.print(" OFF ");

}else{

lcd.write(iRELE_B[memory.d.sGroupB]);

lcd.print(nRELE_B[memory.d.sGroupB]);

}

// Actualiza LCD linea 3: Con tiempo restante para emitir el mensaje:

if( memory.d.sMsg && memory.d.tMsgSleep > 0 && memory.d.tMsgWork > 0 )

{

if( tMsgSleepBefore + memory.d.tMsgSleep > tNow )

{

digitalWrite( pRELE_MSG, LOW );

lcd.setCursor(0,2);

lcd.write(icoMensaje);

lcd.print("Msg conexi: ");

lcd.setCursor(13,2);

lcd.print( tMsgSleepBefore + memory.d.tMsgSleep - tNow );

lcd.print("s");

tMsgWorkBefore = tNow;

}

else if( tMsgWorkBefore + memory.d.tMsgWork > tNow )

{

digitalWrite( pRELE_MSG, HIGH );

lcd.setCursor(0,2);

lcd.write(icoMensaje);

lcd.print("Msg descon: ");

lcd.setCursor(13,2);

lcd.print( tMsgWorkBefore + memory.d.tMsgWork - tNow );

lcd.print("s");

}

else

{

tMsgSleepBefore = tNow;

}

// Actualiza LCD linea 4: Con tiempo para la desconexion del pedal:

if( bPedal && tPedalBefore + memory.d.tPedalWork > tNow )

{

lcd.setCursor(0,3);

lcd.write(icoPedal);

lcd.print("Pedal desc: ");

lcd.setCursor(13,3);

lcd.print( tPedalBefore + memory.d.tPedalWork - tNow );

lcd.print("s");

digitalWrite( pRELE_PEDAL, HIGH );

}

else

{

bPedal = false;

lcd.setCursor(0,3);

lcd.print(" ");

digitalWrite( pRELE_PEDAL, LOW );

}

}// Fin tareas 1 segundo.

// Establece los nuevos estados I/O

if( updateStatus )

{

updateStatus = false;

tMsgSleepBefore = tNow;

tMsgWorkBefore = tNow;

for( int i=0 ; i < zRELE_A ; i++ )

digitalWrite( pRELE_A[i], LOW );

if( memory.d.sGroupA > -1 )

digitalWrite( pRELE_A[memory.d.sGroupA], HIGH );

for( int i=0 ; i < zRELE_B ; i++ )

digitalWrite( pRELE_B[i], LOW );

if( memory.d.sGroupB > -1 )

digitalWrite( pRELE_B[memory.d.sGroupB], HIGH );

digitalWrite( pRELE_MSG, memory.d.sMsg );

digitalWrite( pRELE_AUX, memory.d.sAux );

}

/**

* Muestra el Menu principal en el LCD.

void openMenu()

{

lcd.clear();

while( !exitMenu )

{

readButtons();

if( btnPedal )

{

exitMenu = true;

}

else if( btnLeft && menuPosition-1 >= 0 )

{

menuPosition--;

}

else if( btnRight && menuPosition+1 < menuOptions )

{

menuPosition++;

}

else if( btnCenter )

{

switch( menuPosition )

{

case 0: openSubMenu( 0, TYPE_RELEA, &memory.d.sGroupA, -1, 4 ); break; // Rele Grupo A

case 1: openSubMenu( 1, TYPE_RELEB, &memory.d.sGroupB, -1, 3 ); break; // Rele Grupo B

case 2: openSubMenu( 2, TYPE_BOOL, &memory.d.sMsg, 0, 1 ); break; // Rele Msg Estado

case 3: openSubMenu( 3, TYPE_INT, &memory.d.tMsgSleep, 0, 32767 ); break; // Rele Msg T. reposo

case 4: openSubMenu( 4, TYPE_INT, &memory.d.tMsgWork, 0, 32767 ); break; // Rele Msg T. func.

case 5: openSubMenu( 5, TYPE_BOOL, &memory.d.sAux, 0, 1 ); break; // Rele Aux

case 6: openSubMenu( 6, TYPE_INT, &memory.d.tPedalWork, 0, 32767 ); break; // Rele Pedal T. apag

case 7: writeConfiguration(); exitMenu = true; break; // Guarda y sale

case 8: readConfiguration(); exitMenu = true; break; // Cancela los cambios y sale

case 9: exitMenu = true; break; // Sale, pero mantiene los cambios temporalmente

}

if( !exitMenu && millis()%500 == 0 )

{

if( menuPosition % rowsLCD == 0 )

{

for( int i=menuPosition ; i<(menuPosition+rowsLCD) ; i++ )

{

lcd.setCursor(1, i % rowsLCD);

lcd.print( i<menuOptions ? nMENU[i] : " " );

}

if( (menuPosition-(rowsLCD-1)) % rowsLCD == 0 )

{

for( int i=(menuPosition-(rowsLCD-1)) ; i<((menuPosition-(rowsLCD-1))+rowsLCD) ; i++ )

{

lcd.setCursor(1, i % rowsLCD);

lcd.print( i<menuOptions ? nMENU[i] : " " );

}

for( int i=0 ; i<rowsLCD ; i++ )

{

lcd.setCursor(0,i);

lcd.print(" ");

}

lcd.setCursor(0, menuPosition % rowsLCD );

lcd.write(icoFlecha);

}

exitMenu = false;

menuPosition = 0;

updateStatus = true;

lcd.clear();

}

/**

* Muestra el SubMenu en el LCD.

* @param nameID Indice del array que contiene el titulo del submenu.

* @param typeMenu Segun el tipo, se representara el submenu de una forma u otra.

* @param value Puntero a la variable que almacena el dato, y que se modificara.

* @param minValue Valor minimo que puede tener la variable.

* @param maxValue Valor maximo que puede tener la variable.

void openSubMenu( byte nameID, byte typeMenu, int *value, int minValue, int maxValue )

{

lcd.clear();

while( !exitMenu )

{

readButtons();

if( btnCenter || btnPedal )

{

exitMenu = true;

}

else if( btnLeft && (*value)-1 >= minValue )

{

(*value)--;

}

else if( btnRight && (*value)+1 <= maxValue )

{

(*value)++;

}

if( !exitMenu && millis()%250 == 0 )

{

lcd.setCursor(0,0);

lcd.print(nMENU[nameID]);

lcd.setCursor(0,1);

lcd.print("<");

lcd.setCursor(columnsLCD-1,1);

lcd.print(">");

if( typeMenu == TYPE_RELEA )

{

lcd.setCursor(1,1);

lcd.print(*value > minValue ? nRELE_A[*value] : "OFF " );

}

else if( typeMenu == TYPE_RELEB )

{

lcd.setCursor(1,1);

lcd.print(*value > minValue ? nRELE_B[*value] : "OFF " );

}

else if( typeMenu == TYPE_BOOL )

{

lcd.setCursor(columnsLCD/2-2,1);

lcd.print(*value == 0 ? "OFF" : "ON ");

}

else if( typeMenu == TYPE_INT )

{

lcd.setCursor(columnsLCD/2-4,1);

lcd.print(*value);

lcd.print(" seg ");

}

exitMenu = false;

menuPosition = 0;

lcd.clear();

}

/**

void readConfiguration()

{

for( int i=0 ; i < sizeof(memory.d) ; i++ )

memory.b[i] = EEPROM.read(i);

if( !memory.d.initialized )

{

memory.d.initialized = true;

memory.d.sGroupA = -1;

memory.d.sGroupB = -1;

memory.d.sMsg = false;

memory.d.tMsgSleep = 0;

memory.d.tMsgWork = 0;

memory.d.sAux = false;

memory.d.tPedalWork = 0;

}

/**

void writeConfiguration()

{

for( int i=0 ; i<sizeof(memory.d) ; i++ )

EEPROM.write( i, memory.b[i] );

}

/**

void readButtons()

{

btnLeft = digitalRead(pENCO_LEFT);

btnRight = digitalRead(pENCO_RIGHT);

btnCenter = digitalRead(pENCO_CENTER);

btnPedal = digitalRead(pPEDAL);

if( btnLeft || btnRight || btnCenter || btnPedal )

{

while( digitalRead(pENCO_LEFT) || digitalRead(pENCO_RIGHT) || digitalRead(pENCO_CENTER) || digitalRead(pPEDAL) );

delay(50);

}

/**

* @return Segundos que lleva el Arduino encendido.

unsigned long seconds()

{

return millis()/1000;

}

30 comentarios en “Control de emisoras de radioaficionado con Arduino [4]: Código y vídeo demostrativo”

Buenas, buen trabajo, me encanta
Bueno me encantan muchos trabajos y te encontré porque estoy haciendo un termostato y este menú es lo que necesito, pero tengo el problema de que no puedo o no consigo que en vez de que el TYPE_INT sea de 0,1,2 a mi me gustaría que fuera de 00.00 al 99.99 por ejemplo y llevo dos días pegándome con el código, podrías ayudarme un poco por favor que no tengo ni idea de programar en C++ y estaba usando el MenuBackend pero seme queda corto comparado con el tuyo que es … sin palabras lo que necesitaba
Un saludo Carlos

Responder

Hola Carlos,

Esa función solo permite cambiar números de tipo entero, int o boolean, no funciona con números decimales, float o double, porque los parámetros que le pasas a la función no coinciden con el tipo de dato que le mandas.

Necesitarías crear una segunda función con parámetros distintos, esto se llama sobrecargar una función, las dos se llaman igual pero dependiendo del número y tipo de parámetros que pongas se ejecutara una u otra, por ejemplo:

void openSubMenu( byte nameID, int *value, int minValue, int maxValue, float jumpValue )
{

}

void openSubMenu( byte nameID, int *value, int minValue, int maxValue, float jumpValue )

{

}

Si te fijas he eliminado el segundo parámetro, que ayudaba a saber cómo representar por pantalla la modificación del valor que se le pasaba, porque antes se podían modificar un rango de relés, números enteros y booleans, ahora como solo es para decimales en principio no hace falta.
También he añadido el ultimo parámetro de tipo float para indicar el salto que se ha de dar con cada pulsación… como los números decimales son infinitos es conveniente que sume o reste siempre la misma cantidad, por ejemplo 1.0 si quieres pasar de 22 a 23 a 24, etc., ó 0.5 para pasar de 22 a 22.5, 23, 23.5, etc., ó 0.25, ó 0,10, etc. según el salto que quieras dar.

Así que dentro de la función en vez de hacer:

else if( btnLeft  && (*value)-1 >= minValue )
{
    (*value)--;
}
else if( btnRight && (*value)+1 <= maxValue )
{
    (*value)++;
}

else if( btnLeft && (*value)-1 >= minValue )

{

(*value)--;

}

else if( btnRight && (*value)+1 <= maxValue )

{

(*value)++;

}

Tendrás que hacer:

else if( btnLeft  && (*value)-jumpValue >= minValue )
{
    (*value)-=jumpValue;
}
else if( btnRight && (*value)+jumpValue <= maxValue )
{
    (*value)+=jumpValue;
}

else if( btnLeft && (*value)-jumpValue >= minValue )

{

(*value)-=jumpValue;

}

else if( btnRight && (*value)+jumpValue <= maxValue )

{

(*value)+=jumpValue;

}

Intenta poner como valores mínimo y máximo números a los que se pueda llegar con las sumas/restas de jumpValue, por ejemplo:

minValue = 18
maxValue = 26
jumpValue = 0.5

Con eso ya deberías de poder crear la función para decimales.

Saludos!

Edit:
Ya que estamos te hago una pregunta, que también tengo en mente hacer un termostato pero aun no me he decidido…
Para activar o desactivar la caldera que has usado, un relé normal? Y como fuente de alimentacion, una pequeña que permita empotrarla en el hueco del termostato u otra?

Carlos dice:

21 febrero 2015 a las 15:52 pm

Luego cuando llegue a casa te cuento todo pero vasicamente es un termostato con arduino pro mini con pantalla de 16×2 y wifi rt a otro pro mini que controla el rele como los que usas tu pero los mios son azules jajaa y todo esto conectado a una raspberry y controlarlo por internet, con la raspberry ya lo hice y un amigo me lio para hacerlo en arduino, pero de programacion mi sabiduria se limita un monton
bueno que me enrollo luego te cuento
Carlos dice:

22 febrero 2015 a las 17:57 pm

Bueno el rele es como los que montas tu en el del Control Remoto de Alumbrado y la fuente es de móvil desarmado para el del rele y meterlo en una caja lo mas pequeña posible, para el del control usare pilas ya que lo que interesa es poder llevártelo a una habitacion y que coja la temperatura de ella
giltesa dice:

22 febrero 2015 a las 18:02 pm

Has pensado usar relés de estado solido? Al no tener partes móviles no hacen ruido, aunque solo aguantan 2A a 220V, creo que es suficiente para la caldera ya que imagino que los cables que van conectados al termostato serán para activar el circuito de la caldera, no para encenderla y apagarla.
http://www.ebay.es/itm/271675674782

Mi idea era montarlo todo en uno de estos, pero es complicado, demasiados componentes: http://www.aliexpress.com/item/BHT-100GA-Simple-Non-programmable-Room-Thermostat-White/32279446637.html
Carlos dice:

22 febrero 2015 a las 19:29 pm

No se, primero me tiene que funcionar bien y luego ya pienso o veo como, para empezar comprare el mes que viene la carcasa transparente que comentas en otros post que por unos 6€… por otro lado comprare unas pantallas del 5110 para que sea mas chulo,

No me funciona el menu 🙁 te paso el codigo

#include #include //Libreria LiquidCrystal - Pantalla 16x2 #include #include LiquidCrystal lcd(2, 3, 4, 5, 6, 7); ...
giltesa dice:

22 febrero 2015 a las 19:34 pm

Cuando le das a compilar te sale una lista de errores por los que la compilación no ha podido realizarse. Arregla los errores que te indiquen.

Aunque ya solo por la cantidad de #includes vacíos que pones al principio, ya es razón suficiente para que no funcione.
Carlos dice:

22 febrero 2015 a las 19:36 pm

Si, pero no es factible ademas el ruido lo hace en la caldera, yo para las pruebas comprare la carcasa transparente esta que usas en otros post que por 6€ me valdrá para otros proyectos, también tengo pensado en ponerle una pantalla del 5110 al final.

No me funciona el código 🙁
Estoy intentando ponerlo aquí pero no me deja
Carlos dice:

22 febrero 2015 a las 19:38 pm

No hay errores, simplemente no me deja ponerte el código 🙁
giltesa dice:

22 febrero 2015 a las 19:54 pm

El blog no te deja pegar el código, y tampoco lo voy a revisar linea a linea.

Si el IDE de Arduino no te compila el código es que has cometido algún error al modificarlo, mira que errores te marca el IDE, búscalos y arreglalos.
Si no lo encuentras vuelve a empezar desde el código original y ves editandolo a tu necesidad poco a poco, y tras cada cambio prueba a compilarlo de nuevo.

Carlos dice:

22 febrero 2015 a las 20:40 pm

Ya lógico, solo estoy con el menú tuyo que me parece alucinante y solo quería copiarte tu menú con los siguientes cambios importantes lógicamente todo sobre los reles lo tengo quitado

Si me lo compila pero no me pone en 00.00 me pone en 00 y si esta en 20 solo baja y no sube, lo tuve que configurar void openSubMenu( byte nameID, float jumpValue, int *value, int minValue, int maxValue ) porque daba error luego hice los cambios que me comentaste y en vez de if( typeMenu == TYPE_INT ) he puesto if( jumpValue )

por otro lado en el openMenu, he configurado el case
case 0: openSubMenu( 0, jumpValue, &memory.d.setTemp/*20.00*/, 00.00, 99.99 ); break;

y nada he probado todo lo que yo se y no lo consigo jo

Responder
Campos dice:

23 febrero 2015 a las 10:39 am

Por cierto, no te di las gracias, bueno pues ya lo conseguí después de tirarme desde las 6 de la mañana jajaja lo mio es vicio….
void openSubMenu( byte nameID, float jumpValue, float value, float minValue, float maxValue )

y la verdad es que me encanta el menú como queda wow, lo malo es que no me funciona que coja los resultados value de la EEPROM pero cuando tenga mas tiempo lo mirare jejejeje muchas gracias ya te pasare si lo quieres el codigo

Responder
Iván Blasco dice:

1 marzo 2015 a las 10:30 am

Reles de estado solido para 220 tienes como poco hasta 90 A en tiendas chinas y seguro que en tiendas profesionales tienes de mucho mas un enlace donde se ven algunos
http://www.dx.com/es/s/rele+solid
Muchas gracias por compartir estos proyectos en tu pagina.

Responder
1. giltesa dice:
  
  1 marzo 2015 a las 11:12 am
  
  Bueno es saberlo, gracias.
Javier dice:

11 enero 2016 a las 16:35 pm

Hola, buen dia.
Una pregunta.
¿Lo podré montar a un arduino mega?
saludos!

Responder
1. giltesa dice:
  
  11 enero 2016 a las 17:52 pm
  
  Hola,
  No creo que tengas problemas, no uso ningún código especial como para que haya incompatibilidades entre placas.
  
  Saludos.
2. Javier dice:
  
  14 enero 2016 a las 21:38 pm
  
  Si, disculpa jaja es que no me había fijado bien en la configuración del modulo I2C, pero ya lo revisé.
  Muchas Gracias.
Marcelo dice:

31 enero 2016 a las 14:16 pm

Hola estoy trabajando con tus codigos para hacer un menu de ver parametros y grabar nuevos parametros pero no veo cuando lo hago al pulsador, seguire con eso pero tu menu es genial muchas gracias por publicarlo

Responder
mariano dice:

2 marzo 2016 a las 23:38 pm

Hola, me gustaría saber si tienes más información o si terminaste del todo el proyecto de la conmutación de micrófono para emisoras. Estoy muy interesado
Saludos

Responder
1. giltesa dice:
  
  2 marzo 2016 a las 23:44 pm
  
  Hola,
  
  Esta terminado, me encargaron que hiciera el programa para el Arduino a partir de ciertas especificaciones y es eso lo que he publicado. La persona que me lo encargo lo tiene que unir al resto de sus circuitos eléctricos.
  
  Saludos.
Carlos dice:

1 julio 2016 a las 4:59 am

¡Perfecto Gil! Gran trabajo el tuyo. ¿Las conexiones entre botones – Arduino y LCD – Arduino son las mismas que en tu anterior proyecto https://giltesa.com/2012/07/06/menu-en-un-lcd-con-arduino?

Responder
1. giltesa dice:
  
  1 julio 2016 a las 11:39 am
  
  Hola Carlos,
  
  No, no tiene nada que ver eso. El hardware para este proyecto lo hizo quien me encargo la parte de software, me paso esta foto de su placa:
  
  Saludos.
Anabel dice:

21 octubre 2016 a las 12:22 pm

Hola! Llevaba semanas luchando con Arduino para crear un programa con lcd+encoder+menu y el tuyo me ha resultado fantastco! El único problema que tengo es que estoy utilizando una pantalla de 16×2 y al intentar utilizar tu programa en él no consigo que aparezca nada, simplemente el inicio. ¿Podrías echarme una mano?

Responder
1. giltesa dice:
  
  21 octubre 2016 a las 14:36 pm
  
  Hola Anabel,
  
  Tienes que indicar en el código el número de columnas y filas del LCD, con eso debería de funcionar para esa pantalla aunque no lo he probado.
  
  También tendrás acortar los textos al entrar menos caracteres por línea y eliminar el código en el que se escriba explícitamente en la tercera o cuarta línea del LCD.
  
  Saludos.
2. Anabel dice:
  
  22 octubre 2016 a las 0:14 am
  
  Si, es exactamente lo que he hecho, cambiar el numero de filas y columnas:
  
  const byte rowsLCD = 2; // Numero de filas del LCD
  const byte columnsLCD = 16; // Numero de columnas del LCD
  
  Y los pines de SDA y SCL también los cambié ya que utilizo Arduino Nano, según la entrada que realizaste de las configuraciones de arduino. También incorporé el encoder, y solo me realiza la pantalla de inicio, es decir, donde aparece el texto:
  // Imprime la informacion del proyecto:
  lcd.setCursor(0,0); lcd.print(«Control emisoras»);
  lcd.setCursor(0,1); lcd.print(«radioaficionado»);
  Y a continuación limpia la pantalla sin aparecer nada :/
3. giltesa dice:
  
  22 octubre 2016 a las 18:32 pm
  
  He toqueteado un poco el código y a mi si me funciona, al menos muestra el primer menú por completo, aunque luego se pone a imprimir caracteres extraños por pantalla, seguramente por no ajustar todas las impresiones al nuevo ancho/columnas de la pantalla. Te dejo el código por si te sirve, es para una shield LCD.
  
  https://giltesa.com/wp-content/uploads/2015/02/Menu-LCD-2×16.c
  
  Saludos.
4. Anabel dice:
  
  23 octubre 2016 a las 2:26 am
  
  Muchísimas gracias por modificar el código, pero sigue sin funcionarme. Es cierto que estoy utilizando un LCD I2C, pero no creo que ese sea el problema, ya que al iniciar el programa si me aparece el mensaje inicial, y además he probado con tu entrada anterior «https://giltesa.com/2014/02/18/pantalla-lcd-por-comunicacion-i2c-para-arduino» para asegurarme que no es problema de mi pantalla y me funciona perfectamente. Quizás sea un problema en la EEPROM de mi Arduino, no se me ocurre nada más. Seguiré investigando a ver si resuelvo el tema y te comento.
  Aún así muchas gracias por tu pronta contestación!
5. giltesa dice:
  
  23 octubre 2016 a las 11:48 am
  
  Fíjate que también cambie la lectura de los botones (la prueba la hice con una Shield LCD que usa un pad analógico y no digital como el encoder)
  
  Saludos.
Anabel dice:

23 octubre 2016 a las 17:14 pm

Era eso… Estaba realizando las pruebas con el encoder y simplemente al cambiarlo por los botones ya funcionaba perfectamente!!
Muchas gracias por tu ayuda!

Responder
Jersson avila dice:

15 junio 2021 a las 2:48 am

Hola Gil, cómo está
Necesito una tutoría en qué WhatsApp o correo lo puedo contactar para más información

Responder