The beacon_decode.py program actually rebroadcasts the decoded beacons via MQTT. The log is just so that you can see what is going on.

If you look at the command line options, one of them is --topic (-t) which is the MQTT topic that the decoded beacons are sent to. Default is MCThings/

So each beacon is received, decoded and published to MCThings/<beacond_id>/<item> where <beacon id> is the same as what was received, and <item> is what the value was decoded as (Temperature, BatteryVoltage, Humidity etc.).

You can change --topic to whatever you want on the command line. If you leave it as default and subscribe on your computer to MCThings/# you should see all your modules data being published (decoded from beacons). To publish to the cloud, add this to the command line:

beacon_decode.py -t cloud_topic_whatever/whatever/whatever/

Where cloud_topic_whatever is where you publish things to see them on your phone. You can specify other command line options for broker, port, user_id and password - this assumes that you are receiving and sending to the same broker. If they are different, the program would need to be modified to have two mqtt brokers, ports, users, passwords etc. Easy enough to do, but I was assuming you would just use the one broker.

Data then shows up on  cloud_topic_whatever/whatever/whatever/<beacond_id>/<item> as previously described.


The log is just so that you can see what is happening.

Are you running Python 3? This is a Python 2.7 program.

Python 3 uses byte arrays in place of the Python 2.7 strings. Should be fairly easy to fix, but I don't think I have Python 3 installed anywhere.

I'll see what I can do.

See my post http://mcthings.createaforum.com/support/new-120-moduledemo-205-accelerometer-library-released!/

For details.

You could, I'm not sure exactly why you would want to, unless you need some special feature of the digital interface.

You would have to implement an SPI interface, which is supported, but with no real examples published. Doable though.

An easier (and cheaper) alternative would be to connect an analog k type thermocouple amplifier. Like this one:

https://www.adafruit.com/product/1778

Then you just need an analog input pin, and the interface is easy.

What is the temperature range you are reading? Do you need high temperatures (in the 1000 degrees range)?

I'm just getting ready to release my new LIS2DH12 library (which actually works), and I'm writing some example programs.

One thing I ran into, was putting a line like this into the accelerometer ISR

JData.add("Orientation", Orientation)

Where jData is a json object, and Orientation is a string giving the Orientation "up" "down" etc. The json is published ever 10 seconds by a shared event.

The json object is a shared variable, and is cleared after it is published.

I thought that as the orientation was changed, the new orientation would overwrite the old, and when published you would have the orientation at the point it was published.

Instead, I get a run time error, saying that the publish string is too long. Looking at the culprit (jData) it has dozens of entries (I couldn't tell what the entries were, the Debugger shows (" for the content, but the Count() was 120 in one instance.

This seems to imply that duplicate pairs are allowed in a json object (and the standard does not disallow this).

Is this the case? Is this the intended operation of your implementation of the json object?

It's an easy fix (just clear before adding the new value), but I was wondering if this was intended or not, as most json implementations do not allow duplicate keys.

I also ran this through slowly, to see how duplicate keys deserialize to strings, and lo! No duplicate keys in the string. But the count says there is. Not sure exactly what is going on.

Weird, OK here is my actual code. You can't run it (which is why I made up the example) as it's reading from the accelerometer, and is part of a large class that is instantiated as a new object:

    Public Function GetINT1ActiveInterrupt() As Byte
        'bit 7 not used
        'IA Interrupt active. Default value: 0 bit 6
        '(0: no interrupt has been generated; 1: one or more interrupts have been generated)
        'ZH Z high. Default value: 0 bit 5
        '(0: no interrupt, 1: Z high event has occurred)
        'ZL Z low. Default value: 0 bit 4
        '(0: no interrupt; 1: Z low event has occurred)
        'YH Y high. Default value: 0 bit 3
        '(0: no interrupt, 1: Y high event has occurred)
        'YL Y low. Default value: 0 bit 2
        '(0: no interrupt, 1: Y low event has occurred)
        'XH X high. Default value: 0 bit 1
        '(0: no interrupt, 1: X high event has occurred)
        'XL X low. Default value: 0 bit 0
        '(0: no interrupt, 1: X low event has occurred)
        Return Read(INT1_SRC)
    End Function

    Public Function GetInt1Orientation() As String
        'special function to decode INT1_SOURCE in 6D/4D mode (only valid for that mode)
        Dim intSource As Byte = GetINT1ActiveInterrupt()
        Dim result As String
        Dim orientation As Byte = intSource & ~INT_ACTIVE
       
        '        If (intSource & INT_ACTIVE) = INT_ACTIVE Then
        '            If (intSource & INT_SRC_YL) = INT_SRC_YL Then
        '                result = "left"
        '            ElseIf (intSource & INT_SRC_XH) = INT_SRC_XH Then
        '                result = "right"
        '            ElseIf (intSource & INT_SRC_XL) = INT_SRC_XL Then
        '                result = "top"
        '            ElseIf (intSource & INT_SRC_YH) = INT_SRC_YH Then
        '                result = "bottom"
        '            ElseIf (intSource & INT_SRC_ZH) = INT_SRC_ZH Then
        '                result = "up"
        '            ElseIf (intSource & INT_SRC_ZL) = INT_SRC_ZL Then
        '                result = "down"
        '            End If
       
       
        If (intSource & INT_ACTIVE) = INT_ACTIVE Then
            Select orientation
                Case INT_SRC_YL
                    result = "left"
                Case INT_SRC_XH
                    result = "right"
                Case INT_SRC_XL
                    result = "top"
                Case INT_SRC_YH Then
                    result = "bottom"
                Case INT_SRC_ZH Then
                    result = "up"
                Case INT_SRC_ZL Then
                    result = "down"
            End Select
        End If
       
        Return result
    End Function // GetInt1Orientation

GetInt1Orientation() is the function that causes the error. The commented out code is my workaround, (which works).

Any clues?

PS I don't know if it helps, but here are the constants definitions:

    Const INT_ACTIVE As Byte = 0x40
    Const INT_SRC_ZH As Byte = 0x20
    Const INT_SRC_ZL As Byte = 0x10
    Const INT_SRC_YH As Byte = 0x08
    Const INT_SRC_YL As Byte = 0x04
    Const INT_SRC_XH As Byte = 0x02
    Const INT_SRC_XL As Byte = 0x01


Thanks John,

What about the class names for Functions/Subs?

ie Public Functions/Subs don't need the class name if they are in the same class, but Shared Functions/Subs do
Variables (Public or Shared) don't need the class names when used within the same class.

The inconsistency seems to be Shared Functions/Subs needing the class name when used within the same class This is not how VB.NET does it, and seems the biggest inconsistency.

Thanks for taking the time to look into this.

OK, in process of conversion.

There is still some weirdness going on though:

This works (although you say it shouldn't):
    Public Sub LedGreenFlash1()
        LedGreen = True
        Thread.Sleep(3000)
        LedGreen = False
    End Sub

This does not work (even though you say it should):
    Shared Sub LedGreenFlash()
        LedGreen = True
        Thread.Sleep(3000)
        LedGreen = False
    End Sub
Gives error "Cannot refer to an instance method of a class from within a shared method without an explicit instance of the class". LedGreen is the issue, and given that this is a PinName, the error makes no sense.

This however does work:
    Shared Function LedGreenFlash() As Nothing
        LedGreen = True
        Thread.Sleep(3000)
        LedGreen = False
    End Function
No idea what the difference is, I assume a bug?

This applies to all pins like ReedSwitch, LedRed etc. You can use them within a Shared Event, Shared Function, Public Sub etc. but not from a Shared Sub.

Also a bit of a pain, I can't get the value of a shared function directly. eg, if I want the value of GetTimeStamp() I used to have a function:

Public Function GetTimestamp()
    return Timing.GetTimestamp()
End Function

and I would just use GetTimestamp() in the Main class. eg:

jData.Add("time", GetTimestamp())

because:
jData.Add("time", Timing.GetTimestamp())
doesn't work (error "unshared sub/function"). When clearly it is a shared function - if you hover the mouse over "Timing" it even lists the function as shared.

So now I have to do this:
Dim timestamp As String = Timing.GetTimestamp()
jData.Add("time", timestamp)
for every variable that I want that is shared in another class. Which is messy, and a pain. Why can't I get the values directly?

I would also like to point out that in the documentation, you exclusively use public sub/functions. No shared sub/functions at all, so one might be led to believe that this was acceptable.

For example, page 57 of the mcScript user guide gives this example:

01 Define PinMode Pin8 As AnalogInput

13 Public Function GetVoltage() As Short
14     Dim value As Short
15     value = Pin8 // Read the pin. This activates the ADC
16     Return value // Return value in millivolt
17 End Function

But does not mention that you shouldn't do this in the main program. In fact I think that it implies that you can.

And of course it does in fact work as is.

Another thing that doesn't add up, if I use a Public Function, I don't have to specify the Class name to use it within the same class (the compiler assumes I mean the same class - which is reasonable). If however I make it a shared Function, I do have to use the class name - even within the same class. This makes no sense, and is not consistent either internally, or with normal VB.NET behavior (which does not require the class name for public or shared functions within the same class, only external to the class). Shared or Public variables also do not need the class name within the same class.

Another thing I ran into recently, If one class has a variable called "Time", I can't create a class called "Time" even though the variable is internal to the first class.

Here the Class mma8652 has this function:
    'Returns list of length 2: maxTime, timeStep (both in ms)
    Private Function GetMaxTimeAndTimeStep(stepSize As String) As ListOfFloat
        Dim frequency As Byte = Read(CTRL_REG1_REG) & CTRL_REG1_DR
        Dim mode As Byte = Read(CTRL_REG2_REG) & CTRL_REG2_MODS
        Dim ms As Float
        Dim time As Float
        Dim offset As Integer
        Dim msTable As ListOfFloat = New ListOfFloat
        Dim result As ListOfFloat = New ListOfFloat
Notice the "Dim time" line

Now if I try to create a class Time

I get this error:
Time = ms * 255
       
result.Add(Time.Floor)
"The left hand side of the expression is not a variable or indexer"
""Floor" is not a shared member"

Highlighting the above two lines in the Private Function GetMaxTimeAndTimeStep(), which the IDE obviously believes to be something to do with the new class Time (which it isn't).

I guess my point is that I don't want to spend a lot of time refactoring all my code to eliminate one logical inconsistency, when the replacement itself is logically inconsistent, and there are so many inconsistencies, who knows what the final fixes will be?

So maybe it's best to leave it as is, and when you release breaking changes, hopefully you will let us know what those changes are.