applications/app_common_impl/common_pico.cc - pigweed/experimental - Git at Google

 // Copyright 2022 The Pigweed Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
 // use this file except in compliance with the License. You may obtain a copy of
 // the License at
 //
 //     https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 // License for the specific language governing permissions and limitations under
 // the License.
 #include <cstdint>

 #include "app_common/common.h"

 #define LIB_CMSIS_CORE 0
 #define LIB_PICO_STDIO_SEMIHOSTING 0

 #include "hardware/gpio.h"
 #include "hardware/pwm.h"
 #include "hardware/vreg.h"
 #include "pico/stdlib.h"
 #include "pw_digital_io_rp2040/digital_io.h"
 #include "pw_i2c_rp2040/initiator.h"
 #include "pw_log/log.h"
 #include "pw_pixel_pusher_rp2040_pio/pixel_pusher.h"
 #include "pw_spi_rp2040/chip_selector.h"
 #include "pw_spi_rp2040/initiator.h"
 #include "pw_status/status.h"
 #include "pw_sync/borrow.h"
 #include "pw_sync/mutex.h"

 #if defined(DISPLAY_TYPE_ILI9341)
 #include "pw_display_driver_ili9341/display_driver.h"
 using DisplayDriver = pw::display_driver::DisplayDriverILI9341;
 #elif defined(DISPLAY_TYPE_ST7735)
 #include "pw_display_driver_st7735/display_driver.h"
 using DisplayDriver = pw::display_driver::DisplayDriverST7735;
 #elif defined(DISPLAY_TYPE_ST7789)
 #include "pw_display_driver_st7789/display_driver.h"
 using DisplayDriver = pw::display_driver::DisplayDriverST7789;
 #elif defined(DISPLAY_TYPE_ST7789_PIO)
 #include "pw_display_driver_st7789/display_driver.h"
 using DisplayDriver = pw::display_driver::DisplayDriverST7789;
 #else
 #error "Undefined display type"
 #endif

 using pw::Status;
 using pw::digital_io::Rp2040DigitalIn;
 using pw::digital_io::Rp2040DigitalInOut;
 using pw::display::Display;
 using pw::framebuffer::Framebuffer;
 using pw::framebuffer::PixelFormat;
 using pw::framebuffer_pool::FramebufferPool;
 using pw::pixel_pusher::PixelPusherRp2040Pio;
 using pw::spi::Device;
 using pw::spi::Initiator;
 using pw::spi::PicoChipSelector;
 using pw::spi::PicoInitiator;
 using pw::sync::Borrowable;
 using pw::sync::VirtualMutex;

 namespace {

 // Pico spi0 Pins
 #define SPI_PORT spi0

 struct SpiValues {
   SpiValues(pw::spi::Config config,
             pw::spi::ChipSelector& selector,
             pw::sync::VirtualMutex& initiator_mutex);

   pw::spi::PicoInitiator initiator;
   pw::sync::Borrowable<pw::spi::Initiator> borrowable_initiator;
   pw::spi::Device device;
 };

 static_assert(DISPLAY_WIDTH > 0);
 static_assert(DISPLAY_HEIGHT > 0);

 constexpr uint16_t kDisplayScaleFactor = 2;
 constexpr uint16_t kFramebufferWidth =
     FRAMEBUFFER_WIDTH >= 0 ? FRAMEBUFFER_WIDTH / kDisplayScaleFactor
                            : DISPLAY_WIDTH / kDisplayScaleFactor;
 constexpr uint16_t kFramebufferHeight = DISPLAY_HEIGHT / kDisplayScaleFactor;

 constexpr pw::math::Size<uint16_t> kDisplaySize{DISPLAY_WIDTH, DISPLAY_HEIGHT};
 constexpr size_t kNumPixels = kFramebufferWidth * kFramebufferHeight;
 constexpr uint16_t kFramebufferRowBytes = sizeof(uint16_t) * kFramebufferWidth;

 constexpr uint32_t kBaudRate = 31'250'000;
 constexpr pw::spi::Config kSpiConfig8Bit{
     .polarity = pw::spi::ClockPolarity::kActiveHigh,
     .phase = pw::spi::ClockPhase::kFallingEdge,
     .bits_per_word = pw::spi::BitsPerWord(8),
     .bit_order = pw::spi::BitOrder::kMsbFirst,
 };
 constexpr pw::spi::Config kSpiConfig16Bit{
     .polarity = pw::spi::ClockPolarity::kActiveHigh,
     .phase = pw::spi::ClockPhase::kFallingEdge,
     .bits_per_word = pw::spi::BitsPerWord(16),
     .bit_order = pw::spi::BitOrder::kMsbFirst,
 };

 Rp2040DigitalInOut s_display_dc_pin(DISPLAY_DC_GPIO);
 #if DISPLAY_RESET_GPIO != -1
 Rp2040DigitalInOut s_display_reset_pin(DISPLAY_RESET_GPIO);
 #endif
 #if DISPLAY_TE_GPIO != -1
 Rp2040DigitalIn s_display_tear_effect_pin(DISPLAY_TE_GPIO);
 #endif
 Rp2040DigitalInOut s_display_cs_pin(DISPLAY_CS_GPIO);
 PicoChipSelector s_spi_chip_selector(s_display_cs_pin);
 PicoInitiator s_spi_initiator(SPI_PORT);
 VirtualMutex s_spi_initiator_mutex;
 Borrowable<Initiator> s_borrowable_spi_initiator(s_spi_initiator,
                                                  s_spi_initiator_mutex);
 SpiValues s_spi_8_bit(kSpiConfig8Bit,
                       s_spi_chip_selector,
                       s_spi_initiator_mutex);
 SpiValues s_spi_16_bit(kSpiConfig16Bit,
                        s_spi_chip_selector,
                        s_spi_initiator_mutex);

 #if USE_PIO
 PixelPusherRp2040Pio s_pixel_pusher(DISPLAY_DC_GPIO,
                                     DISPLAY_CS_GPIO,
                                     SPI_MOSI_GPIO,
                                     SPI_CLOCK_GPIO,
                                     DISPLAY_TE_GPIO,
                                     pio0);
 #endif
 uint16_t s_pixel_data1[kNumPixels];
 uint16_t s_pixel_data2[kNumPixels];
 const pw::Vector<void*, 2> s_pixel_buffers{s_pixel_data1, s_pixel_data2};
 pw::framebuffer_pool::FramebufferPool s_fb_pool({
     .fb_addr = s_pixel_buffers,
     .dimensions = {kFramebufferWidth, kFramebufferHeight},
     .row_bytes = kFramebufferRowBytes,
     .pixel_format = PixelFormat::RGB565,
 });
 DisplayDriver s_display_driver({
     .data_cmd_gpio = s_display_dc_pin.as<pw::digital_io::DigitalOut>(),
     .spi_cs_gpio = s_display_cs_pin.as<pw::digital_io::DigitalOut>(),
 #if DISPLAY_RESET_GPIO != -1
     .reset_gpio = &s_display_reset_pin.as<pw::digital_io::DigitalOut>(),
 #else
     .reset_gpio = nullptr,
 #endif
 #if DISPLAY_TE_GPIO != -1
     .tear_effect_gpio = &s_display_tear_effect_pin,
 #else
     .tear_effect_gpio = nullptr,
 #endif
     .spi_device_8_bit = s_spi_8_bit.device,
     .spi_device_16_bit = s_spi_16_bit.device,
 #if USE_PIO
     .pixel_pusher = &s_pixel_pusher,
 #endif
 });
 Display s_display(s_display_driver, kDisplaySize, s_fb_pool);

 #if BACKLIGHT_GPIO != -1
 void SetBacklight(uint16_t brightness) {
   pwm_config cfg = pwm_get_default_config();
   pwm_set_wrap(pwm_gpio_to_slice_num(BACKLIGHT_GPIO), 65535);
   pwm_init(pwm_gpio_to_slice_num(BACKLIGHT_GPIO), &cfg, true);
   gpio_set_function(BACKLIGHT_GPIO, GPIO_FUNC_PWM);

   pwm_set_gpio_level(BACKLIGHT_GPIO, brightness);
 }
 #endif

 SpiValues::SpiValues(pw::spi::Config config,
                      pw::spi::ChipSelector& selector,
                      pw::sync::VirtualMutex& initiator_mutex)
     : initiator(SPI_PORT),
       borrowable_initiator(initiator, initiator_mutex),
       device(borrowable_initiator, config, selector) {}

 constexpr pw::i2c::PicoInitiator::Config ki2cConfig{
     .i2c_block = 0,
     .baud_rate_bps = 400'000,
     .sda_pin = 4,
     .scl_pin = 5,
 };

 pw::i2c::PicoInitiator i2c_bus(ki2cConfig);

 }  // namespace

 // static
 Status Common::Init() {
 #if OVERCLOCK_250
   // Overvolt for a stable 250MHz on some RP2040s
   vreg_set_voltage(VREG_VOLTAGE_1_20);
   sleep_ms(10);
   set_sys_clock_khz(250000, false);
 #endif

   // Initialize all of the present standard stdio types that are linked into the
   // binary.
   stdio_init_all();

   // Set up the default UART and assign it to the default GPIO's.
   setup_default_uart();

   s_display_cs_pin.Enable();
   s_display_dc_pin.Enable();
 #if DISPLAY_RESET_GPIO != -1
   s_display_reset_pin.Enable();
 #endif

 #if DISPLAY_TE_GPIO != -1
   s_display_tear_effect_pin.Enable();
 #endif

   i2c_bus.Enable();

 #if BACKLIGHT_GPIO != -1
   SetBacklight(0xffff);  // Full brightness.
 #endif

   unsigned actual_baudrate = spi_init(SPI_PORT, kBaudRate);
   PW_LOG_DEBUG("Actual Baudrate: %u", actual_baudrate);

 #if SPI_MISO_GPIO != -1
   gpio_set_function(SPI_MISO_GPIO, GPIO_FUNC_SPI);
 #endif
   gpio_set_function(SPI_CLOCK_GPIO, GPIO_FUNC_SPI);
   gpio_set_function(SPI_MOSI_GPIO, GPIO_FUNC_SPI);

 #if USE_PIO
   // Init the display before the pixel pusher.
   s_display_driver.Init();
   auto result = s_pixel_pusher.Init(s_fb_pool);
   s_pixel_pusher.SetPixelDouble(true);
   return result;
 #else
   return s_display_driver.Init();
 #endif
 }

 // static
 pw::display::Display& Common::GetDisplay() { return s_display; }
	// Copyright 2022 The Pigweed Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License"); you may not
	// use this file except in compliance with the License. You may obtain a copy of
	// the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	// License for the specific language governing permissions and limitations under
	// the License.
	#include <cstdint>

	#include "app_common/common.h"

	#define LIB_CMSIS_CORE 0
	#define LIB_PICO_STDIO_SEMIHOSTING 0

	#include "hardware/gpio.h"
	#include "hardware/pwm.h"
	#include "hardware/vreg.h"
	#include "pico/stdlib.h"
	#include "pw_digital_io_rp2040/digital_io.h"
	#include "pw_i2c_rp2040/initiator.h"
	#include "pw_log/log.h"
	#include "pw_pixel_pusher_rp2040_pio/pixel_pusher.h"
	#include "pw_spi_rp2040/chip_selector.h"
	#include "pw_spi_rp2040/initiator.h"
	#include "pw_status/status.h"
	#include "pw_sync/borrow.h"
	#include "pw_sync/mutex.h"

	#if defined(DISPLAY_TYPE_ILI9341)
	#include "pw_display_driver_ili9341/display_driver.h"
	using DisplayDriver = pw::display_driver::DisplayDriverILI9341;
	#elif defined(DISPLAY_TYPE_ST7735)
	#include "pw_display_driver_st7735/display_driver.h"
	using DisplayDriver = pw::display_driver::DisplayDriverST7735;
	#elif defined(DISPLAY_TYPE_ST7789)
	#include "pw_display_driver_st7789/display_driver.h"
	using DisplayDriver = pw::display_driver::DisplayDriverST7789;
	#elif defined(DISPLAY_TYPE_ST7789_PIO)
	#include "pw_display_driver_st7789/display_driver.h"
	using DisplayDriver = pw::display_driver::DisplayDriverST7789;
	#else
	#error "Undefined display type"
	#endif

	using pw::Status;
	using pw::digital_io::Rp2040DigitalIn;
	using pw::digital_io::Rp2040DigitalInOut;
	using pw::display::Display;
	using pw::framebuffer::Framebuffer;
	using pw::framebuffer::PixelFormat;
	using pw::framebuffer_pool::FramebufferPool;
	using pw::pixel_pusher::PixelPusherRp2040Pio;
	using pw::spi::Device;
	using pw::spi::Initiator;
	using pw::spi::PicoChipSelector;
	using pw::spi::PicoInitiator;
	using pw::sync::Borrowable;
	using pw::sync::VirtualMutex;

	namespace {

	// Pico spi0 Pins
	#define SPI_PORT spi0

	struct SpiValues {
	SpiValues(pw::spi::Config config,
	pw::spi::ChipSelector& selector,
	pw::sync::VirtualMutex& initiator_mutex);

	pw::spi::PicoInitiator initiator;
	pw::sync::Borrowable<pw::spi::Initiator> borrowable_initiator;
	pw::spi::Device device;
	};

	static_assert(DISPLAY_WIDTH > 0);
	static_assert(DISPLAY_HEIGHT > 0);

	constexpr uint16_t kDisplayScaleFactor = 2;
	constexpr uint16_t kFramebufferWidth =
	FRAMEBUFFER_WIDTH >= 0 ? FRAMEBUFFER_WIDTH / kDisplayScaleFactor
	: DISPLAY_WIDTH / kDisplayScaleFactor;
	constexpr uint16_t kFramebufferHeight = DISPLAY_HEIGHT / kDisplayScaleFactor;

	constexpr pw::math::Size<uint16_t> kDisplaySize{DISPLAY_WIDTH, DISPLAY_HEIGHT};
	constexpr size_t kNumPixels = kFramebufferWidth * kFramebufferHeight;
	constexpr uint16_t kFramebufferRowBytes = sizeof(uint16_t) * kFramebufferWidth;

	constexpr uint32_t kBaudRate = 31'250'000;
	constexpr pw::spi::Config kSpiConfig8Bit{
	.polarity = pw::spi::ClockPolarity::kActiveHigh,
	.phase = pw::spi::ClockPhase::kFallingEdge,
	.bits_per_word = pw::spi::BitsPerWord(8),
	.bit_order = pw::spi::BitOrder::kMsbFirst,
	};
	constexpr pw::spi::Config kSpiConfig16Bit{
	.polarity = pw::spi::ClockPolarity::kActiveHigh,
	.phase = pw::spi::ClockPhase::kFallingEdge,
	.bits_per_word = pw::spi::BitsPerWord(16),
	.bit_order = pw::spi::BitOrder::kMsbFirst,
	};

	Rp2040DigitalInOut s_display_dc_pin(DISPLAY_DC_GPIO);
	#if DISPLAY_RESET_GPIO != -1
	Rp2040DigitalInOut s_display_reset_pin(DISPLAY_RESET_GPIO);
	#endif
	#if DISPLAY_TE_GPIO != -1
	Rp2040DigitalIn s_display_tear_effect_pin(DISPLAY_TE_GPIO);
	#endif
	Rp2040DigitalInOut s_display_cs_pin(DISPLAY_CS_GPIO);
	PicoChipSelector s_spi_chip_selector(s_display_cs_pin);
	PicoInitiator s_spi_initiator(SPI_PORT);
	VirtualMutex s_spi_initiator_mutex;
	Borrowable<Initiator> s_borrowable_spi_initiator(s_spi_initiator,
	s_spi_initiator_mutex);
	SpiValues s_spi_8_bit(kSpiConfig8Bit,
	s_spi_chip_selector,
	s_spi_initiator_mutex);
	SpiValues s_spi_16_bit(kSpiConfig16Bit,
	s_spi_chip_selector,
	s_spi_initiator_mutex);

	#if USE_PIO
	PixelPusherRp2040Pio s_pixel_pusher(DISPLAY_DC_GPIO,
	DISPLAY_CS_GPIO,
	SPI_MOSI_GPIO,
	SPI_CLOCK_GPIO,
	DISPLAY_TE_GPIO,
	pio0);
	#endif
	uint16_t s_pixel_data1[kNumPixels];
	uint16_t s_pixel_data2[kNumPixels];
	const pw::Vector<void*, 2> s_pixel_buffers{s_pixel_data1, s_pixel_data2};
	pw::framebuffer_pool::FramebufferPool s_fb_pool({
	.fb_addr = s_pixel_buffers,
	.dimensions = {kFramebufferWidth, kFramebufferHeight},
	.row_bytes = kFramebufferRowBytes,
	.pixel_format = PixelFormat::RGB565,
	});
	DisplayDriver s_display_driver({
	.data_cmd_gpio = s_display_dc_pin.as<pw::digital_io::DigitalOut>(),
	.spi_cs_gpio = s_display_cs_pin.as<pw::digital_io::DigitalOut>(),
	#if DISPLAY_RESET_GPIO != -1
	.reset_gpio = &s_display_reset_pin.as<pw::digital_io::DigitalOut>(),
	#else
	.reset_gpio = nullptr,
	#endif
	#if DISPLAY_TE_GPIO != -1
	.tear_effect_gpio = &s_display_tear_effect_pin,
	#else
	.tear_effect_gpio = nullptr,
	#endif
	.spi_device_8_bit = s_spi_8_bit.device,
	.spi_device_16_bit = s_spi_16_bit.device,
	#if USE_PIO
	.pixel_pusher = &s_pixel_pusher,
	#endif
	});
	Display s_display(s_display_driver, kDisplaySize, s_fb_pool);

	#if BACKLIGHT_GPIO != -1
	void SetBacklight(uint16_t brightness) {
	pwm_config cfg = pwm_get_default_config();
	pwm_set_wrap(pwm_gpio_to_slice_num(BACKLIGHT_GPIO), 65535);
	pwm_init(pwm_gpio_to_slice_num(BACKLIGHT_GPIO), &cfg, true);
	gpio_set_function(BACKLIGHT_GPIO, GPIO_FUNC_PWM);

	pwm_set_gpio_level(BACKLIGHT_GPIO, brightness);
	}
	#endif

	SpiValues::SpiValues(pw::spi::Config config,
	pw::spi::ChipSelector& selector,
	pw::sync::VirtualMutex& initiator_mutex)
	: initiator(SPI_PORT),
	borrowable_initiator(initiator, initiator_mutex),
	device(borrowable_initiator, config, selector) {}

	constexpr pw::i2c::PicoInitiator::Config ki2cConfig{
	.i2c_block = 0,
	.baud_rate_bps = 400'000,
	.sda_pin = 4,
	.scl_pin = 5,
	};

	pw::i2c::PicoInitiator i2c_bus(ki2cConfig);

	} // namespace

	// static
	Status Common::Init() {
	#if OVERCLOCK_250
	// Overvolt for a stable 250MHz on some RP2040s
	vreg_set_voltage(VREG_VOLTAGE_1_20);
	sleep_ms(10);
	set_sys_clock_khz(250000, false);
	#endif

	// Initialize all of the present standard stdio types that are linked into the
	// binary.
	stdio_init_all();

	// Set up the default UART and assign it to the default GPIO's.
	setup_default_uart();

	s_display_cs_pin.Enable();
	s_display_dc_pin.Enable();
	#if DISPLAY_RESET_GPIO != -1
	s_display_reset_pin.Enable();
	#endif

	#if DISPLAY_TE_GPIO != -1
	s_display_tear_effect_pin.Enable();
	#endif

	i2c_bus.Enable();

	#if BACKLIGHT_GPIO != -1
	SetBacklight(0xffff); // Full brightness.
	#endif

	unsigned actual_baudrate = spi_init(SPI_PORT, kBaudRate);
	PW_LOG_DEBUG("Actual Baudrate: %u", actual_baudrate);

	#if SPI_MISO_GPIO != -1
	gpio_set_function(SPI_MISO_GPIO, GPIO_FUNC_SPI);
	#endif
	gpio_set_function(SPI_CLOCK_GPIO, GPIO_FUNC_SPI);
	gpio_set_function(SPI_MOSI_GPIO, GPIO_FUNC_SPI);

	#if USE_PIO
	// Init the display before the pixel pusher.
	s_display_driver.Init();
	auto result = s_pixel_pusher.Init(s_fb_pool);
	s_pixel_pusher.SetPixelDouble(true);
	return result;
	#else
	return s_display_driver.Init();
	#endif
	}

	// static
	pw::display::Display& Common::GetDisplay() { return s_display; }