Měření teploty pomocí čidla UMW DS18B20

$ mkdir teplota4
$ cd teplota4
$ mkdir modules
$ cd modules
$ git clone https://github.com/adamboardman/pico-onewire
$ cd ..

#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "modules/pico-onewire/api/one_wire.h"


int main() {
    stdio_init_all();
    One_wire one_wire(15); //GP15 - Pin 20 on Pi Pico
    one_wire.init();
    rom_address_t address{};
    while (true) {
        one_wire.single_device_read_rom(address);
        printf("Device Address: %02x%02x%02x%02x%02x%02x%02x%02x\n", address.rom[0], address.rom[1], address.rom[2], address.rom[3], address.rom[4], address.rom[5], address.rom[6], address.rom[7]);
        one_wire.convert_temperature(address, true, false);
        printf("Temperature: %3.1foC\n", one_wire.temperature(address));
        sleep_ms(1000);
    }
    return 0;
}

cmake_minimum_required(VERSION 3.13)

# initialize the SDK based on PICO_SDK_PATH
# note: this must happen before project()
include(pico_sdk_import.cmake)

project(teplota4)

# set(CMAKE_C_STANDARD 11)

# initialize the Raspberry Pi Pico SDK
pico_sdk_init()

# rest of your project

add_executable(teplota4
	ds18b20_test.cpp
)

add_subdirectory(modules/pico-onewire)

target_link_libraries(teplota4 pico_stdlib pico_one_wire)

pico_enable_stdio_usb(teplota4 1)
pico_enable_stdio_uart(teplota4 0)

# create map/bin/hex/uf2 file in addition to ELF.
pico_add_extra_outputs(teplota4)

$ cd teplota4
$ mkdir build
$ cd build
$ cmake ..
$ make -j4

Device Address: 28e89944d4ee250e
Temperature: 22.9oC
Device Address: 28e89944d4ee250e
Temperature: 22.9oC
Device Address: 28e89944d4ee250e
Temperature: 22.9oC
Device Address: 28e89944d4ee250e
Temperature: 22.9oC
Device Address: 28e89944d4ee250e
Temperature: 22.9oC
Device Address: 28e89944d4ee250e
Temperature: 22.9oC
Device Address: 28e89944d4ee250e
Temperature: 22.9oC

/**
 * OneWire with DS1820 Dallas 1-Wire Temperature Probe
 *
 * Example:
 * @code
 * #include "one_wire.h"
 *
 * One_wire one_wire(15); //GP15 - Pin 20 on Pi Pico
 *
 * int main() {
 *     one_wire.init();
 *     rom_address_t address{};
 *     while (true) {
 *         one_wire.single_device_read_rom(address);
 *         one_wire.convert_temperature(address, true, true);
 *         printf("It is %3.1foC\n", one_wire.temperature(address));
 *         sleep_ms(1000);
 *     }
 * }
 * @endcode
 */
class One_wire {
public:
	enum {
		invalid_conversion = -1000,
		not_controllable = 0xFFFFFFFF
	};

	/** Create a one wire bus object connected to the specified pins
	 *
	 * The bus might either by regular powered or parasite powered. If it is parasite
	 * powered and power_pin is set, that pin will be used to switch an external mosfet
	 * connecting data to Vdd. If it is parasite powered and the pin is not set, the
	 * regular data pin is used to supply extra power when required. This will be
	 * sufficient as long as the number of devices is limited.
	 *
	 * @param data_pin pin for the data bus
	 * @param power_pin (optional) pin to control the power MOSFET
	 * @param power_polarity (optional) which sets active state (false for active low (default), true for active high)
	 */
	One_wire(uint data_pin, uint power_pin = not_controllable, bool power_polarity = false);
	~One_wire();

	/**
	 * Initialise and determine if any devices are using parasitic power
	 */
	void init();

	/**
	 * Finds all one wire devices and returns the count
	 *
	 * @return - number of devices found
	 */
	int find_and_count_devices_on_bus();

	/**
	 * Get address of devices previously found
	 *
	 * @param index the index into found devices
	 * @return the address of
	 */
	static rom_address_t &get_address(int index);

	/**
	 * This routine will initiate the temperature conversion within
	 * one or all temperature devices.
	 *
	 * @param wait if true or parasitic power is used, waits up to 750 ms for
	 * conversion otherwise returns immediately.
	 * @param address allows the function to apply to a specific device or
	 * to all devices on the 1-Wire bus.
	 * @returns milliseconds until conversion will complete.
	 */
	int convert_temperature(rom_address_t &address, bool wait, bool all);

	/**
	 * Changes the "endianness" of the unique device ID in supplied address
	 * so that it can be conveniently printed out and manipulated as a number.
	 *
	 * @param address the address you received from OneWire::get_address(i).
	 * @returns device ID as unsigned 64-bit integer.
	 */
	static uint64_t to_uint64(rom_address_t &address);

	/**
	 * This function will return the temperature measured by the specific device.
	 *
	 * @param convert_to_fahrenheit whether to convert the degC to Fahrenheit
	 * @returns temperature for that scale, or OneWire::invalid_conversion (-1000) if CRC error detected.
	 */
	float temperature(rom_address_t &address, bool convert_to_fahrenheit = false);

	/**
	 * This function sets the temperature resolution for supported devices
	 * in the configuration register.
	 *
	 * @param resolution number between 9 and 12 to specify resolution
	 * @returns true if successful
	 */
	bool set_resolution(rom_address_t &address, unsigned int resolution);

	/**
	 * Assuming a single device is attached, do a Read ROM
	 *
	 * @param rom_address the address will be filled into this parameter
	 */
	void single_device_read_rom(rom_address_t &rom_address);

	/**
	 * Static utility method for easy conversion from previously stored addresses
	 *
	 * @param hex_address the address as a human readable hex string
	 * @return the rom address
	 */
	static rom_address_t address_from_hex(const char *hex_address);

private:
	uint _data_pin;
	uint _parasite_pin;
	bool _parasite_power{};
	bool _power_mosfet;
	bool _power_polarity;
	uint8_t _search_ROM[8] = {0, 0, 0, 0, 0, 0, 0, 0};
	uint8_t ram[9]{};

	int _last_discrepancy;	// search state
	bool _last_device;  // search state

	static uint8_t crc_byte(uint8_t crc, uint8_t byte);

	static void bit_write(uint8_t &value, int bit, bool set);

	[[nodiscard]] bool reset_check_for_device() const;

	void match_rom(rom_address_t &address);

	void skip_rom();

	void onewire_bit_out(bool bit_data) const;

	void onewire_byte_out(uint8_t data);

	[[nodiscard]] bool onewire_bit_in() const;

	uint8_t onewire_byte_in();

	static bool rom_checksum_error(uint8_t *address);

	bool ram_checksum_error();

	bool search_rom_find_next();

	void read_scratch_pad(rom_address_t &address);

	void write_scratch_pad(rom_address_t &address, int data);

	bool power_supply_available(rom_address_t &address, bool all);
};