<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>ESP32 on 菜菜博士</title>
    <link>https://microcai.org/tags/ESP32.html</link>
    <description>Recent content in ESP32 on 菜菜博士</description>
    <generator>Hugo</generator>
    <language>zh-cn</language>
    <lastBuildDate>Wed, 20 Dec 2023 00:00:00 +0800</lastBuildDate>
    <atom:link href="https://microcai.org/tags/ESP32/feed.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>变频器制作-第九部分之ESP32C3 也能输出svpwm</title>
      <link>https://microcai.org/2023/12/20/esp32c3-can-drive-svpwm.html</link>
      <pubDate>Wed, 20 Dec 2023 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2023/12/20/esp32c3-can-drive-svpwm.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;先看以下乐馨官方的 ESP32S3 和 ESP32C3 的对比&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/esp32s3-vs-esp32c3.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;很明显，ESP32C3 缺乏 MCPWM 设备。&lt;/p&gt;
&lt;p&gt;所谓 MCPWM, 就是专门为产生svpwm设计的电路。他能产生6路互补的PWM信号，并且实现中央对齐。然后还能实现在PWM信号的特定位置产生同步事件。app据此可以在这个同步事件上实现电流采样。&lt;/p&gt;
&lt;p&gt;一度我以为 ESP32C3 是无法用于驱动电机的。&lt;/p&gt;
&lt;p&gt;直到一次偶然，我看到 SimpleFOC 的论坛里有人提到要支持 ESP32C3。我在想，这C3不是没MCPWM么？ SimpleFOC咋支持？&lt;/p&gt;
&lt;p&gt;事实是，SimpleFOC 也确实不支持 C3。但是有人回复他实现过。就用的 LEDC PWM。&lt;/p&gt;
&lt;p&gt;要知道，ESP32C3 可比 S3 便宜了一半还多。要真的能驱动电机，那我的 VVVF 变频器大业，又多了一项可选的MCU！&lt;/p&gt;
&lt;h1 id=&#34;实践&#34;&gt;实践&lt;/h1&gt;
&lt;p&gt;虽然别人有提过他用 LEDC PWM 实现了 foc。但是吧，无代码无真相。但是总归人家说可以。那我研究研究吧。于是购入 ESP32S3。&lt;/p&gt;
&lt;p&gt;等等，不是说C3吗？咋买了S3呢？因为我确信我的VVVF需要蓝牙！需要WIFI！AT32F415已经不能满足我的需求了。&lt;/p&gt;
&lt;p&gt;然后顺便买了个9.9的 ESP32C3开发板。&lt;/p&gt;
&lt;p&gt;等开发板到了，我马上研究起了 ESP32C3。虽然C3是顺便买的，但是不妨碍我先研究它。&lt;/p&gt;
&lt;p&gt;于是在项目里创建了 lib/libvfd/hal/esp32c3pwm.{hpp,cpp} 文件。&lt;/p&gt;
&lt;p&gt;着手研究 ESP32C3 里的 LEDC PWM。&lt;/p&gt;
&lt;p&gt;最后踩了无数的坑后，把他实现出来了。&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;
#if defined(ESP_PLATFORM)

#ifdef CONFIG_IDF_TARGET_ESP32C3

#include &amp;#34;esp32c3pwm.hpp&amp;#34;
#include &amp;#34;driver/ledc.h&amp;#34;
#include &amp;#34;esp_err.h&amp;#34;
#include &amp;#34;esp_timer.h&amp;#34;
#include &amp;#34;freertos/FreeRTOS.h&amp;#34;
#include &amp;#34;freertos/task.h&amp;#34;
#include &amp;#34;freertos/timers.h&amp;#34;
#include &amp;#34;private/commons.hpp&amp;#34;

#include &amp;#34;os/os.hpp&amp;#34;

#define FOC_MCPWM_TIMER_RESOLUTION_HZ 40000000 // 40MHz, 1 tick = 0.025us

#ifndef INVERT_LOW_SIDE
#define INVERT_LOW_SIDE 0
#endif

const static char* TAG = &amp;#34;vfd&amp;#34;;

namespace motorlib
{
	struct esp32c3pwmdriver_impl
	{
		/*
		 * Prepare and set configuration of timers
		 * that will be used by LED Controller
		 */
		ledc_timer_config_t timer_config = {
			.speed_mode		 = LEDC_LOW_SPEED_MODE, // timer mode
			.duty_resolution = LEDC_TIMER_13_BIT,	// resolution of PWM duty
			.timer_num		 = LEDC_TIMER_0,		// timer index
			.freq_hz		 = 4000,				// frequency of PWM signal
			.clk_cfg		 = LEDC_AUTO_CLK,		// Auto select the source clock
		};

		int gen_gpios[6]; // 3 GPIO pins for generator config

		// hardware variables
		int pwm_frequency;
		int pwm_period;

		esp32c3pwmdriver_impl(
			int pin_AH, int pin_AL, int pin_BH, int pin_BL, int pin_CH, int pin_CL, int PWM_freq)
			: pwm_frequency(PWM_freq)
		{
			gen_gpios[0] = pin_AH;
			gen_gpios[1] = pin_BH;
			gen_gpios[2] = pin_CH;
			gen_gpios[3] = pin_AL;
			gen_gpios[4] = pin_BL;
			gen_gpios[5] = pin_CL;

			// ledc_timer_config.duty_resolution = ledc_find_suitable_duty_resolution(LEDC_USE_XTAL_CLK, pwm_frequency);

			pwm_period = 1 &amp;lt;&amp;lt; timer_config.duty_resolution;
			// pwm_frequency = timer_config.freq_hz;

			esp_err_t ret;
			ledc_timer_rst(LEDC_LOW_SPEED_MODE, LEDC_TIMER_0);

			ret = ledc_timer_config(&amp;amp;timer_config);
			timer_config.timer_num = LEDC_TIMER_1;
			ret = ledc_timer_config(&amp;amp;timer_config);
			os::printf(&amp;#34;ledc_channel_config return %d\n&amp;#34;, ret);

			ledc_channel_config_t ledc_channel[] = {
				{
					.gpio_num	= pin_AH,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_0,
					.timer_sel	= LEDC_TIMER_0,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = 0 },
				},
				{
					.gpio_num	= pin_BH,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_1,
					.timer_sel	= LEDC_TIMER_0,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = 0 },
				},
				{
					.gpio_num	= pin_CH,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_2,
					.timer_sel	= LEDC_TIMER_0,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = 0 },
				},
				{ .gpio_num		= pin_AL,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_3,
					.timer_sel	= LEDC_TIMER_1,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = !INVERT_LOW_SIDE } },
				{ .gpio_num		= pin_BL,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_4,
					.timer_sel	= LEDC_TIMER_1,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = !INVERT_LOW_SIDE } },
				{ .gpio_num		= pin_CL,
					.speed_mode = LEDC_LOW_SPEED_MODE,
					.channel	= LEDC_CHANNEL_5,
					.timer_sel	= LEDC_TIMER_1,
					.duty		= 1,
					.hpoint		= 0,
					.flags		= { .output_invert = !INVERT_LOW_SIDE } },
			};

			for (int ch = 0; ch &amp;lt; 6; ch++)
			{
				ret = ledc_channel_config(&amp;amp;ledc_channel[ch]);
				os::printf(&amp;#34;ledc_channel_config return %d\n&amp;#34;, ret);
			}

			stop();
		}

		void set_duty(float_number U_a, float_number U_b, float_number U_c)
		{
			auto u_lpoint = clamp&amp;lt;int&amp;gt;(U_a * pwm_period, 0, pwm_period-1);
			auto v_lpoint = clamp&amp;lt;int&amp;gt;(U_b * pwm_period, 0, pwm_period-1);
			auto w_lpoint = clamp&amp;lt;int&amp;gt;(U_c * pwm_period, 0, pwm_period-1);

			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, u_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1, v_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_2, w_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_3, u_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_4, v_duty);
			ledc_set_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_5, w_duty);

			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_2);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_3);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_4);
			ledc_update_duty(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_5);
		}

		void set_frequency(int freq)
		{
			if (freq &amp;lt;= 6000 &amp;amp;&amp;amp; freq &amp;gt;= 3000)
			{
				ledc_set_freq(LEDC_LOW_SPEED_MODE, LEDC_TIMER_0, freq);
				ledc_set_freq(LEDC_LOW_SPEED_MODE, LEDC_TIMER_1, freq);
				pwm_frequency = freq;
                esp_timer_restart(hr_timer, 1000000/freq);
			}
		}

		void stop()
		{
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_0, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_1, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_2, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_3, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_4, 0);
			ledc_stop(LEDC_LOW_SPEED_MODE, LEDC_CHANNEL_5, 0);
		}

		void start() { }

		int get_frequency() { return pwm_frequency; }

		pwmdriver::timer_fn pwm_cb;

		static void timer_cb(void* user_data)
		{
			auto _this = reinterpret_cast&amp;lt;esp32c3pwmdriver_impl*&amp;gt;(user_data);_this-&amp;gt;pwm_cb(_this-&amp;gt;pwm_frequency);
		}

		esp_timer_handle_t hr_timer;

		void link_timer(pwmdriver::timer_fn fn)
		{
			pwm_cb = fn;

			esp_timer_create_args_t timer_arg = {
				.callback			   = timer_cb,
				.arg				   = this,
				.dispatch_method	   = ESP_TIMER_TASK,
				.name				   = &amp;#34;pwm_tmr&amp;#34;,
				.skip_unhandled_events = true,
			};

			esp_timer_create(&amp;amp;timer_arg, &amp;amp;hr_timer);
			// 200us = 5khz pwm
			esp_timer_start_periodic(hr_timer, 200);
		}

        ~esp32c3pwmdriver_impl()
        {
            esp_timer_stop(hr_timer);
			esp_timer_delete(hr_timer);
        }
	};

	//////////////////////////////////////////////////////////////////////////////
	esp32c3pwmdriver::esp32c3pwmdriver(
		int pin_AH, int pin_AL, int pin_BH, int pin_BL, int pin_CH, int pin_CL)
	{
		impl = new esp32c3pwmdriver_impl(pin_AH, pin_AL, pin_BH, pin_BL, pin_CH, pin_CL, 4000);
	}

	esp32c3pwmdriver::~esp32c3pwmdriver()
	{
        delete impl;
    }

	// Function setting the duty cycle to the pwm pin (ex. analogWrite())
	// - BLDC driver - 6PWM setting
	// - hardware specific
	void esp32c3pwmdriver::set_duty(float_number U_a, float_number U_b, float_number U_c)
	{
		impl-&amp;gt;set_duty(U_a, U_b, U_c);
	}

	void esp32c3pwmdriver::start() { impl-&amp;gt;start(); }

	void esp32c3pwmdriver::stop() { impl-&amp;gt;stop(); }

	int esp32c3pwmdriver::get_frequency() { return impl-&amp;gt;get_frequency(); }

	void esp32c3pwmdriver::set_frequency(int f) { impl-&amp;gt;set_frequency(f); }

	void esp32c3pwmdriver::link_timer(timer_fn fn) { impl-&amp;gt;link_timer(fn); }

}

#endif // CONFIG_IDF_TARGET_ESP32C3
#endif // defined(ESP_PLATFORM)
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;不同于其他平台使用 PWM 自身的定时器中断，esp32c3 上，pwm 周期更新的回调是由一个高精度定时器回调提供的。之所以不用 pwm 的回调，是因为 ledc pwm 并不会产生这样的中断——除非使用了硬件fade功能。
但电机控制岂是fade能瞎fade的？&lt;/p&gt;</description>
    </item>
    <item>
      <title>platformIO 单片机开发神器</title>
      <link>https://microcai.org/2022/11/12/platformio.html</link>
      <pubDate>Sat, 12 Nov 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/11/12/platformio.html</guid>
      <description>&lt;p&gt;近来闲暇无事，想弄个三相变频器玩玩。
三相变频器可以用来驱动异步电机，还可以驱动直线加速器。&lt;/p&gt;
&lt;p&gt;于是搜索万能宝，发现只有380v的变频器。&lt;/p&gt;
&lt;p&gt;可是我想玩安全电压的。最多24V三相交流电。&lt;/p&gt;
&lt;p&gt;找不到，看来只能自己开发一个了。&lt;/p&gt;
&lt;p&gt;硬件不用自己做，只要购买无刷电机驱动板就可以了。
无刷电机驱动板，只要提供3路PWM信号，就可以生成驱动无刷电机用的三相交流电。&lt;/p&gt;
&lt;p&gt;而生成这pwm信号的工作，就留给了单片机。&lt;/p&gt;
&lt;p&gt;我比较中意的单片机是 ESP32. 便宜，性能强。STM32 零头的价格提供了比 STM32 高数倍的性能。&lt;/p&gt;
&lt;p&gt;我写程序啊，不喜欢从头写。哪怕是单片机。
总不能用汇编代码一点一点写吧。再说，汇编我也只知道8051的汇编，不懂 esp32 的汇编。&lt;/p&gt;
&lt;p&gt;所以，用了 SimpleFOC 这个库。&lt;/p&gt;
&lt;p&gt;这个库虽然是用来驱动无刷电机的，但是他带了一个 3PWM Driver . 我只要用他这个。&lt;/p&gt;
&lt;p&gt;起初我用 VSCODE 搭配 ExpressIDF SDK 写过 ESP32 的代码。
但是 SimpleFOC 基于 arduino 库，无法直接使用 ExpressIDF SDK。&lt;/p&gt;
&lt;p&gt;后来我就折腾用 arduino 写。发现 arduino 的编辑器不是很顺手。代码补全，语法提示就是个 0 。&lt;/p&gt;
&lt;p&gt;还是得用vscode写，结果翻阅 simplefoc 的文档发现可以用 platformio。
PlatformIO 是个 vscode 的插件。 装上它，就有了一个单片机的集成开发环境了。
编辑器还是用的 vscode，还能用 clangd 进行自动完成。&lt;/p&gt;
&lt;p&gt;后来还发现 platformio 更高级的功能，就是可以多平台构建。可以同一份源码直接编译出 ESP32 和 STM32 的固件。
虽然soc各有不同的地方， 但是这些不同的地方可以用偶这个C++程序员最擅长的条件编译搞定。&lt;/p&gt;
&lt;p&gt;至于 stm32 的板子，嘿嘿， 之前玩电机的是买过一个 VESC 的电机控制器。控制器上是个 STM32F405G ，而且，板子上 SWD 调试端口。接上 stlink， 在 platformio 里添加一个 stm32 的板子， 点 upload 直接成功！&lt;/p&gt;</description>
    </item>
  </channel>
</rss>
