Osvitka – osvětlovací jednotka pro fotocitlivé DPS – update 25.10.14

Rozhodl jsem se po stavbu osvitové jednotky pro fotocitlivé desky plošných spojů, které používám při výrobě kusových desek. Požadavkem bylo využití jiného zdroje světla než je známé “horské sluníčko”, které způsobovalo nenávratné škody na pokojových rostlinách. Nakonec jsem se rozhodl použit nastříhaný pásek ultra fialových LED. Nově jsem se pokusil o tvorbu řídící části založenou na Arduino, to umožní stavbu každému včetně začátečníků, bez potřeby výroby DPS, programátorů a znalostí osazování součástek na DPS. Posledním požadavkem byl nějaký slušně vypadající kryt, který pak ukázal být nejdražší částí osvitky.

Zařízení je umístěno do laserem řezané dřevěné desky MDF v tloušťce 6mm o rozměrech cca 190 x 92 x 240mm. Velikost osvětlovací plochy je 120 x 160mm, tvořené sklem tloušťky 5mm o rozměrech 130 x 170mm. Pro výrobu jsem použil služeb portálu iDílna.cz , zde doporučuji neposílat soubory e-mailem, ale použít zadávacího systému na stránkách, protože ušetříte za zpracování objednávky (podstatná část z ceny). Potřebné soubory DXF jsou přiloženy na konci článku. Toto je pouze možnost, jak si usnadnit výrobu, rozměry si může každý zvolit podle svého, elektronika je univerzální a jednoduchá.

Nyní se již zaměřím na samotnou konstrukci elektronické části. Napájecí zdroj je tvořen nějakým spínaným zdrojem, který nám zbyl myslím od nějakého routeru Mikrotik (12v/3A). Můžete použít podle vašich možností, důležité je pouze dodržet výstupní napětí 12V, kterým je napájeno Arduino ( 12V je maximální napájecí napětí) a LED pásky. Případně lze do otvoru umístit samotný konektor a zdroj použít i jiného rozměru.
Arduino je použito v provedení UNO (328), lze použít nějaký z jeho klonů (~~na ebay jsem kupoval kolem $9,~~ dnes lepší nakoupit na www.banggood.com, což je obdoba asi známějšího www.dx.com) a jako LCD zobrazovač je použit už hotový shield ~~opět z ebay~~ (pomoci by vám měl tento odkaz, ceny kolem $4). Deska obsahuje i tlačítka, která jsou pak snímána ADC převodníkem jako odporový dělič. Na samotné tlačítka pak přilepte plastovou tyčku, tak aby vystupovala skrze vypálené otvory. Jedinou úpravou je přeletování trimru pro řízení kontrastu na spodní část desky, protože jinak by vadil umístění do krytu. Propojení obou desek je pak pomocí kablíků, stačí propojit pouze zapojené piny podle schématu. Z Arduino jsem odletoval napájecí konektor a připevnil pomocí sloupků tak, že USB konektor je na boční straně a umožňuje případnou změnu firmware.

LCD Shield

Schéma osvitky

Osvětlovací část je tvořena nastříhaným LED UV páskem. Použil jsem pásek s 60 LED 5050 na 1m o příkonu 14,4W a standardním napájecím napětí 12V. Do prostoru se vešlo 54 LED, což odpovídá 13W. Pásek je nastříhán na 6 kusů o 12cm dlouhé kousky, ty jsou pak přilepeny na hliníkový plech, který tvoří chlazení a reflektor. Ve vnitřním prostoru je celek uchycen na distanční sloupky a okolí nastříkáno stříbrnou barvou.
Při tomto výkonu mi vychází ideální čas osvitu pro desky koupené u GME a TME na 5-7min. Ještě jsem zkoušel nějakou desku, která je cca 18let stará, ale byla uložená ve tmě a i ta kupodivu byla funkční s dobou osvitu 3-5min. Bohužel nemám možnost otestovat desky pokryté lakem “POSITIV 20″, tak pokud by mi někdo zaslal kousek cca 4×10 cm nebo 4 kousky 4×2,5cm rád otestuji vhodné doby. K vytištění předlohy používám laserovou tiskárnu (nejzákladnější model od Xeroxu) a tisknu na transparentní fólii opět od Xeroxu s výrobním označením “003R98205″ (balení 50ks velikosti A4). Vzor vytisknu na jednu stránku na dvě místa, pak rozstřihnu a přiložím na sebe (fixuji malířskou páskou), tím docílím dokonalého neprůsvitného vzoru.

Výkonový tranzistor N-MOS je možné volit podle toho co najdete doma. Já našel vzorky od NXP, které jsou trošku předimenzované s jejich spínacím odporem pouhých 7mΩ a proudem 100A. Vy můžete volit nějaký typ, který bude dostatečný pro spínané proudy do LED okolo 1,2A. Tranzistor je umístěn na UNI desce, kde část desky tvoří případný chladič. Ještě je zde umístěný malinký reproduktor, který jsem vypájel z nějaké staré základní desky (odpor 47Ω) v sérii s odporem 220Ω.

Co se týká obslužného programu, jde o mojí prvotinu s prostředím Arduino a tak prosím o shovívavost. Z tohoto důvodu jsem použil jako základ nějaký program, který byl původně kuchyňskou minutkou a nakonec z něj zůstala pouze část měřící čas.
Obsluha je jednoduchá, nejdříve zvolíte počet minut, následně přejdete na volbu desítek sekund a poslední volbou je možnost změnit výkon svitu LED. V průběhu osvitu je možnost osvit pozastavit a nebo úplně ukončit. Samozřejmostí je pamatování si posledního nastaveného času, zvuková a světelná indikace na konci osvitu.

UPDATE v1.1:
– bugfix dlouhého držení kláves
– přidáno potvrzení před zahájením osvitu s možností návratu do menu
– přidána zvuková indikace stisku kláves

// OSVITKA v.1.1
// casovac pro osvetlovaci jednotku DPS
// 
// v.1.1 
// rozsireni menu o moznost navratu 
// bug fix dlouheho stisku
// pridani zvukove odezvy tlacitek

#include <LiquidCrystal.h>
#include "pitches.h"
#include "EEPROM.h" 

//Pin assignments for SainSmart LCD Keypad Shield
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// voltage values for the buttons - zde mozne provadet korekci
const int  ADC_KEY_VOLTAGE[5] ={30, 150, 360, 535, 760 };
// how many butons we have
const int NUM_KEYS = 5;
// constants for the buttons
const int RIGHT = 0;
const int UP = 1;  
const int DOWN = 2;
const int LEFT = 3;
const int OK = 4;
// backlight pin
const int BKLIGHT_PIN = 10;
// LED pin
const int LED_PIN = 3;
// speaker pin
const int TONE_PIN = 11;
// tune notes
const int TUNE_NOTES[] = {NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4};
// tune note durations
const int TUNE_TIMES[] = {4, 8, 8, 4,4,4,4,4};
// tune length (no of notes)
const int TUNE_LENGTH = 8;
// delay before key repeating starts
const int KEY_REPEAT_DELAY = 800;
// delay between individual key repeats
const int KEY_REPEAT_INTERVAL = 200;

byte c_down[8] = {
  B00000,
  B00000,
  B00000,
  B01110,
  B01110,
  B11111,
  B01110,
  B00100,
};
byte c_play[8] = {
  B00000,
  B11000,
  B11110,
  B11111,
  B11110,
  B11000,
  B00000,
  B00000,
};
byte c_stop[8] = {
  B00000,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B00000,
  B00000,
};
byte c_pause[8] = {
  B00000,
  B11011,
  B11011,
  B11011,
  B11011,
  B11011,
  B00000,
  B00000,
};
byte c_ecko[8] = {
  B01010,
  B00100,
  B01110,
  B10001,
  B11111,
  B10000,
  B01110,
  B00000,
};
byte c_acko[8] = {
  B00010,
  B00100,
  B01110,
  B00001,
  B01111,
  B10001,
  B01111,
  B00000,
};
byte c_right[8] = {
  B00000,
  B00100,
  B00010,
  B11111,
  B00010,
  B00100,
  B00000,
  B00000,
};


int oldkey=-1;
// State is one of:
// 60: waiting for input min
// 61: waiting for input sec
// 62: waiting for input power out
// 63: confirm set or back
// 11: counting down
// 12: pause to next stop
// 13: pause to next play
// 2: flashing screen
// 3: playing tone
// 4: end state: user is up
int state = 60;
// current brightness for the backlight
int brightness = 100;
// minutes value
int mins;
int minsold = mins;
int minspause = 0;
// seconds value
int secs;
int secsold = secs;
int secspause = 0;
// performance output LED
int power;
// repeat sound
int tuneRepeat = 0;
// time alarm is due
unsigned long alarmTime = 0;
// time we started counting down
unsigned long startTime = 0;
// time we started playing the tune
unsigned long tuneStart = 0;
// last time a new key press event started
unsigned long keyPressStart = 0;
// is the user already up (we've been in state 4 before) 
boolean awake = false;
unsigned long remainingTime;


void setup() { 
  pinMode(BKLIGHT_PIN, OUTPUT); // pin for backlight control
  pinMode(LED_PIN, OUTPUT); 	// pin for output LED
  digitalWrite(LED_PIN, LOW);
  delay(10);
  lcd.createChar(1,c_down);
  lcd.createChar(2,c_play);
  lcd.createChar(3,c_stop);
  lcd.createChar(4,c_pause);
  lcd.createChar(5,c_right);
  lcd.createChar(7,c_ecko);  
  lcd.createChar(8,c_acko);
  lcd.begin(16, 2);
  analogWrite(BKLIGHT_PIN, brightness);
  mins = EEPROM.read(0);
  secs = EEPROM.read(1);
  power = EEPROM.read(2);
  if (mins == 255 || secs == 255 || power == 255) {
	mins = 8;
	secs = 0;
	power = 100;
  }
  lcd.clear();					// start test LCD, LED and beep
  lcd.print("OSVITKA     v1.1");
  lcd.setCursor(2,1);
  lcd.print("by BorgMcz");
  delay(1500);
  lcd.setCursor(2,1);
  lcd.print("www.dccmm.cz");  
  testLed();
  delay(500);
  lcd.clear();
  lcd.setCursor(1, 0);
  lcd.write(1);
  displayPower(power);
}

void loop() {
  int key = getKey();
  
  if(state == 60) { // reading input mins
    if(key == UP){
      mins++;
      if(mins >= 100) mins = 99;
    } else if(key == DOWN){
      mins--;
      if(mins < 0) mins = 0;
    } else if(key == OK) {
      state = 61;
	  lcd.setCursor(1, 0);
	  lcd.print("   ");
	  lcd.write(1);
    }
    displayTime(mins, secs);
	
 } else if(state == 61) { // reading input sec
    if(key == UP){
      secs+= 10;
      if(secs >= 60) secs = 50;
    } else if(key == DOWN){
      secs-= 10;
      if(secs < 0) secs = 0;
    } else if(key == OK) {
      state = 62;
	  lcd.setCursor(4, 0);
	  lcd.print(" ");
	  lcd.setCursor(14,0);
	  lcd.write(1);
	  minsold = mins;
	  secsold = secs;
	  EEPROM.write (0, mins);
	  EEPROM.write (1, secs);
    }
    displayTime(mins, secs);	
	
 } else if(state == 62) { // reading input power
    if(key == UP){
      power+= 10;
      if(power >= 100) power = 100;
    } else if(key == DOWN){
      power-= 10;
      if(power < 10) power = 10;
    } else if(key == OK) {
	  EEPROM.write (2, power);
      state = 63;
	  lcd.setCursor(14,0);
	  lcd.print(" ");
	  lcd.setCursor(0, 0);
      lcd.print("+ osvit   - zp");
	  lcd.write(7);
      lcd.print("t");
    }
    displayPower(power);
	
 } else if(state == 63) { // reading input power
    if(key == UP){
      state = 11;
      lcd.print("                ");
      state = 11;
      startTime = 0;
	  analogWrite(LED_PIN, (power * 2.55));
	  } else if(key == DOWN){
      state = 60;
	  lcd.home();
	  lcd.print("      STOP      ");
	  delay(1000);
	  lcd.clear();
	  lcd.setCursor(1, 0);
	  lcd.write(1);
	  displayPower(power);
	  }
 } else if(state == 12) { // pause next stop
	lcd.setCursor(14,0);
	lcd.write(5);
	lcd.write(3);
	if(key == UP){
      state = 13;
    } else if(key == DOWN){
      state = 13;
    } else if(key == OK) {
	  lcd.home();
	  lcd.print("      STOP      ");
	  delay(1000);
	  state = 60;
	  reset();
    }

 } else if(state == 13) { // pause next play
	lcd.setCursor(15,0);
	lcd.write(2);
	if(key == UP){
      state = 12;
    } else if(key == DOWN){
      state = 12;
    } else if(key == OK) {
      state = 11;
	  lcd.setCursor(14,0);
	  lcd.print("  ");
	  alarmTime = 0;
	  startTime = 0;
	  tuneStart = 0;
	  analogWrite(LED_PIN, (power * 2.55));
    }

	
  } else if(state == 11) { // counting down
    unsigned long time = millis();
    if(startTime == 0) { // just started counting down
      startTime = time;
      // calculate the target time
      alarmTime = startTime+ 60000ul * mins + 1000ul * secs;
      lcd.clear();
	  lcd.write(2);
      lcd.print("  ..OSVIT..");
	  displayPower(power);
      // start dimming the lights
    }
    if(alarmTime > time) {
      // we're still waiting
      // if any key is pressed, turn on the light
       if(key >= 0) {   // POUZIJI PRO PRERUSENI ZA BEHU
          analogWrite(LED_PIN, 0);
		  lcd.home();
		  lcd.write(4);
		  lcd.print("    PAUSA  ");
		  state = 12;
		  mins = (remainingTime / 60000);
		  secs = ((remainingTime % 60000) / 1000);
        }
      remainingTime = alarmTime - time; 
      // update the time shown
      displayTime(remainingTime / 60000, (remainingTime % 60000) / 1000);
    } else {
      // we're done waiting
      state = 2;
    }
  } else if(state == 2) {  // blink for 10 seconds
    lcd.home();
	lcd.write(3);
	lcd.print("    HOTOVO ");
	analogWrite(LED_PIN, 0);
	if(key >= 0) { // if any key pressed, stop
      state = 60;
	  reset();
    } else {
      unsigned long elapsedTime = millis() - alarmTime;
      if(elapsedTime < 6000) {
        int sign = (elapsedTime / 1000) %2;
        brightness = (elapsedTime % 1000) / 4;
        if(sign == 1) brightness = 255 - brightness; 
      } else {
        brightness = 100;
        state = 3;
      }
    }
  } else if(state == 3) { // play a tune
    if(key >= 0) { // if any key pressed, stop
      noTone(TONE_PIN);
      state = 60;
	  reset();
    } else {
      unsigned long time = millis();
      if(tuneStart == 0) tuneStart = time;
      long tuneTime = time - tuneStart;
      for(int i = 0; i < TUNE_LENGTH && tuneTime > 0; i++) {
        tuneTime -= (1000 / TUNE_TIMES[i]);        
        if(tuneTime <= 0) {
          // current note
          tone(TONE_PIN, TUNE_NOTES[i]);
        }
      }
      if(tuneTime > 0) {
        // song over;
        noTone(TONE_PIN);
        if(tuneTime > 1000) {
          // play again, after a second
          tuneStart = 0;
		  // number of repeats sounds
		  if(tuneRepeat == 2) {
		  state = 4;
		  tuneRepeat = 0;
		  } else {
		  tuneRepeat++;
		  }
        }
      }
    }
  } else if(state == 4) { // end state
    if(!awake) {
      brightness = 100;
      lcd.clear();
//	  lcd.write(3);
      lcd.print("     HOTOVO  ");
      lcd.setCursor(0, 1);
      lcd.print("Stisk pro n");
	  lcd.write(8);
	  lcd.print("vrat");
      awake = true;
    }
    if(key >= 0) {
      reset();
    }
  }
  
  analogWrite(BKLIGHT_PIN, brightness);
  delay(20);
}

void reset() {
  state = 60;
  brightness = 100;
  mins = minsold;
  secs = secsold;
  alarmTime = 0;
  startTime = 0;
  tuneStart = 0;
  awake = false;
  lcd.clear();
  lcd.setCursor(1, 0);
  lcd.write(1);
  analogWrite(BKLIGHT_PIN, brightness);
  displayPower(power); 
}

// Read a key (if any was pressed)
// Convert ADC value to key number
int getKey() {
  int k = decodeKey();
  if (k == -1) {
    // no key pressed
    keyPressStart = 0;
  } else {
    // possible new key press event: debounce and re-read
    delay(20);
    k = decodeKey();
    if (k == -1){
      // false start:  No valid key pressed
      keyPressStart = 0;
    } else {
      // key press confirmed
      if(keyPressStart == 0) {
        // it's a new event
        keyPressStart = millis();
        oldkey = k;
		tone(TONE_PIN, NOTE_C8, 100);
		} else {
        if(oldkey == k) {
          // long press of oldKey
          unsigned long duration = millis() - keyPressStart;
          if(duration >= KEY_REPEAT_DELAY) {
            // return a key, and schedule a new one after KEY_REPEAT_INTERVAL
            keyPressStart = keyPressStart + duration - KEY_REPEAT_DELAY + KEY_REPEAT_INTERVAL;
			tone(TONE_PIN, NOTE_C8, 100);
          } else {
            // we're waiting, so we report no key press
            k = -1;
          }
        } else {
          // new key now pressed
          keyPressStart = millis();
          oldkey = k;
        }
      } 
    }
  }
  return k;
}

// Reads a key input from the input pin
int decodeKey() {
  unsigned int input = analogRead(0);    // read the value from the sensor
  int k;
  for (k = 0; k < NUM_KEYS; k++) {
    if (input < ADC_KEY_VOLTAGE[k]) {
      //return k;
      break;
    }
  }
  if (k >= NUM_KEYS) {
    k = -1;     // No valid key pressed
  }
  return k;
}

void displayTime(int mins, int secs) {
  lcd.setCursor(0, 1);  //line=2, x=0
  char minMsg[3] = {'0' + (mins / 10), '0' + (mins % 10), 0};
  lcd.print(minMsg);
  lcd.print(":");
  char secMsg[3] = {'0' + (secs / 10), '0' + (secs % 10), 0};
  lcd.print(secMsg);
}

void displayPower(int power) {
	lcd.setCursor(12, 1); //line=2, x=13
	if (power == 100) {
	lcd.print("100%");
	} else {
	lcd.print(" ");
	char powerMsg[3] = {'0' + (power / 10), '0' + (power % 10), 0};
	lcd.print(powerMsg);
	lcd.print("%");
	}
}

void testLed() {
	tone(TONE_PIN, NOTE_C5, 300);
	delay(350);
	for (int x=1; x <= 255; x++){
      analogWrite(LED_PIN, x);
      delay(10);
	}
	tone(TONE_PIN, NOTE_C3, 300);
	delay(350);
	for (int x=255; x >= 0; x--){
      analogWrite(LED_PIN, x);
      delay(10);
	}  
	analogWrite(LED_PIN, 0);
}

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

// OSVITKA v.1.1

// casovac pro osvetlovaci jednotku DPS

// v.1.1

// rozsireni menu o moznost navratu

// bug fix dlouheho stisku

// pridani zvukove odezvy tlacitek

#include <LiquidCrystal.h>

#include "pitches.h"

#include "EEPROM.h"

//Pin assignments for SainSmart LCD Keypad Shield

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// voltage values for the buttons - zde mozne provadet korekci

const int ADC_KEY_VOLTAGE[5] ={30, 150, 360, 535, 760 };

// how many butons we have

const int NUM_KEYS = 5;

// constants for the buttons

const int RIGHT = 0;

const int UP = 1;

const int DOWN = 2;

const int LEFT = 3;

const int OK = 4;

// backlight pin

const int BKLIGHT_PIN = 10;

// LED pin

const int LED_PIN = 3;

// speaker pin

const int TONE_PIN = 11;

// tune notes

const int TUNE_NOTES[] = {NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4};

// tune note durations

const int TUNE_TIMES[] = {4, 8, 8, 4,4,4,4,4};

// tune length (no of notes)

const int TUNE_LENGTH = 8;

// delay before key repeating starts

const int KEY_REPEAT_DELAY = 800;

// delay between individual key repeats

const int KEY_REPEAT_INTERVAL = 200;

byte c_down[8] = {

B00000,

B01110,

B11111,

B01110,

B00100,

};

byte c_play[8] = {

B00000,

B11000,

B11110,

B11111,

B11110,

B11000,

B00000,

};

byte c_stop[8] = {

B00000,

B11111,

B00000,

};

byte c_pause[8] = {

B00000,

B11011,

B00000,

};

byte c_ecko[8] = {

B01010,

B00100,

B01110,

B10001,

B11111,

B10000,

B01110,

B00000,

};

byte c_acko[8] = {

B00010,

B00100,

B01110,

B00001,

B01111,

B10001,

B01111,

B00000,

};

byte c_right[8] = {

B00000,

B00100,

B00010,

B11111,

B00010,

B00100,

B00000,

};

int oldkey=-1;

// State is one of:

// 60: waiting for input min

// 61: waiting for input sec

// 62: waiting for input power out

// 63: confirm set or back

// 11: counting down

// 12: pause to next stop

// 13: pause to next play

// 2: flashing screen

// 3: playing tone

// 4: end state: user is up

int state = 60;

// current brightness for the backlight

int brightness = 100;

// minutes value

int mins;

int minsold = mins;

int minspause = 0;

// seconds value

int secs;

int secsold = secs;

int secspause = 0;

// performance output LED

int power;

// repeat sound

int tuneRepeat = 0;

// time alarm is due

unsigned long alarmTime = 0;

// time we started counting down

unsigned long startTime = 0;

// time we started playing the tune

unsigned long tuneStart = 0;

// last time a new key press event started

unsigned long keyPressStart = 0;

// is the user already up (we've been in state 4 before)

boolean awake = false;

unsigned long remainingTime;

void setup() {

pinMode(BKLIGHT_PIN, OUTPUT); // pin for backlight control

pinMode(LED_PIN, OUTPUT); // pin for output LED

digitalWrite(LED_PIN, LOW);

delay(10);

lcd.createChar(1,c_down);

lcd.createChar(2,c_play);

lcd.createChar(3,c_stop);

lcd.createChar(4,c_pause);

lcd.createChar(5,c_right);

lcd.createChar(7,c_ecko);

lcd.createChar(8,c_acko);

lcd.begin(16, 2);

analogWrite(BKLIGHT_PIN, brightness);

mins = EEPROM.read(0);

secs = EEPROM.read(1);

power = EEPROM.read(2);

if (mins == 255 || secs == 255 || power == 255) {

mins = 8;

secs = 0;

power = 100;

}

lcd.clear(); // start test LCD, LED and beep

lcd.print("OSVITKA v1.1");

lcd.setCursor(2,1);

lcd.print("by BorgMcz");

delay(1500);

lcd.setCursor(2,1);

lcd.print("www.dccmm.cz");

testLed();

delay(500);

lcd.clear();

lcd.setCursor(1, 0);

lcd.write(1);

displayPower(power);

}

void loop() {

int key = getKey();

if(state == 60) { // reading input mins

if(key == UP){

mins++;

if(mins >= 100) mins = 99;

} else if(key == DOWN){

mins--;

if(mins < 0) mins = 0;

} else if(key == OK) {

state = 61;

lcd.setCursor(1, 0);

lcd.print(" ");

lcd.write(1);

}

displayTime(mins, secs);

} else if(state == 61) { // reading input sec

if(key == UP){

secs+= 10;

if(secs >= 60) secs = 50;

} else if(key == DOWN){

secs-= 10;

if(secs < 0) secs = 0;

} else if(key == OK) {

state = 62;

lcd.setCursor(4, 0);

lcd.print(" ");

lcd.setCursor(14,0);

lcd.write(1);

minsold = mins;

secsold = secs;

EEPROM.write (0, mins);

EEPROM.write (1, secs);

}

displayTime(mins, secs);

} else if(state == 62) { // reading input power

if(key == UP){

power+= 10;

if(power >= 100) power = 100;

} else if(key == DOWN){

power-= 10;

if(power < 10) power = 10;

} else if(key == OK) {

EEPROM.write (2, power);

state = 63;

lcd.setCursor(14,0);

lcd.print(" ");

lcd.setCursor(0, 0);

lcd.print("+ osvit - zp");

lcd.write(7);

lcd.print("t");

}

displayPower(power);

} else if(state == 63) { // reading input power

if(key == UP){

state = 11;

lcd.print(" ");

state = 11;

startTime = 0;

analogWrite(LED_PIN, (power * 2.55));

} else if(key == DOWN){

state = 60;

lcd.home();

lcd.print(" STOP ");

delay(1000);

lcd.clear();

lcd.setCursor(1, 0);

lcd.write(1);

displayPower(power);

}

} else if(state == 12) { // pause next stop

lcd.setCursor(14,0);

lcd.write(5);

lcd.write(3);

if(key == UP){

state = 13;

} else if(key == DOWN){

state = 13;

} else if(key == OK) {

lcd.home();

lcd.print(" STOP ");

delay(1000);

state = 60;

reset();

}

} else if(state == 13) { // pause next play

lcd.setCursor(15,0);

lcd.write(2);

if(key == UP){

state = 12;

} else if(key == DOWN){

state = 12;

} else if(key == OK) {

state = 11;

lcd.setCursor(14,0);

lcd.print(" ");

alarmTime = 0;

startTime = 0;

tuneStart = 0;

analogWrite(LED_PIN, (power * 2.55));

}

} else if(state == 11) { // counting down

unsigned long time = millis();

if(startTime == 0) { // just started counting down

startTime = time;

// calculate the target time

alarmTime = startTime+ 60000ul * mins + 1000ul * secs;

lcd.clear();

lcd.write(2);

lcd.print(" ..OSVIT..");

displayPower(power);

// start dimming the lights

}

if(alarmTime > time) {

// we're still waiting

// if any key is pressed, turn on the light

if(key >= 0) { // POUZIJI PRO PRERUSENI ZA BEHU

analogWrite(LED_PIN, 0);

lcd.home();

lcd.write(4);

lcd.print(" PAUSA ");

state = 12;

mins = (remainingTime / 60000);

secs = ((remainingTime % 60000) / 1000);

}

remainingTime = alarmTime - time;

// update the time shown

displayTime(remainingTime / 60000, (remainingTime % 60000) / 1000);

} else {

// we're done waiting

state = 2;

}

} else if(state == 2) { // blink for 10 seconds

lcd.home();

lcd.write(3);

lcd.print(" HOTOVO ");

analogWrite(LED_PIN, 0);

if(key >= 0) { // if any key pressed, stop

state = 60;

reset();

} else {

unsigned long elapsedTime = millis() - alarmTime;

if(elapsedTime < 6000) {

int sign = (elapsedTime / 1000) %2;

brightness = (elapsedTime % 1000) / 4;

if(sign == 1) brightness = 255 - brightness;

} else {

brightness = 100;

state = 3;

}

} else if(state == 3) { // play a tune

if(key >= 0) { // if any key pressed, stop

noTone(TONE_PIN);

state = 60;

reset();

} else {

unsigned long time = millis();

if(tuneStart == 0) tuneStart = time;

long tuneTime = time - tuneStart;

for(int i = 0; i < TUNE_LENGTH && tuneTime > 0; i++) {

tuneTime -= (1000 / TUNE_TIMES[i]);

if(tuneTime <= 0) {

// current note

tone(TONE_PIN, TUNE_NOTES[i]);

}

if(tuneTime > 0) {

// song over;

noTone(TONE_PIN);

if(tuneTime > 1000) {

// play again, after a second

tuneStart = 0;

// number of repeats sounds

if(tuneRepeat == 2) {

state = 4;

tuneRepeat = 0;

} else {

tuneRepeat++;

}

} else if(state == 4) { // end state

if(!awake) {

brightness = 100;

lcd.clear();

// lcd.write(3);

lcd.print(" HOTOVO ");

lcd.setCursor(0, 1);

lcd.print("Stisk pro n");

lcd.write(8);

lcd.print("vrat");

awake = true;

}

if(key >= 0) {

reset();

}

analogWrite(BKLIGHT_PIN, brightness);

delay(20);

}

void reset() {

state = 60;

brightness = 100;

mins = minsold;

secs = secsold;

alarmTime = 0;

startTime = 0;

tuneStart = 0;

awake = false;

lcd.clear();

lcd.setCursor(1, 0);

lcd.write(1);

analogWrite(BKLIGHT_PIN, brightness);

displayPower(power);

}

// Read a key (if any was pressed)

// Convert ADC value to key number

int getKey() {

int k = decodeKey();

if (k == -1) {

// no key pressed

keyPressStart = 0;

} else {

// possible new key press event: debounce and re-read

delay(20);

k = decodeKey();

if (k == -1){

// false start: No valid key pressed

keyPressStart = 0;

} else {

// key press confirmed

if(keyPressStart == 0) {

// it's a new event

keyPressStart = millis();

oldkey = k;

tone(TONE_PIN, NOTE_C8, 100);

} else {

if(oldkey == k) {

// long press of oldKey

unsigned long duration = millis() - keyPressStart;

if(duration >= KEY_REPEAT_DELAY) {

// return a key, and schedule a new one after KEY_REPEAT_INTERVAL

keyPressStart = keyPressStart + duration - KEY_REPEAT_DELAY + KEY_REPEAT_INTERVAL;

tone(TONE_PIN, NOTE_C8, 100);

} else {

// we're waiting, so we report no key press

k = -1;

}

} else {

// new key now pressed

keyPressStart = millis();

oldkey = k;

}

return k;

}

// Reads a key input from the input pin

int decodeKey() {

unsigned int input = analogRead(0); // read the value from the sensor

int k;

for (k = 0; k < NUM_KEYS; k++) {

if (input < ADC_KEY_VOLTAGE[k]) {

//return k;

break;

}

if (k >= NUM_KEYS) {

k = -1; // No valid key pressed

}

return k;

}

void displayTime(int mins, int secs) {

lcd.setCursor(0, 1); //line=2, x=0

char minMsg[3] = {'0' + (mins / 10), '0' + (mins % 10), 0};

lcd.print(minMsg);

lcd.print(":");

char secMsg[3] = {'0' + (secs / 10), '0' + (secs % 10), 0};

lcd.print(secMsg);

}

void displayPower(int power) {

lcd.setCursor(12, 1); //line=2, x=13

if (power == 100) {

lcd.print("100%");

} else {

lcd.print(" ");

char powerMsg[3] = {'0' + (power / 10), '0' + (power % 10), 0};

lcd.print(powerMsg);

lcd.print("%");

}

void testLed() {

tone(TONE_PIN, NOTE_C5, 300);

delay(350);

for (int x=1; x <= 255; x++){

analogWrite(LED_PIN, x);

delay(10);

}

tone(TONE_PIN, NOTE_C3, 300);

delay(350);

for (int x=255; x >= 0; x--){

analogWrite(LED_PIN, x);

delay(10);

}

analogWrite(LED_PIN, 0);

}

Jak se pracuje s Arduino nebudu nijak rozvádět, protože je článků plný internet. Snad jen pro úplné začátečníky uvedu domácí stránky www.arduino.cc (zde zdarma stáhnete vývojové prostředí) a například tento popis práce v češtině, zde také popis z Robodoupě.cz a poslední z Root.cz.

V případě zájmu mám doma ještě 3 x 1m UV LED pásku a kvalitní zdroje 230V – 12V/2A v provedení “open frame”.

—————————————————————————————————————————————————
Soubory ke stažení:

: Titulek : Osvitka - schéma pro program Eagle
Název souboru : osvitka.sch (87 kB)

: Titulek : Osvitka - výkres v pdf
Název souboru : Osvitka.pdf (192 kB)

: Titulek : Osvitka - soubory DXF pro pálení
Název souboru : Osvitka_dxf.zip (379 kB)

: Titulek : Osvitka - deklarace tónů
Název souboru : pitches.h (2 kB)

: Titulek : Osvitka - zdrojový program v.1.0
Název souboru : lcd_timer_v1.00.ino (11 kB)

: Titulek : Osvitka - zdrojový program v.1.1
Název souboru : lcd_timer_1.1.ino (11 kB)

______________________________________________________________________________________

Zde můžete přispět na provoz a rozvoj stránek, protože i malá částka může pomoci. Výše příspěvku: ( CZK ) ( 20CZK ~ 1$ )

______________________________________________________________________________________

DCC modely, Elektro MM

Digitální modelová železnice a elektro bastlení