SDI-12 Soil Moisture Probe Help

[robert-hh]

@jimpower Thanks. The code looks principly OK. What happens if you increase the receive timeout?

The documentation of the product is weird. Why cannot they include a proper protocol definition? Did you see b.t.w. CR/LF transmitted at the end of response messages?

[jimpower]

@robert-hh

yes it says technical document "coming soon"

here is a snippet of my uart.readline()

Do you think this timeout_chars is correct? I wasn't sure what to put in here.

uart.init(1200, bits=7, parity=UART.EVEN, stop=1, timeout_chars=75)```

[robert-hh]

@jimpower SInce the length of the response is not known, you need astrategy to tell when the respons eis complete:

• either the response has a known terminal symbol, like ! in the command, or \r\n, then you can read until you see that symbol, and wait as second condition for a long timeout. Waitung for \r\n is done by uart.readline().
• or you have to wait for a timeout.
  The 75 char timeout seems reasonable, but to sort out implementation errors in Micropython, you could increase that for testing and see, if you receive a longer message. Thre reason I ask is, taht I faintly remember some discussion around the rx timeout of uart.read.

[jimpower]

@robert-hh I'm not sure what happened but I changed my code back to the way it was before playing around with break times, uart timeout etc and it works.
A note for anyone wanting to interface with SDI-12 with a LoPy you need to perform a gc.collect() after every read and then wait for 30secs before you can read from any other sensors.
@robert-hh thanks for your help with this it was pivotal to getting a working SDI-12 interface.
@AntonioValente thanks for your initial concept which lead to this solution.

[Bryan Hom]

@jimpower I know this is an old thread but where are you getting the 1.8V ref from?

[robert-hh]

@Bryan-Hom Yuo can use a small voltage regulator and derive it from 3.3V. If

[Bryan Hom]

@robert-hh Thank you. 1 other question, am i looking at the diagram correctly that the 1.8V + should also be tied in with the 3.3v line? Wouldn't that mean the voltage going into A is 3.3V?

[robert-hh]

@Bryan-Hom That's looks wrong. You can consider the 1.8V source as a function block with 3.3V/GND as input and 1.8v/GND as output.

I tried also some other circuits for a SDI-12 connection, but never connected them to real sensors. https://forum.pycom.io/topic/4827/teros-12-and-sdi-12?_=1640181173389

[Bryan Hom]

@robert-hh Thanks, so it should actually look more like this?

[robert-hh]

@Bryan-Hom Yes.

[Bryan Hom]

This post is deleted!

[Bryan Hom]

@robert-hh

Hi Robert, you seem to be the right person to be asking these questions to, but im using @jimpower's code and i followed the drawing exactly, but i cannot seem to get any reply from the sensor. Probing around my setup it looks like i have all the grounds properly connected, 5v going into to A. I made sure to put the 10k resistor between the 3.3v and the pin 4 (rx) of the pycom. Any thoughts or suggestions? I'm trying to read SDI-12 from a Campbell Scientific AVW200 https://s.campbellsci.com/documents/es/manuals/avw200 - 772.pdf Thank you

import network
import time
import pycom
import machine
import gc
import socket
import utime
from machine import RTC
from machine import ADC
from machine import Pin
from machine import UART


pycom.heartbeat(False)
rtc = RTC()
adc = ADC()
#lora = LoRa()
uart = UART(1, baudrate=1200)
p_tx = Pin('P3', mode=Pin.OUT)
p_dir = Pin('P11', mode=Pin.OUT)



def SDI12(cmd):
    uart.deinit()
    p_tx.value(0)
    p_dir.value(1)                                                          # set output dir
    utime.sleep_us(12500)                                                   # send BREAK
    p_tx.value(1)
    utime.sleep_us(8333)                                                    # send MARK
    uart.init(1200, bits=7, parity=UART.EVEN, stop=1, timeout_chars=75)     # init with given parameters
    uart.write(cmd)                                                         # send command
    utime.sleep_us(8333 * len(cmd))                                               # wait to send command (byte time * command lenght)
    p_dir.value(0)                                                          # output set to read
    line = uart.readline()                                                  # read data from UART
    return line;

time.sleep(2)

while True:

##########################################################
#                   Measure Temperature                  #
##########################################################
    utime.sleep(2)
    command = SDI12('V!')
    utime.sleep(10)
    print(command)                  #Print Sensor Response
    utime.sleep(2)
    command2 = SDI12('0V!')
    utime.sleep(10)
    print(command2)

##########################################################
#                     Garbage Collect                    #
##########################################################
    gc.enable()
    gc.collect()
    print("Sensor Memory Free : " + str(gc.mem_free()))
    time.sleep(15)```

[robert-hh]

@Bryan-Hom Sorry, I misread you diagram. Pin A has to be at a level between 0 and 3.3 V, like 1.8 V in the first diagram. You asked from where to get it, I recommended an 1.8V regulator which in turn gets it power from 5V or 3.3V. For a fist test, you should also be able to use a 1.5V battery.

[Bryan Hom]

@robert-hh Thank you! i rigged up the battery and got the response. I also just tried used a DAC output on Pin22 set at 55% which is roughly 1.77V and it seems to work as well without any special power supply

dac = machine.DAC('P22') # create a DAC object
dac.write(0.55) # set output to 55% ~1.77V

[Gusti Made Arya Wijaya]

@Bryan-Hom @robert-hh Hello, I've tried the program and do the wiring diagram like this
but it still can't seem to get any reply from the sensor. ,

here is my program

import utime
from machine import Pin, UART, DAC
# from machine import UART

uart = UART(1, baudrate=1200)
p_tx = Pin('P10', mode=Pin.OUT)
p_dir = Pin('P11', mode=Pin.OUT)
pin12 = Pin('P3', mode=Pin.OUT)
dac = DAC('P21') # create a DAC object


def SDI12(cmd):
    uart.deinit()
    p_tx.value(0)
    p_dir.value(1)        # set output dir
    utime.sleep_us(12800)  # send BREAK
    p_tx.value(1)
    utime.sleep_us(8333)   # send MARK
    uart.init(1200, bits=7, parity=UART.EVEN, stop=1, timeout_chars=75)     # init with given parameters
    uart.write(cmd)       # send command
    utime.sleep_us(8333 * len(cmd))  # wait to send command (byte time * command lenght)
    p_dir.value(0)    # output set to read
    line = uart.readline()      # read data from UART
    return line;

while True:
    print("reading")
    pin12.value(1)
    dac.write(0.55) # set output to 55% ~1.77V
    utime.sleep(2)
    line = SDI12("?!")
    utime.sleep(3)
    print(line)
    # pin12.value(0)
    utime.sleep(10)

I need your help to fix it, Thank you

[robert-hh]

@Gusti-Made-Arya-Wijaya Compqring with the port of the previous poster, you use different pins for p_tx. In the previous post, p_tx is the same a UART 1 TX, and that is by intention.

[Gusti Made Arya Wijaya]

@robert-hh @Bryan-Hom Hello, I've updated the program like this

import utime
from machine import Pin, UART, DAC
# from machine import UART

# uart = UART(1, baudrate=1200, pins=('P10','P11'))
uart = UART(1, baudrate=1200)
p_tx = Pin('P3', mode=Pin.OUT)
# p_tx = Pin('P10', mode=Pin.OUT)
p_dir = Pin('P11', mode=Pin.OUT)
# pin12 = Pin('P3', mode=Pin.OUT)
dac = DAC('P21') # create a DAC object


def SDI12(cmd):
    uart.deinit()
    p_tx.value(0)
    p_dir.value(1)                                                          # set output dir
    # utime.sleep_us(12800)                                                   # send BREAK
    utime.sleep_us(14000)
    p_tx.value(1)
    utime.sleep_us(8333)                                                    # send MARK
    uart.init(1200, bits=7, parity=UART.EVEN, stop=1, timeout_chars=75)     # init with given parameters
    uart.write(cmd)                                                         # send command
    utime.sleep_us(8333 * len(cmd))                                         # wait to send command (byte time * command lenght)
    # p_dir.value(0)                                                          # output set to read
    line = uart.readline()                                                  # read data from UART
    return line;

while True:
    print("reading")
    # pin12.value(1)
    dac.write(0.55) # set output to 55% ~1.77V
    utime.sleep(2)
    line = SDI12('?!')
    utime.sleep(3)
    print(line)
    # line = SDI12('0M!')
    # utime.sleep(3)
    # print(line)
    # pin12.value(0)
    utime.sleep(10)

but the response is still "none", and I use rs485 module like this (max485)

[robert-hh]

@Gusti-Made-Arya-Wijaya As far I see it, the chip has both transmit enable DE and receive enable /RE. For Transmit, the DE has to be high, for receive, the /RE has to be low. Unless you have an inverter connected between DE and /RE, you have to control both in software.

[Gusti Made Arya Wijaya]

@robert-hh I've followed the wiring by @AntonioValente's reply in https://forum.pycom.io/topic/1924/sdi-12/6 he uses SN65HVD1780 chip that has same pinout as MAX485.

[robert-hh]

@Gusti-Made-Arya-Wijaya But still you have to control both DE and /RE. You code seems to control only one of them.