const byte LCD_ROWS    =  2           -- LCD with 2 lines
const byte LCD_CHARS   =  16          -- and 16 characters per line

var byte hello[LCD_CHARS] = "Hello World"

include lcd_hd44780_3wires
lcd_init()

lcd_clear_screen()
for LCD_CHARS using i loop
   lcd_write_char(hello[i])        -- write using procedure)
end loop

const byte signogrado[] =
{  
0b_00001100,
0b_00010010,
0b_00010010,
0b_00001100,
0b_00000000,
0b_00000000,
0b_00000000,
0b_00000000
}

lcd_define(0, signogrado)

lcd = "-"
lcd = "1"
lcd = 0   --envía el signo grado

-- ----------------------------------------------------------------------------
-- Title: String manipulation
-- Author: Mohammad Hafiz Othman, Copyright (c) 2010, All rights reserved.
--
-- Released under the ZLIB license (http://www.opensource.org/licenses/zlib-license.html)
--
-- Description: - String manipulation
-- cstr[] -> constant string.
-- str [] -> string pointer.
-- char   -> ASCII character

const        byte STRING_MAX           = 255

-- this holds temp string for string manipulation
var volatile byte _tmpStr[STRING_MAX + 1]

-- ----------------------------------------------------------------------------
-- Returns the string length.
-- ----------------------------------------------------------------------------

function StrLen (byte in str[]) return byte is
   var byte i
   for STRING_MAX using i loop
       if str[i] = 0 then
          return i
       end if
   end loop
   return STRING_MAX
end function

-- ----------------------------------------------------------------------------
-- Returns the string length. (const)
-- ----------------------------------------------------------------------------

function StrLenC (byte in cstr[]) return byte is
   return count(cstr)
end function

-- ----------------------------------------------------------------------------
-- Find char in string
-- ----------------------------------------------------------------------------

function FindStr (byte in str[], byte in char) return bit is
   var word len = StrLen (str)
   var byte i
   for len using i loop
      if str[i] = Char then
         return true
      end if
   end loop
   return false
end function

-- ----------------------------------------------------------------------------
-- Find char in string (const)
-- ----------------------------------------------------------------------------

function FindStrC (byte in cstr[], byte in char) return bit is
   var word len = count(cstr)
   var byte i
   for (len + 1) using i loop
      if cstr[i] = char then
         return true
      end if
   end loop
   return false
end function

-- ----------------------------------------------------------------------------
-- Find char in string (reverse mode)
-- ----------------------------------------------------------------------------

function FindStrRev (byte in str[], byte in char) return bit is
   var byte i
   i = StrLen (str[])
   if i != 0 then
      -- find char, reverse mode.
      repeat
         if str[i] == char then
            return true
         end if
         i = i - 1
      until i == 0
   end if
   return false
end function

-- ----------------------------------------------------------------------------
-- Find char in string (reverse mode), const
-- ----------------------------------------------------------------------------

function FindStrRevC (byte in cstr[], byte in char) return bit is
   var byte i
   i = count (cstr[])
   if i != 0 then
      i = i + 1
      -- find char, reverse mode.
      repeat
         if cstr[i] == char then
            return true
         end if
         i = i - 1
      until i == 0
   end if
   return false
end function

-- ----------------------------------------------------------------------------
-- Returns a specified number of characters from the left side of a string
-- ----------------------------------------------------------------------------

procedure Left (volatile byte in out str[], byte in length) is
   if length > 0 then
      var byte len
      var byte i
      len = StrLen (str[])
      if length < len then
         str[length] = 0
      end if
   end if
end procedure

-- ----------------------------------------------------------------------------
-- Returns a specified number of characters from the right side of a string
-- ----------------------------------------------------------------------------

procedure Right (volatile byte in out str[], byte in length) is
   if length > 0 then
      var byte len
      var byte i
      len = StrLen (str[])
      if length < len then
         -- recopy to string.
         for (len - length) using i loop
            str[i] = str[i + length]
         end loop
         str[length] = 0
      end if
   end if
end procedure

-- ----------------------------------------------------------------------------
-- Returns a repeating character string of the length specified
-- ----------------------------------------------------------------------------

procedure String (volatile byte out str[], byte in char, byte in length) is
   var byte i
   for length using i loop
      str[i] = char
   end loop
   str[length] = 0
end procedure

-- ----------------------------------------------------------------------------
-- Reverse a string
-- ----------------------------------------------------------------------------

procedure StrReverse (volatile byte in out str[]) is
   var byte len
   var byte i
   len = StrLen (str[])
   -- copy string to temp string.
   for len using i loop
      _tmpStr[i] = str[len - i]
   end loop
   -- recopy to string.
   for len using i loop
      str[i] = _tmpStr[i]
   end loop
end procedure

-- ----------------------------------------------------------------------------
--  Returns a copy of a string without leading spaces
-- ----------------------------------------------------------------------------

procedure LTrimStr (volatile byte in out str[]) is
   var byte len
   var byte i
   var byte tmp
   len = StrLen (str[])
   tmp = len
   -- find space.
   for len using i loop
      if str[i] != " " then
         tmp = i
         exit loop
      end if
   end loop
   if tmp != len then
      -- recopy to string.
      for (len - tmp) using i loop
         str[i] = str[i + tmp]
      end loop
      str[len - tmp] = 0
   else
      str[0] = 0
   end if
end procedure

-- ----------------------------------------------------------------------------
--  Returns a copy of a string without trailing spaces
-- ----------------------------------------------------------------------------

procedure RTrimStr (volatile byte in out str[]) is
   var byte i
   i = StrLen (str[])
   if i != 0 then
      -- find space, reverse mode.
      repeat
         if str[i] != " " then
            exit loop
         end if
         i = i - 1
      until i == 0
      str[i] = 0
   end if
end procedure

-- ----------------------------------------------------------------------------
--  Compare a string
-- ----------------------------------------------------------------------------

function StrCmp (volatile byte in str1[], volatile byte in str2[]) return bit is
   var byte lena
   var byte lenb
   var byte i
   lena = StrLen (str1[])
   lenb = StrLen (str2[])
   if lena == lenb then
      -- process
      for lena using i loop
         if str1[i] != str2[i] then
            return false
         end if
      end loop
      return true
   end if
   return false
end procedure