fastspin Basic CM2302

Comments

• ersmith Posts: 4,588

  2019-04-20 (5:01 PM)

  This line:

  output(2) = indata%  'Capture incoming
  

  does not do what the comment says (capture incoming); instead it outputs a random value (whatever happened to be in the variable "indata%") to pin 2. Did you mean to say:

  indata% = input(2) ' Capture state of pin 2
  

  
  In general, if the Spin code you have works correctly then you can just use that directly in the BASIC code by doing something like:

  ' create a BASIC Object (class) from the Spin object
  dim dht as class using "DHTnn_Object.spin"
  ' declare some variables to receive output
  dim temperature as single
  dim humidity as single
  dim status as integer
  ...
  ' start the reading process in the background
  dht.StartDHTnn(devicePin, deviceModel, @temperature, @humidity, @status)
  
  ' loop printing temperature and humidity
  do
    pausems 1000
    if status = 1
      print "temperature=", temerature, "humidity=", humidity
    else
      print "error? status=", status
    end if
  loop
  

  (I haven't checked that code and don't have a device to actually test with, so it probably needs some tweaking, but that's the general idea.)
  
• Rsadeika Posts: 3,488

  2019-04-20 (6:59 PM)

  Actually what I was trying to do is, or make an attempt to write the dht22 code in fastspin Basic. So, basically I would have a driver for the CM2302 module that was in Basic instead of using the dht22 spin object.
  
  I was curious to see whether the actual Basic code would make the actual program size smaller than what I am getting when using the spin object code. The same experiment could be used to see what the code sizes look like with the dht22 C code, whenever that becomes available.
  
  Since fastspin Basic is using LMM mode, it seems that all the program code has to be as small and compact as possible. I think that it would be easier to tweak Basic code then to tweak the spin objects, before using them in the fastspin Basic. Just my thoughts on this.
  
  Ray
• ersmith Posts: 4,588

  2019-04-20 (10:42 PM)

  Rsadeika wrote: »

  Actually what I was trying to do is, or make an attempt to write the dht22 code in fastspin Basic. So, basically I would have a driver for the CM2302 module that was in Basic instead of using the dht22 spin object.
  
  I was curious to see whether the actual Basic code would make the actual program size smaller than what I am getting when using the spin object code.

  Well, in general I would expect the code produced by fastspin to be similar size regardless of the language. Internally fastspin translates all 3 languages into the same internal form before compiling to PASM. So if you write the code in the same way in Spin, BASIC, or C it should be compiled into the same result.
  
  The "in the same way" is an interesting caveat though, because it may be that different languages make slightly different forms of code more "natural". In Spin, for example, it's pretty easy to interface to a PASM driver that runs in another COG, but that's harder in BASIC or C. In BASIC it's easier to use small inline functions than in the other languages. And C code tends not to use objects in the same way as Spin or BASIC.
  
  
• Rsadeika Posts: 3,488

  2019-04-20 (11:15 PM)

  Interesting, so the only way to see program code, in a reduced size, would be by changing over to CMM, I think. Also, I was thinking, using the dhtnn spin object, as an example, if that were written in complete pasm, would that show a reduction in program size when used with Basic?
  
  I think there needs to be an explanation for why/when you would use the optimization option. I noticed that the dhtnn program, when you use 'no optimization', it runs as expected and the values are correct. But when you use 'Default Optimization', the program runs, but the values that you are printing are wrong, although there is quite a substantial reduction in program code size. I guess it would be some what difficult to find out where the problem lies when you do use the optimization option. Maybe a short summary on how the optimization thing works.
  
  Ray
• Rsadeika Posts: 3,488

  2019-04-21 (3:19 PM)

  Using the latest version of fastspin Basic, I cleaned up the CM2302 code, and it seems to be working as expected. I am not including the Spin objects, for that, if you are interested, OBEX is the place to find them.
  
  Still need to get a handle on how that Optimization works. With that info I guess you can start writing programs with that protocol in mind, I think. Also, what is the best way to have this program copied to EEPROM, so it starts up on power up?
  
  The next step, I think, will have to be a pair up with a Raspberry Pi, that way I can access a program on the RasPi to get the temperature/humidity readings remotely.
  
  Ray
  
  

  rem test_temp3.bas
  '
  '  April 21, 2019
  rem This uses the CM2302 module for temperature and humidity.
  /'
  For this to work, you need access to the following:
  DHTnn_Object.spin
  FloatMath.spin
  FloatString.spin
  Also, in Options, the selection has to be "No Optimization".
  Program size is 12704 bytes, ~one third of available memory is used.
  '/
  
  ' Setup a Spin object for use with Basic
  dim dht as class using "DHTnn_Object.spin"
  
  let dhtpin = 2  ' Pin number.
  let model = 22  ' Model is dht22.
  
  ' Variable types.
  dim temp as single
  dim humid as single
  dim status as integer
  
  /' Start the dht object code.
   Module is set for pin 2, and model 22.'/
  dht.StartDHTnn(dhtpin,model,@temp,@humid,@status)
  ' Hold for terminal screen access.
  waitcnt(getcnt() + 10_000_000)
  
  do
    dht.DHTnn_Read()  ' Read the dht module.
    if status = 1 then
      print "Temperature - ";(9.0/5.0)*temp + 32.0;" *F" ;"  Humidity - ";humid;" %"
    else
      print "error status= "; status
    end if
    pausems 3000  ' Need at least two seconds for module stabalization.
  loop
  
• ersmith Posts: 4,588

  2019-04-21 (3:34 PM) edited 2019-04-21 (3:45 PM)

  Rsadeika wrote: »

  IAlso, I was thinking, using the dhtnn spin object, as an example, if that were written in complete pasm, would that show a reduction in program size when used with Basic?

  Possibly, depending on how clever your PASM code was.
  

  I think there needs to be an explanation for why/when you would use the optimization option. I noticed that the dhtnn program, when you use 'no optimization', it runs as expected and the values are correct. But when you use 'Default Optimization', the program runs, but the values that you are printing are wrong, although there is quite a substantial reduction in program code size.

  Well, that's a bug then. Could you describe exactly how it's going wrong? (what kinds of values are being printed, etc.) As I said, I don't have any DHT hardware to test with, but if you could narrow down the problem to which function is producing the wrong result I may be able to figure out what's wrong.
  
  There are a lot of optimizations that fastspin performs. The ones that most reduce the program size are unused method removal (getting rid of methods that are never called) and dead code removal (getting rid of parts of if statements that are always false). I think all of the optimizations in the "default optimization" level are performed within functions. At "full optimization" (-O2) it also does a few things like automatically inlining functions that are only called once.
  
• Rsadeika Posts: 3,488

  2019-04-21 (4:54 PM)

  When you run the program :
  No Optimization
  Temperature : 73.04 *F Humidity : 45.100 %
  Default Optimization
  Temperature : 107.42 *F Humidity : 1.109E+08
  Full Optimization
  error status = 0
  
  The values are so far apart, not sure what the heck is going on. But, when you compile with Full Optimization, the program code size is 7932 bytes. That is quite a reduction in program code size.
  
  Ray
  
  
• dgately Posts: 1,373

  2019-04-21 (5:00 PM)

  Rsadeika wrote: »

  Also, what is the best way to have this program copied to EEPROM, so it starts up on power up?

  PropLoader (loader for P1) gets built as part of the spin2gui project.

  $ proploader
  PropLoader v1.0-41 (2019-04-11 14:50:14 g9192230)
  
  usage: proploader [options] [<file>]
  
  options:
      -b <type>       select target board and subtype (default is 'default:default')
      -c              display numeric message codes
      -D var=value    define a board configuration variable
      -e              program eeprom (and halt, unless combined with -r)
  ... many more options available...
  

  The "-e" option allows uploading to the P1 EEPROM.
  
  dgately
  
• kwinn Posts: 8,677

  2019-04-21 (5:01 PM)

  For debugging something like this I would add output statements to print the temperature and humidity at every step of the calculations from reading the raw data to outputting the final result.
• Rsadeika Posts: 3,488

  2019-04-21 (7:15 PM)

  I was very curious how the Basic program would compare to the program I have that uses SimpleIDE. The program below comes out too: 9092bytes(9480 total).
  
  Another thing that I am noticing is the actual code itself. Of course it is a very simple program, but the fastspin Basic is just as readable as the C code, and vice-versa, in this instance. I know that C code can get very difficult to decipher at times.
  
  I also looked at DHT11_Test.spin, which is similar in function, I sort looked at that code and was scratching my head thinking, what the heck. I am not saying this to start a language war, just my observation.
  
  I am starting to like fastspin Basic, although I must confess, I have written some programs using FreeBasic, so it is starting to become very familiar.
  
  Ray
  

  /*
    cm2302_test.c
    September 13, 2018
  */
  #include "simpletools.h"
  #include "dht22.h"
  
  float temp,humid;  // Decimal point precision.
  
  int main()
  {
    // Add startup code here.
    
   
    while(1)
    {
      // Add main loop code here.
      dht22_read(2);   // CM2302 is connected to pin 16.
      pause(150);
      temp = dht22_getTemp(0);  // (0) Celsius, (1) Fahrenheit, (2) Kelvin.
      temp = ((temp*.100)-.30); 
      print("%.2f Temperature\n",temp);  // Apply decimal point precission.
      humid = dht22_getHumidity();
      humid = (humid*.10);
      print("%.2f Humidity\n",humid);  // Apply decimal point precission.
      pause(2000);  // Pause for two seconds.
    }  
  }
  
• Rsadeika Posts: 3,488

  2019-04-22 (12:59 PM)

  To get a better feel for how to use Spin objects with fastspin Basic, I tried to use the FFloat() that is available with FloatMath.spin. The results that I am seeing are not what I expected.
  
  I thought I would see something like 1.111 2.111 … But what I am seeing is 3F800000 40400000 … So, I must be using math.FFloat() incorrectly, right? I also wanted to see how the optimization would work on a program that had a Spin object attached.
  
  Ray
  

  rem test4.bas
  
  dim math as class using "FloatMath.spin"
  
  
  dim i as integer
  
  waitcnt(getcnt() + 10_000_000)
  
  for i =  1.111 to 10
    print math.FFloat(i)
    pausems 1000
  next i
  

  FloatMath.spin

  ''***************************************
  ''*  Floating-Point Math                *
  ''*  Single-precision IEEE-754          *
  ''*  Author: Chip Gracey                *
  ''*  Copyright (c) 2006 Parallax, Inc.  *
  ''*  See end of file for terms of use.  *
  ''***************************************
  
  
  PUB FFloat(integer) : single | s, x, m
  
  ''Convert integer to float    
  
    if m := ||integer             'absolutize mantissa, if 0, result 0
      s := integer >> 31          'get sign
      x := >|m - 1                'get exponent
      m <<= 31 - x                'msb-justify mantissa
      m >>= 2                     'bit29-justify mantissa
  
      return Pack(@s)             'pack result
     
  
  PUB FRound(single) : integer
  
  ''Convert float to rounded integer
  
    return FInteger(single, 1)    'use 1/2 to round
  
  
  PUB FTrunc(single) : integer
  
  ''Convert float to truncated integer
  
    return FInteger(single, 0)    'use 0 to round
  
  
  PUB FNeg(singleA) : single
  
  ''Negate singleA
  
    return singleA ^ $8000_0000   'toggle sign bit
    
  
  PUB FAbs(singleA) : single
  
  ''Absolute singleA
  
    return singleA & $7FFF_FFFF   'clear sign bit
    
  
  PUB FSqr(singleA) : single | s, x, m, root
  
  ''Compute square root of singleA
  
    if singleA > 0                'if a =< 0, result 0
  
      Unpack(@s, singleA)         'unpack input
  
      m >>= !x & 1                'if exponent even, shift mantissa down
      x ~>= 1                     'get root exponent
  
      root := $4000_0000          'compute square root of mantissa
      repeat 31
        result |= root
        if result ** result > m
          result ^= root
        root >>= 1
      m := result >> 1
    
      return Pack(@s)             'pack result
  
  
  PUB FAdd(singleA, singleB) : single | sa, xa, ma, sb, xb, mb
  
  ''Add singleA and singleB
  
    Unpack(@sa, singleA)          'unpack inputs
    Unpack(@sb, singleB)
  
    if sa                         'handle mantissa negation
      -ma
    if sb
      -mb
  
    result := ||(xa - xb) <# 31   'get exponent difference
    if xa > xb                    'shift lower-exponent mantissa down
      mb ~>= result
    else
      ma ~>= result
      xa := xb
  
    ma += mb                      'add mantissas
    sa := ma < 0                  'get sign
    ||ma                          'absolutize result
  
    return Pack(@sa)              'pack result
  
  
  PUB FSub(singleA, singleB) : single
  
  ''Subtract singleB from singleA
  
    return FAdd(singleA, FNeg(singleB))
  
               
  PUB FMul(singleA, singleB) : single | sa, xa, ma, sb, xb, mb
  
  ''Multiply singleA by singleB
  
    Unpack(@sa, singleA)          'unpack inputs
    Unpack(@sb, singleB)
  
    sa ^= sb                      'xor signs
    xa += xb                      'add exponents
    ma := (ma ** mb) << 3         'multiply mantissas and justify
  
    return Pack(@sa)              'pack result
  
  
  PUB FDiv(singleA, singleB) : single | sa, xa, ma, sb, xb, mb
  
  ''Divide singleA by singleB
  
    Unpack(@sa, singleA)          'unpack inputs
    Unpack(@sb, singleB)
  
    sa ^= sb                      'xor signs
    xa -= xb                      'subtract exponents
  
    repeat 30                     'divide mantissas
      result <<= 1
      if ma => mb
        ma -= mb
        result++        
      ma <<= 1
    ma := result
  
    return Pack(@sa)              'pack result
  
  
  PRI FInteger(a, r) : integer | s, x, m
  
  'Convert float to rounded/truncated integer
  
    Unpack(@s, a)                 'unpack input
  
    if x => -1 and x =< 30        'if exponent not -1..30, result 0
      m <<= 2                     'msb-justify mantissa
      m >>= 30 - x                'shift down to 1/2-lsb
      m += r                      'round (1) or truncate (0)
      m >>= 1                     'shift down to lsb
      if s                        'handle negation
        -m
      return m                    'return integer
  
        
  PRI Unpack(pointer, single) | s, x, m
  
  'Unpack floating-point into (sign, exponent, mantissa) at pointer
  
    s := single >> 31             'unpack sign
    x := single << 1 >> 24        'unpack exponent
    m := single & $007F_FFFF      'unpack mantissa
  
    if x                          'if exponent > 0,
      m := m << 6 | $2000_0000    '..bit29-justify mantissa with leading 1
    else
      result := >|m - 23          'else, determine first 1 in mantissa
      x := result                 '..adjust exponent
      m <<= 7 - result            '..bit29-justify mantissa
  
    x -= 127                      'unbias exponent
  
    longmove(pointer, @s, 3)      'write (s,x,m) structure from locals
    
    
  PRI Pack(pointer) : single | s, x, m
  
  'Pack floating-point from (sign, exponent, mantissa) at pointer
  
    longmove(@s, pointer, 3)      'get (s,x,m) structure into locals
  
    if m                          'if mantissa 0, result 0
    
      result := 33 - >|m          'determine magnitude of mantissa
      m <<= result                'msb-justify mantissa without leading 1
      x += 3 - result             'adjust exponent
  
      m += $00000100              'round up mantissa by 1/2 lsb
      if not m & $FFFFFF00        'if rounding overflow,
        x++                       '..increment exponent
      
      x := x + 127 #> -23 <# 255  'bias and limit exponent
  
      if x < 1                    'if exponent < 1,
        m := $8000_0000 +  m >> 1 '..replace leading 1
        m >>= -x                  '..shift mantissa down by exponent
        x~                        '..exponent is now 0
  
      return s << 31 | x << 23 | m >> 9 'pack result
  
  {{
  
  ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
  │                                                   TERMS OF USE: MIT License                                                  │                                                            
  ├──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
  │Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation    │ 
  │files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,    │
  │modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software│
  │is furnished to do so, subject to the following conditions:                                                                   │
  │                                                                                                                              │
  │The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.│
  │                                                                                                                              │
  │THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE          │
  │WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR         │
  │COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   │
  │ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                         │
  └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
  }}    
  
• dgately Posts: 1,373

  2019-04-23 (1:02 AM) edited 2019-04-23 (1:38 AM)

  First off... i is an integer... It most likely will not hold a value of '1.111', right?
  Secondly... a For loop would need some form of stepping of non-integers, if it allowed floating point as an index:

  For someFloatValue = 1.111 To 20 Step .5  '' if that works at all
  

  Third... I'm not sure that you can print a floating value directly in this BASIC. You probably need a formatted print statement. I'm a bit fuzzy on this BASIC, but if it's like Spin, it will need a formatted print statement.
  
  EDIT: Looks like FloatMath.spin uses an integer as basically a pointer to a 32 bit value that it manipulates as if a float. It packs a float into those 32 bits, that would need to be unpacked for use. i.e. you can't just print the integer, as-is.
  

  ''Convert integer to float
  
    if m := ||integer             'absolutize mantissa, if 0, result 0
      s := integer >> 31          'get sign
      x := >|m - 1                'get exponent
      m <<= 31 - x                'msb-justify mantissa
      m >>= 2                     'bit29-justify mantissa
  

  
  dgately
• ersmith Posts: 4,588

  2019-04-23 (2:08 AM)

  Spin doesn't have any notion of types, so basically every Spin function's return value has the BASIC type "any", which is just a plain 32 bit value with no real interpretation. This won't mix well with BASIC floating point values ("single"). In BASIC you can just use floating point the same way you do in C.
  
  For loops and print will work with floats, so you can do something like:

  dim x as single  ' declare x as a float
  for x = 1.11 to 10
    print x
  next x
  

  
  So there's no need for FloatMath.spin in a BASIC program, and it would actually be confusing to try to mix BASIC floating point and a Spin object.
  
• Rsadeika Posts: 3,488

  2019-04-23 (10:38 AM)

  OK, since there is no need to use FloatMath.spin object, is it somehow corrupting some values in the DHTnn_Object.spin object since it uses both FloatMath.spin and FloatString.spin objects? I have not tried the FloatString.spin object on its own, so I am not sure if it will have a problem working with fastspin Basic.
  
  Ray
• ersmith Posts: 4,588

  2019-04-23 (12:29 PM)

  Rsadeika wrote: »

  OK, since there is no need to use FloatMath.spin object, is it somehow corrupting some values in the DHTnn_Object.spin object since it uses both FloatMath.spin and FloatString.spin objects? I have not tried the FloatString.spin object on its own, so I am not sure if it will have a problem working with fastspin Basic.

  
  I don't think it's a conflict -- you said things work if optimization is disabled, so you've probably encountered a bug in fastspin's optimizer. The Float*.spin files should work, it's just that calling them from BASIC requires some care since Spin does not have floating point as a built in type but BASIC does. (Plus there's not really any need to call them from BASIC, since BASIC has the same functions built in.)
  
  I'd like to figure out what's going wrong, but I don't have DHTnn hardware to test with. Looking at the code I'd guess that if something's going wrong it may be with the data[] array in the DHTnn_Read function in DHTnn_Object.spin. You could try changing that from a local variable to a method variable (in the VAR block) to see if that helps.