src/SBUI/SBUI.cpp

   1 /*
   2 Copyright 2008  Lukas Kropatschek lukas.krop@gmail.com
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License as
   6 published by the Free Software Foundation; either version 2 of
   7 the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #include "SBUI.h"
  19
  20 //#include "StaticStrings.h"
  21
  22 #include <LCD.h>
  23 #include <IOManager.h>
  24 #include <core/defines.h>
  25 #include <SolderManager.h>
  26
  27 #define clearViewArea() LCD.drawRect(21, 0, 109, 130, FILL, WHITE);
  28 #define clearStatusMsgArea() LCD.drawRect(0,0,19,69,FILL,WHITE);
  29
  30
  31 SBUI::SBUI()
  32 {
  33         total = 0;
  34 }
  35
  36 void SBUI::update()
  37 {
  38         LCD.putVariable("X:", SolderMgr.curX, 100, 5, RED, WHITE, 30);
  39         LCD.putVariable("Y:", SolderMgr.curY, 90, 5, BLUE, WHITE, 30);
  40 }
  41
  42 void SBUI::draw()
  43 {
  44         clearViewArea();
  45
  46         drawStatusBar();
  47 }
  48
  49 void SBUI::drawCoordInput()
  50 {
  51         byte xcursor = 0;
  52         byte ycursor = 0;
  53         byte curField = 0;
  54         byte xArray[] = { 0, 0, 0};
  55         byte yArray[] = { 0, 0, 0};
  56         byte xpos = 2;
  57         byte ypos = 2;
  58
  59         LCD.putChar('X', 65, 5, RED, WHITE);
  60         LCD.putChar('Y', 50, 5, BLUE, WHITE);
  61
  62         LCD.drawRect(49, 15, 75, 75, FILL, WHITE);
  63
  64         LCD.drawRect(64, 15, 75, 75, 0, RED);
  65         LCD.drawRect(49, 15, 60, 75, 0, GREY);
  66
  67         while (true)
  68         {
  69                 // acquire PS2 keycode
  70                 byte ps2 = IOMgr.getPS2Keycode();
  71
  72                 // delete the last character and set cursor position accordingly
  73
  74                 if (ps2 == KEYCODE_BACKSPACE)
  75                 {
  76                         if (curField == 0)
  77                         {
  78                                 xArray[xpos] = 0;
  79
  80                                 if (xcursor != 0)
  81                                         xcursor -= 1;
  82
  83                                 if (xpos != 2)
  84                                         xpos++;
  85
  86                                 // clear with an space char
  87                                 LCD.putChar(' ', 65, (16 + (6 * xcursor)), BLACK, WHITE);
  88                         }
  89
  90                         if (curField == 1)
  91                         {
  92                                 yArray[ypos] = 0;
  93
  94                                 if (ycursor != 0)
  95                                         ycursor -= 1;
  96
  97                                 if (ypos != 2)
  98                                         ypos++;
  99
 100                                 LCD.putChar(' ', 50, (16 + (6 * ycursor)), BLACK, WHITE);
 101                         }
 102
 103                 }
 104
 105                 if (ps2 == KEYCODE_TAB)
 106                 {
 107                         //Toogle current coordinate input (x/y)
 108                         if (curField == 0)
 109                         {
 110                                 curField = 1;
 111                                 LCD.drawRect(64, 15, 75, 75, 0, GREY);
 112                                 LCD.drawRect(49, 15, 60, 75, 0, RED);
 113                         }
 114
 115                         else
 116                         {
 117                                 curField = 0;
 118                                 LCD.drawRect(64, 15, 75, 75, 0, RED);
 119                                 LCD.drawRect(49, 15, 60, 75, 0, GREY);
 120                         }
 121                 }
 122
 123                 if (ps2 == KEYCODE_ENTER)
 124                 {
 125                         byte x, y;
 126
 127                         switch (xcursor)
 128                         {
 129
 130                                 case 1:
 131                                         x = xArray[2];
 132                                         break;
 133
 134                                 case 2:
 135                                         x = xArray[1] + (xArray[2] * 10);
 136                                         break;
 137
 138                                 case 3:
 139                                         x = xArray[0] + (xArray[1] * 10) + (xArray[2] * 100);
 140                                         break;
 141
 142                                 default:
 143                                         x = 0;
 144                                         break;
 145                         }
 146
 147                         switch (ycursor)
 148                         {
 149
 150                                 case 1:
 151                                         y = yArray[2];
 152                                         break;
 153
 154                                 case 2:
 155                                         y = yArray[1] + (yArray[2] * 10);
 156                                         break;
 157
 158                                 case 3:
 159                                         y = yArray[0] + (yArray[1] * 10) + (yArray[2] * 10);
 160                                         break;
 161
 162                                 default:
 163                                         y = 0;
 164                                         break;
 165                         }
 166
 167                         //LCD.putVariable("x:", x, 35, 5, BLACK, WHITE, 30);
 168                         //LCD.putVariable("y:", y, 25, 5, BLACK, WHITE, 30);
 169                         SolderMgr.goTo(x, y);
 170
 171                         // get out of the endless loop
 172                         break;
 173                 }
 174
 175                 else
 176                 {
 177                         if (ps2 != 0 && ps2 != KEYCODE_TAB && ps2 != KEYCODE_BACKSPACE && ps2 != KEYCODE_ENTER)
 178                         {
 179                                 // do work for the x field
 180                                 if (curField == 0)
 181                                 {
 182                                         if (xcursor <= 2)
 183                                         {
 184                                                 // print char on screen
 185                                                 LCD.putChar(ps2, 65, (16 + (6 * xcursor)), BLACK, WHITE);
 186                                                 // add value to data array
 187                                                 xArray[xpos] = ps2 - 48;
 188                                                 xcursor++;
 189
 190                                                 if (xpos != 0)
 191                                                         xpos--;
 192                                         }
 193                                 }
 194
 195                                 if (curField == 1)
 196                                 {
 197                                         if (ycursor <= 2)
 198                                         {
 199                                                 LCD.putChar(ps2, 50, (16 + (6 * ycursor)), BLACK, WHITE);
 200                                                 yArray[ypos] = ps2 - 48;
 201                                                 ycursor++;
 202
 203                                                 if (ypos != 0)
 204                                                         ypos--;
 205                                         }
 206                                 }
 207                         }
 208                 }
 209         }
 210
 211 }
 212
 213 void SBUI::drawStatusBar()
 214 {
 215 // draw a line and the current status text
 216         LCD.drawLine(20, 0, 20, 130, BLACK);
 217         // draw free SRAM
 218         LCD.putVariable("SRAM:", availableSRAM(), 5, 70, BLACK, WHITE, 40);
 219
 220         // check whicht status message should be displayed
 221
 222         /* switch (code)
 223          {
 224
 225           case 0:
 226            // clear area
 227            clearStatusMsgArea();
 228            LCD.putString ( (const char*) getPGMStr (Idle), 5, 5, BLACK, WHITE);
 229            lastStatusMsg = 0;
 230            break;
 231
 232           case 1:
 233            // only draw status message if it is not the
 234            // same as the currently displayed
 235
 236            if (lastStatusMsg != 1)
 237            {
 238             clearStatusMsgArea();
 239             LCD.putString ( (const char*) getPGMStr (Solder), 5, 5, BLACK, WHITE);
 240            }
 241
 242            lastStatusMsg = 1;
 243
 244            break;
 245
 246           case 2:
 247
 248            if (lastStatusMsg != 2)
 249            {
 250             clearStatusMsgArea();
 251             LCD.putString ( (const char*) getPGMStr (Moving), 5, 5, BLACK, WHITE);
 252            }
 253
 254            lastStatusMsg = 2;
 255
 256            break;
 257
 258           case 3:
 259
 260            if (lastStatusMsg != 3)
 261            {
 262             clearStatusMsgArea();
 263             LCD.putString ( (const char*) getPGMStr (Loading), 5, 5, BLACK, WHITE);
 264            }
 265
 266            lastStatusMsg = 3;
 267
 268            break;
 269          }
 270          */
 271
 272 }
 273
 274 void SBUI::drawShowTrack()
 275 {
 276         // draw coord system
 277         clearViewArea();
 278
 279         for (byte i = 0; i < 16; i++)
 280         {
 281                 LCD.drawLine(35, 25 + (5 * i), 105, 25 + (5 * i), LIGHTGREY);
 282
 283                 if (i < 14)
 284                         LCD.drawLine(35 + (5 * i), 25, 35 + (5 * i), 105, LIGHTGREY);
 285         }
 286
 287         // y axis
 288         LCD.drawLine(35, 25, 105, 25, BLACK);
 289
 290         // x axis
 291         LCD.drawLine(35, 25, 35, 105, BLACK);
 292
 293         // loop through all points / 2 doing 2 points each time
 294         for (byte i = 1; i <= (total / 2); i++)
 295         {
 296                 // aquire point data
 297                 byte x1;
 298                 byte y1;
 299                 byte x2;
 300                 byte y2;
 301                 x1 = IOMgr.smap[i][1];
 302                 y1 = IOMgr.smap[i][2];
 303                 x2 = IOMgr.smap[i+1][1];
 304                 y2 = IOMgr.smap[i+1][2];
 305
 306                 //coordinate system finished draw points and lines now
 307
 308                 // draw a line from point to point
 309                 LCD.drawLine(35 + y1, 25 + x1, 35 + y2, 25 + x2, LIGHTBLUE);
 310
 311                 // draw points
 312                 LCD.drawX(35 + y1, 25 + x1, RED);
 313                 LCD.drawX(35 + y2, 25 + x2, RED);
 314         }
 315
 316         LCD.putVariable("Points:", total, 22, 5, BLACK, WHITE);
 317 }
 318
 319 void SBUI::drawLoadTrack(byte count, byte coord, byte pos)
 320 {
 321         // if we haven't started to receive
 322         if (count == 0)
 323         {
 324                 clearViewArea();
 325                 LCD.putString("Waiting for SMap..", 100, 5, BLACK, WHITE);
 326         }
 327
 328         if (count > 0 && count != 101)
 329         {
 330                 // display what we received yet and the percentage
 331                 LCD.drawRect(100, 5, 110, 100, FILL, WHITE);
 332                 LCD.putVariable("RX:", count, 100, 5, BLACK, WHITE, 30);
 333                 LCD.putVariable("/", total, 100, 42, BLACK, WHITE, 30);
 334                 LCD.putVariable("", ((count * 100) / total), 100, 70, BLACK, WHITE, 3);
 335                 LCD.putChar('%', 100, 92, BLACK, WHITE);
 336
 337                 // display x coord
 338
 339                 if (pos == 1)
 340                 {
 341                         LCD.putVariable("LP(", coord, 90, 5, BLACK, WHITE, 30);
 342                 }
 343
 344                 // display y coord
 345
 346                 if (pos == 2)
 347                 {
 348                         LCD.putVariable("/", coord, 90, 42, BLACK, WHITE, 30);
 349                         LCD.putChar(')', 90, 67, BLACK, WHITE);
 350                 }
 351
 352         }
 353
 354         // if we finished receiving the count is set to 101
 355
 356         if (count == 101)
 357         {
 358                 LCD.putString("Enter -> start", 70, 5, BLACK, WHITE);
 359                 LCD.putString("V -> show track", 60, 5, BLACK, WHITE);
 360                 while(true)
 361                 {
 362                         byte ps2 = IOMgr.getPS2Keycode();
 363
 364                         if(ps2 == KEYCODE_V)
 365                         {
 366                                 drawShowTrack();
 367                                 break;
 368                         }
 369                         else if(ps2 == KEYCODE_ENTER)
 370                         {
 371                                 drawSolder();
 372                                 break;
 373                         }
 374                 }
 375                 //TODO Add info message for start soldering
 376         }
 377 }
 378
 379 void SBUI::drawSolder()
 380 {
 381         clearViewArea();
 382         update();
 383         LCD.putString("Space -> Pause", 70, 5, BLACK, WHITE);
 384
 385         byte i = 0;
 386
 387         while(i <= total)
 388         {
 389                 byte ps2 = IOMgr.getPS2Keycode();
 390
 391                 if(ps2 == KEYCODE_SPACE)
 392                 {
 393                         while(true)
 394                         {
 395                                 byte pause = IOMgr.getPS2Keycode();
 396                                 if(pause == KEYCODE_SPACE)
 397                                         break;
 398                         }
 399                 }
 400
 401                 byte x,y;
 402
 403                 x = IOMgr.smap[i][1];
 404                 y = IOMgr.smap[i][2];
 405
 406                 SolderMgr.goTo(x,y);
 407                 SolderMgr.solder();
 408
 409                 i++;
 410         }
 411
 412 }
 413
 414
 415 SBUI sbui = SBUI();