ELLO LC1

The release version PCB of ELLO LC1 finally arrived, and although it can't be seen on the picture, the manufacturing quality is *amazing*!  

Here are also a few pictures (with my old prototype) showing the pre-loaded content on the ..."hard drive" :) The usual "Hello World" thingy, a port of the Grain benchmark, and a simple walk-through-maze game.

Which assembling another ELLO LC1, I decided to push my luck and skip the six capacitors, normally needed for the operation of the LCD. It lives!! A second test - lives again! I am not observing any reduction in the quality of the displayed text.

Turns out, ELLO LC1 can operate with ONLY THREE COMPONENTS (plus battery, of course) - PIC18, LCD, and the reset button, which is important to turn the system on or off.

Just FYI to all who may want to assemble one of these :)

Release candidates of LC1 just arrived.

The bottom side is with a lot of exposed ground copper now, because it turns out it massively improves the performance of the touch keyboard.

Also, the battery hole is now a bit smaller, and the soldering rings for the capacitors - a bit wider.

All looks fine but need to assemble one for test anyway.

Finally managed to track down and fix a nasty memory leak which was happening when using string constants. Took a week, this thing alone!

Below is the list of currently supported keywords and what is left to do to full release:

Bitling BASIC interpreter

' comment until the end of the line

        
=== Data types

INT     (also INTEGER for compatibility)
REAL    (also FLOAT for compatibility)
STRING


=== operators
        
+   -   *   /
//  or  MOD     ' modulo
^               ' power
<<              ' shift left
>>              ' shift right
=               ' (in statements) attribution
==  or  =       ' (in expressions) compare for equal
<>              ' compare for not equal
<   <=   =>   >
AND   OR   XOR


=== variables

VAR  <type>  <name>  { [dimension [, dimension...] ] }  { , <name> ... }
' DIM is alias to VAR for backward compatibility

examples:
var int a, b[3,3]
var real x, z[10,10,10]
var string s[5]     ' array of five zero-terminated strings
' () are also supported in variable indexes instead of [] for backward compatibility

        
=== control structures

IF  <expression>  THEN
{ ELSE }
END IF  or  ENDIF

FOR  <variable>  =  <expression>  TO  <expression>  { STEP <expression> }
NEXT  { <variable> }

WHILE  <expression>
END WHILE  or  WEND

REPEAT
UNTIL  <expression>
        
CONTINUE            ' valid for FOR, WHILE, and REPEAT structures
EXIT                ' valid for FOR, WHILE, and REPEAT structures
        
LABEL  <label_name>
GOTO   <label_name>
        
END
' STOP is also supported and act the same way as END
        
        
=== subroutines
        
SUB     <name> {  (  <type>  {  @  }  <variable>  { ,  <type>  ...  }  )  }
FUNC    <name> {  (  <type>  {  @  }  <variable>  { ,  <type>  ...  }  )  }  {  AS  <type>  }
RETURN  {  variable  }
END SUB  or  ENDSUB
GOSUB   <sub_name(...)>      ' optional calling format for subs

        
examples:
sub test1
func average(real a, real b) as real
sub store1(int x, int y, int @arr)


=== commands
        
PRINT   { expression  { ,  expression ... } }
DATA    expression  { ,  expression ... }
READ    variable  { ,  variable ... }
REWIND                      ' return to the first DATA element
POP                         ' remove one return address from the stack
POKE    <addr, val
RESET                       ' restart the system
SLEEP                       ' put the system to sleep
INKEY   variable
GET     variable  { ,  variable ... }
INPUT   variable  { ,  variable ... }
CLS
HLOC    <column>
VLOC    <row>
PUTCH   <ascii>
DEFCH   <chrcode>  <byte1>  <byte2>  <byte3>  <byte4>  <byte5>  <byte6>  <byte7>  <byte8>
SELCHT  < 1, 2, or 3 >
CURSOR  < bit.0 blink, bit.1 enable >
SCROLL  < bit.0 up, bit.1 down, bit.2 left, bit.3 right >
TDREF                       ' refresh the text display (used after direct writes into TD RAM)
WAIT    <milliseconds>
 

=== functions

RND     (val)               ' parameter other than 0 first seeds the generator with the value
ABS     (val)
ROUND   (val)
TRUNC   (val)
FRACT   (val)
LOGN    (val)
LOGD    (val)
EXP     (val)
SQR     (val)               ' square root
CBR     (val)               ' cube root
SIN     (val)
ASIN    (val)
HSIN    (val)
COS     (val)
ACOS    (val)
HCOS    (val)
TAN     (val)
ATAN    (val)
HTAN    (val)
COTAN   (val)
FREE    ()                  ' return the largest free block in memory
TDRAM   ()                  ' return the text display RAM address
TDTDT   ()                  ' text display width
TDHGT   ()                  ' text display height
PEEK    (addr)              ' 0 and positive numbers: RAM address, negative numbers: ROM address-1
ASC     (str)               ' character (first in string) to ASCII
CHR$    (val)               ' ASCII to character (one-character string)
VAL     (str)               ' string to number
STR$    (val, d)            ' number to string; "d" specifies the number of digits after decimal point
LEN$    (str)
LEFT$   (str, count)
RIGHT$  (str, count)
MID$    (str, start, count)
INSTR   (substr, str, start)
TIMER   (value)             ' read system millisecond incremental counter; any value different than 0 first loads the counter


=== TODO:

CLEAR  [ ALL  or  var [ , ... ] ]   ' undefine variables
 
work with files
OPEN    <filename>  as  #<variable>
PRINT   #<variable> ,  .....
INPUT   #<variable> ,  .....
GET     #<variable> ,  .....
CLOSE   <variable>

IO port
UART
PWM
ADC
DAC
    

When I was designing this board, in fact I designed three different boards - LC1 (this one) with PIC18, LC2 with AVR-DA or -DB, and LC3 with PIC24. Since I have no experience writing for AVR, and that's why started the software with this one, and porting to the PIC32 should not be a big task either. Not completely sure about the AVR one, though.

Will release all the three at the same time soon.