ESP8266 MultiPWMs Lib ver.0.7
目前已完成至自己要想的程度了，馬達的基礎控制應都有了；調滴西，調頻，調相。除非想到有要追加的，不然應不會更新。不過，不過，還有一支 bug 未解，就是程式未開始跑前的 sync 設定，開始跑後並不正確。不過在跑的過程中作 sync 是正確的。這隻 bug 我想破頭都想不著，不能一直耗在這，故暫時放棄解它。相信看了範例影片會笑的，真的功能都有了。
要知道，所展示的範例程式是有 13 支 pwm 同時在跑喔！
#include"Esp8266MultiPwms.h"
// applied on NodeMCU 0.9 (ESP-12 Module) @80Hz. 115200bps.
cMultiPwms sss[12]={
{3, 800, 16},
{5, 800, 16},
{12, 800, 16},
{13, 800, 16},
{2, 800, 8},
{0, 800, 8},
{0, 800, 8},
{4, 800, 8},
{0, 155800, 2},
{0, 166800, 2},
{14, 177800, 2},
{0, 188800, 2},
};
cMultiPwms a;
void setup_cmultipwms() {
pinMode(3, OUTPUT);
pinMode(5, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
pinMode(15, OUTPUT);
pinMode(2, OUTPUT);
pinMode(4, OUTPUT);
pinMode(14, OUTPUT);
unsigned a=micros();
cMultiPwms::SyncStart(sss[0]);
cMultiPwms::SyncNext(sss[1], 100);
cMultiPwms::SyncNext(sss[2], 150);
cMultiPwms::SyncNext(sss[3], 200);
cMultiPwms::SyncEnd(sss[0]);
delay(3);
cMultiPwms::SyncStart(sss[3]);
cMultiPwms::SyncNext(sss[4], 50);
cMultiPwms::SyncNext(sss[5], 100);
cMultiPwms::SyncNext(sss[6], 150);
cMultiPwms::SyncNext(sss[7], 200);
cMultiPwms::SyncEnd(sss[3]);
delay(17);
cMultiPwms::SyncStart(sss[2]);
cMultiPwms::SyncNext(sss[8], 300);
cMultiPwms::SyncNext(sss[9], 350);
cMultiPwms::SyncNext(sss[10], 400);
cMultiPwms::SyncNext(sss[11], 450);
cMultiPwms::SyncEnd(sss[2]);
unsigned b=micros()-20000;
sss[0].setDC(0, 4);
sss[1].setDC(0, 4);
sss[2].setDC(0, 4);
sss[3].setDC(0, 4);
sss[4].setDC(0, 1);
sss[5].setDC(0, 2);
sss[6].setDC(0, 3);
sss[7].setDC(0, 4);
sss[8].setDC(0, 1);
sss[9].setDC(0, 2);
sss[10].setDC(0, 2);
sss[11].setDC(0, 1);
unsigned c=micros();
printf("\r\n12 pwms, sync take %dus, set dc take %dus\r\n\r\n", b-a, c-b);
}
void G15(){
static unsigned tmo0=micros();
if (cMultiPwms::Timeout(300, tmo0, true)){ // oneshot to set 1ms, 20steps, inverted, stophigh, running at 1step
a=cMultiPwms(0, 1000, 20, true, true); // waste an id, not suggested
a.setGpio(15);
a.Resume();
//printf("\r\nthis pwm is %d, processing at %d\r\n", a.getId(), 1);
}
static unsigned tmo1=micros(), dc1=0, k=1, maxdc=20;
if (cMultiPwms::Timeout(800, tmo1) && k){ // per 800ms, inc dc a step
a.setDC(0, dc1++);
if (dc1>maxdc) dc1=0;
//printf("\r\nthis pwm is %d, processing at %d\r\n", a.getId(), 2);
}
static unsigned tmo2=micros();
if (cMultiPwms::Timeout(15000, tmo2, true)){ // @15s, pause
k=0;
a.Pause();
//printf("\r\nthis pwm is %d, processing at %d\r\n", a.getId(), 3);
}
static unsigned tmo3=micros();
if (cMultiPwms::Timeout(20000, tmo3, true)){ // @20s, resume
k=1;
a.Resume();
//printf("\r\nthis pwm is %d, processing at %d\r\n", a.getId(), 4);
}
static unsigned tmo4=micros();
if (cMultiPwms::Timeout(30000, tmo4, true)){ // @30s, stop at low and deallocate
k=0;
a.setStopLevel(false);
a.removePwm();
//printf("\r\nthis pwm is %d, processing at %d\r\n", a.getId(), 5);
}
static unsigned tmo5=micros();
if (cMultiPwms::Timeout(40000, tmo5, true)){ // @40s, setperiod 800us, 8steps, running at 50%, inverted, stophigh
a=sss[5]; // 800, 8
a.setGpio(15);
a.setInvert(true);
a.setStopLevel(true);
a.setDC(50);
//printf("\r\nthis pwm is %d, processing at %d\r\n", a.getId(), 6);
}
static unsigned tmo6=micros();
if (cMultiPwms::Timeout(55000, tmo6, true)){ // @55s, alter dc
maxdc=8;
k=1;
//printf("\r\nthis pwm is %d, processing at %d\r\n", a.getId(), 7);
}
static unsigned tmo7=micros();
if (cMultiPwms::Timeout(75000, tmo7, true)){ // @75s, setperiod 1.5s, 4steps, noninverted, stoplow
a.setPeriod(1500000, 4, 0, 1);
a.setInvert(false);
a.setStopLevel(false);
k=0;
//printf("\r\nthis pwm is %d, processing at %d\r\n", a.getId(), 8);
}
static unsigned tmo8=micros(), tmo9=tmo8;
if (cMultiPwms::Timeout(90000, tmo8, true, true))
if (cMultiPwms::Timeout(150, tmo9)){ // @90s, per 150ms, changes freq
// gen a valid freq
static int count_down=1500000, inv=1;
int the_dc=50, the_steps=4;
while ((count_down>=200) && count_down%200) count_down-=inv;
a.setPeriod(count_down, the_steps, the_dc);
if (count_down>=100000) count_down-=49001;
else if (count_down>=50800) count_down=10998;
else if ((count_down>=201) && (count_down<=10997)) count_down-=inv;
else {inv=0-inv; count_down-=inv;}
}
}
void G3_5_12_13(){
static unsigned s=0, y=0, z=0;
static unsigned tmo1=micros(), tmo2=tmo1, tmo3=tmo2;
if (cMultiPwms::Timeout(8000, tmo1, true, true) && !cMultiPwms::Timeout(75000, tmo2, true, true)){ // 800us, run between @8s and @75s
if (cMultiPwms::Timeout(300, tmo3)){ // run per 300ms
if (++s>=16) s=1;
for (int i=0; i<4; i++) sss[i].setDC(0, s); // each time set dc
if (!(++y%3)){ // set the 4 pwms synced per 0.9s
cMultiPwms::SyncStart(sss[0]);
for (int j=1; j<4; j++) cMultiPwms::SyncNext(sss[j], 50*(z+j-1)%800);
cMultiPwms::SyncEnd(sss[0]);
z++;
}
//printf("\r\nthis pwm is %d, processing at %d\r\n", sss[0].getId(), 21);
}
}
static unsigned tmo4=micros();
if (cMultiPwms::Timeout(85000, tmo4, true)){ // @85s, reconfig the 4 pwms as 6.8ms period, 17steps, run at 1step, synced offset 250us
//printf("\r\nthis pwm is %d, processing at %d\r\n", sss[0].getId(), 22);
sss[0].removePwm();
sss[0].configPwm(3, 6800, 17, false, false); // GPIO3, non-inverted, stoplow
sss[0].setDC(0, 1); // 1step
sss[1]=sss[0];
sss[1].setDC(5); // also 1step
sss[1].setStopLevel(true); // stophigh
sss[1].setInvert(true); // inverted
sss[2]=cMultiPwms(12, 400, 4); // GPIO12, 400us, 4steps, noninverted, stoplow. waste an id not suggested.
sss[2].setPeriod(6800, 17, 5);
sss[3].setPeriod(6800, 17, 0, 1);
cMultiPwms::SyncStart(sss[0]);
for (int k=1; k<4; k++) cMultiPwms::SyncNext(sss[k], 250*k);
cMultiPwms::SyncEnd(sss[0]);
}
static unsigned tmo5=micros();
if (cMultiPwms::Timeout(100000, tmo5, true, true)){ // after @100s, processing sync per 200ms and altering dc
static unsigned tmo6=micros();
static int diff=6800, dc=17, inv=300;
if (cMultiPwms::Timeout(200, tmo6)){
diff-=inv;
if (diff<300) inv=-300;
else if (diff>6500) inv=300;
dc--;
if (!dc) dc=16;
sss[0].setDC(0, 17-dc);
cMultiPwms::SyncStart(sss[0]);
cMultiPwms::SyncNext(sss[1], 0);
cMultiPwms::SyncNext(sss[2], diff);
cMultiPwms::SyncNext(sss[3], 6800-diff);
cMultiPwms::SyncEnd(sss[0]);
sss[1].setDC(0, dc);
}
}
}
void loop_cmultipwms() {
cMultiPwms::traverseLinkedList();
delay(5);
static unsigned tmox=micros();
if (cMultiPwms::Timeout(50, tmox)) G3_5_12_13(); // run it per 50ms
static unsigned tmoy=micros();
if (cMultiPwms::Timeout(20000, tmoy, true, true)) G15(); // run it after @20s
}
void setup(){
Serial.begin(115200);
delay(5000);
setup_cmultipwms();
}
void loop(){
loop_cmultipwms();
}Esp8266MultiPwms.h
// Esp8266MultiPwms.h ver.0.7
// https://waterfalls.ddns.net
// by Ken Woo
// 2020.12.23
/*
ver.0.1 initial release
ver.0.2 a. fixed many bugs
b. add sync function
ver.0.3 a. add speedup
b. change class name from cMultiPwm to cMultiPwms
c. add constructors
d. add stop_all method
e. fix destructor bug
f. modify the sync function
ver.0.4 a. fix some bugs
b. mainly fulfill sync functions
ver.0.5 a. fix some bugs
b. big change of the code structure
c. add sync func capable of more than 2 waveforms
d. add setPeriod() so as to dynamically change dc or frequency.
e. fix bug as to seamlessly the waveform change dc or freq.
f. the waveforms synced still some becomes complement offset, i.e.,
f1. q_offset becomes period-q_offset, or no-clue deviated. under investigation.
ver.0.6 a. setDC has the timing shifting problem/wrong reload counter which caused by CDPAV. fixed.
b. sync funcs have wrong parameter calculation. fixed.
c. the test is accurate at 80Hz.
ver.0.7 a. the file of the code divided into 2 .h, .cpp, for Arduino IDE Lib use.
b. add supplementary functions.
c. let objects reusable after removePwm(). reassign is now available too.
d. fixed the new object still needs to define tr_low_pos, etc., parameters. otherwise is incorrect before setDC called.
e. sync before isr running hence applicable, however incorrect currently.
todo. a. avoid to allocate memory on external ram or flash.
known bugs. a. max period now shrinks to 1.5 seconds. wdt-reset if over.
b. IRAM_ATTR or non-global static pwm objects probably cause wdt-reset.
c. sync before isr running is incorrect.
d. if wdt-reset, probably heavy loading and firstly try to ease. now ok test 13 pwms running and 5 doing variations in it.
e. please report and refinement recommendation.
*/
// PWM class: using ESP82366 MultiTimersV0.4 to generate four 196us timers which are sequentially sync-offset by 49us to one another.
// which are approaching to and are regarded as 200us/50us. Such a facility forms a single 50us timer with 4 sequential ISRs.
// PWM waveforms whereas ought to be transition of the processes will be evenly settled in the 4 ISRs,
// unless there are specified ones to be explicitly offset or synced to another, which determines the position.
// note that explicitly sync offset is restricted only to same period PWM.
// duty cycle 70% means headed high 70% first then low, inverted duty cycle 70% means headed low 70% then high.
// sync or offset counts for headed beginning.
// so, PWM periods are restricted to multiples of 200us(and at least 200us, at most 13s; in order to have fixed positions),
// (however, since there are delays in this code, such that by test, the max period is as 1.5seconds to prevent from wdt-reset).
// in addition, the duty cycle step must be multiple of 50us, is restricted too.
// for example, 2.2ms PWM with 45 steps is allowed; 2200/200=11 is integer, 2200/44/50=1 is integer,
// step0 0%, step1 <=2.27%(100%/44), step2(<=100%*2/44)..., step44(>100%*43/44) 100%.
// or with 12 steps, each step is 200us, and the like.
// the highest one is 200us/5kHz with 5 steps(0%, 0%< <=25%, 25%< <=50%, 50%< <=75%, 75%< <=100%).
// the number of PWMs depends on bits of id; you can rewrite it for unlimited PWMs theoretically.
// new pwm objects are at the stopped state, once setDC/setPeriod/sync will commence to run.
#include"Esp8266HwSwTimers.h"
#ifndef _c_MULTI_PWMS_H_
#define _c_MULTI_PWMS_H_
// switches
#define C_MULTI_PWMS_DEBUG 0
#define MULTIPWMS_PREVENT_WDT_RESET 1
#define MULTIPWMS_GPIO_PARKING 0 // for efficiency, a gpio number as default is used; it should be INPUT and not used by others.
#if C_MULTI_PWMS_DEBUG
extern unsigned z1, z2, z3, z4;
extern unsigned t1, t11, t2, t22, t3, t33, t4, t44, ttt, ttt1;
extern unsigned w;
extern int syncoffset_d[16]; // after test, it is more analogy to oscope, so fine ref. it tracks offset from id2 to id16 against id1.
#endif
class cMultiPwms{
typedef struct sPwmObj{
unsigned counter: 16; // counter, reload to it.
unsigned rsv1_not_use: 16; // reserved 1. it should be 0 and do not use.
unsigned n_reload_high: 16; // the new reload count for high level.
unsigned reload_high: 16; // reload count for high level. 200us is one-round, 200x65536=13seconds, max period.
unsigned n_reload_low: 16; // the new reload count for low level.
unsigned reload_low: 16; // reload count for low level. 200us is one-round, 200x65536=13seconds.
unsigned freeze: 1; // the first 4 stall bits are mutually exclusive, each would have accepted set if isr acked. freeze is pause.
unsigned stopit: 1; // mainly indicates this obj will be deleted, essentially stop timing.
unsigned is_new_reload: 1; // has a new reload value arrived. used it by read and clear.
unsigned is_aside_duty: 1; // it is the duty 0% or 100%
unsigned accepted: 1; // this bit will be set if isr accepted freeze, etc., every round. so clear it before set stall.
unsigned is_high_level: 1; // the current level counted is high? it will be toggling.
unsigned is_inverted: 1; // we use it at the final waveform, invert it, so it affects nothing.
unsigned stall_h_or_l: 1; // dictates isr to be at high or at low when stall, freeze, stopped or need to do some other things.
unsigned tr_high_pos: 2; // the position at timer ISR[] for transiting to high level, it exists with low-counting.
unsigned tr_low_pos: 2; // the position at timer ISR[] for transiting to low level, coexists with high-counting.
unsigned n_tr_low_pos: 2; // the new position at timer ISR[] for transiting to low level, used to renew in isr.
unsigned gpio: 4; // the gpio pin number
unsigned id: 5; // id in order to search. for unlimited new/delete, must maintain it. but i prefer not.
unsigned rsv2: 9; // reserved 2.
// note the relationship of is_high_level, tr_high_pos, tr_low_pos.
// is_high_level indicats currently is high counting or low. tr_high_pos: currently is low level counting,
// it is going to transit to high level, so it is positioned at tr_high_pos, and vice versa.
// so, the duty-cycle count allocates on reload_high. when which positioning at tr_high_pos, is active, it is counting low,
// when count-up, loading the reload_high to counter, transits the level from low to high, and finally hands over the control
// to tr_low_pos for it active. after a while the count is up again, it is responsible for transiting from high to low,
// then reload reload_low, and then changing position to tr_high_pos again alternatively. it is pointer process, so not much cost.
sPwmObj(){
(reinterpret_cast<unsigned*>(this))[0]=0;
(reinterpret_cast<unsigned*>(this))[1]=0;
(reinterpret_cast<unsigned*>(this))[2]=0;
(reinterpret_cast<unsigned*>(this))[3]=0;
}
} sPwmObj;
typedef unsigned (*xptr_sPwmObj)[4];
#define OP_RLD_HIGH(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[0]=\
(*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[1]>>16)
#define OP_RLD_LOW(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[0]=\
(*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[2]>>16)
#define OP_RLD_NEWHIGH(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[1]<<=16)
#define OP_RLD_NEWLOW(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[2]<<=16)
#define OP_RLD_NEWTRLOWPOS_C(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]=\
((((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]>>2)&0x00000C00)|\
((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&0xFFFFF3FB))) // indication bit also cleared.
#define OP_SET_LVL_HIGH(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]|=0x20)
#define OP_SET_LVL_LOW(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&=0xFFFFFFDF)
#define OP_COUNTER_DEC(sNode_ex) (--(*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[0])
#define VAL_COUNTER(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[0])
#define OP_GET_TR_HIGH_POS(sNode_ex) (((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]>>8)&0x3)
#define OP_GET_TR_LOW_POS(sNode_ex) (((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]>>10)&0x3)
#define OP_GET_GPIO(sNode_ex) (((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]>>14)&0xF)
/// #define OP_GET_STALL_LVL(sNode_ex) (((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]>>7)&0x1)
#define OP_GET_STALL_LVL(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&0x80)
#define OP_DO_ACCEPT(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]|=0x10)
#define IS_NEED_LOOKINTO(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&0xF)
#define IS_FREEZE(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&0x1)
#define IS_STOP(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&0x2)
#define IS_RLD_NEW(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&0x4)
#define IS_ASIDE_DUTY(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&0x8)
#define IS_HIGH_LEVEL(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&0x20)
#define IS_INVERTED(sNode_ex) ((*reinterpret_cast<xptr_sPwmObj>(&(sNode_ex)))[3]&0x40)
typedef struct sNode{
sPwmObj data;
sNode *next;
sNode(): next(0){};
} sNode;
typedef struct sGcNode{ // exclusively used for stall objects.
//// this struct is a bad trick need improvement; identical fields are must.
unsigned tmp_offset;
unsigned tmp_stop_h_l;
unsigned tmp_period;
sNode *obj;
sGcNode *next;
sGcNode(): obj(0), next(0){};
} sGcNode;
IRAM_ATTR static sNode** node_get_conn_pt(sNode **head){ // get the tail-next address so we can store data in it.
sNode *a=*head;
while (a){
head=&(a->next);
a=a->next;
}
return head;
};
int node_get_length(sNode *head){ // evaluate the linkedlist length
int i=0;
for (; head; i++, head=head->next);
return i;
};
void node_add(sNode **head, sNode *a){ // attach a node to the tail
while (*head) head=&((*head)->next);
*head=a;
};
void node_delete(sNode *head){ // delete entire linkedlist
for (sNode *i; head; i=head->next, freeMemory(head), head=i);
};
IRAM_ATTR static sNode** node_pwm_dec_cnt(sNode **head){ // possibly process several times by caller.
sNode *a=*head;
for (; a && VAL_COUNTER(a->data)>1; OP_COUNTER_DEC(a->data), head=&(a->next), a=a->next); // 1 is minimum.
if (a) return head;
return 0;
};
sNode** node_pwm_find_parent(unsigned id, unsigned pwms_pos){ // find the parent of the node having this id.
sNode **i;
for (i=&(pwms[pwms_pos]); *i && ((*i)->data).id!=id; i=&((*i)->next));
if (!*i) return 0;
return i;
};
IRAM_ATTR static void node_pwm_move_to(sNode **src, unsigned new_pos){ // move this src node to attach to pwms[new_pos].
sNode *obj=*src;
*src=obj->next;
*node_get_conn_pt(&(pwms[new_pos]))=obj;
obj->next=0;
/// priorly excluded.
/// sNode **a=node_get_conn_pt(&(pwms[new_pos]));
/// if (&((*src)->next)!=&((*a)->next)){*a=*src;*src=(*src)->next;(*a)->next=0;}
};
unsigned wellAdd(sNode *a);
bool setStallLevel(bool high_or_low);
void configTimer();
void* getMemory(int obj_size);
void freeMemory(void *b);
bool ack(){
// used for waiting for acked. it is set by isr and read by client code.
// this accepted bit will be repeatedly set,
// so as to get closer between isr and client code.
// client code clear it, and wait it be true and know they are how closer.
// since for example, max period 13s, it probably needs to wait for 13s then acked.
return (owner->data).accepted;
};
void nack(){ // clear the stall state; mainly clear the accepted bit.
// there are 4 candidate bits, but only freeze, stopit bits needed for cleared.
/// [CDPAV]
isr_sneak(); ///
(owner->data).freeze=0; // if pause, the timing will not lose.
(owner->data).stopit=0; // if stop, the timing will lose but it still can be resumed.
// for the renew bit, clear by client demands indirectly, for the aside_duty, setdc to clear.
(owner->data).accepted=0; // no need to delay
};
void resume(){nack();};
void pause(){isr_sneak(); (owner->data).freeze=1; (owner->data).accepted=0;}; // nonblocking
void stop(){isr_sneak(); (owner->data).stopit=1; (owner->data).accepted=0;}; // nonblocking
void renew(){isr_sneak(); (owner->data).is_new_reload=1; (owner->data).accepted=0;}; // nonblocking
void aside_duty(){isr_sneak(); (owner->data).is_aside_duty=1; (owner->data).accepted=0;}; // nonblocking
void de_aside_duty(){isr_sneak(); (owner->data).is_aside_duty=0; (owner->data).accepted=0;}; // nonblocking
void isr_sneak(){ // let client code spin waiting for isr leaved, used for critical data accessing(50us). [CDPAV].
if (!timers[0].isRunning() || stop_all) return;
isr_key=1;
while (isr_key) delayMicroseconds(5); // the delay is must or wdt-reset.
};
static void enter_global_stop();
static void leave_global_stop();
static void enter_global_stop_wait();
static void leave_global_stop_wait();
static cHwTimer timers[4];
static sNode* pwms[4];
static unsigned stop_all; // global stop for PWMs. to avoid conflict.
static unsigned isr_key; // this is the only one way to prevent isr and client code from conflict.
static unsigned gid; // it could be maintained for the purpose of unlimited new/delete, but need more storage.
static sGcNode *memo_park; // for stall objs collection.
sNode *owner;
unsigned period;
unsigned steps; // 0% is not counted. however we need it be a step.
unsigned stop_h_l; // stop at high or low, default is low.
unsigned uid;
public:
void removePwm(){ // there are times when use static objects but need to discard during runtime could call. also could reuse.
if (!owner) return;
waitForStop();
enter_global_stop_wait();
sNode **n=node_pwm_find_parent(uid, (owner->data).tr_high_pos);
if (!n) n=node_pwm_find_parent(uid, (owner->data).tr_low_pos);
if (!n){ // could not happen.
#if C_MULTI_PWMS_DEBUG
printf("\r\nx[MEM]x\r\n");
#endif // C_MULTI_PWMS_DEBUG
leave_global_stop_wait();
return;
}
*n=(*n)->next;
leave_global_stop_wait();
freeMemory(owner);
owner=0;
};
cMultiPwms(): owner(0), uid(0), stop_h_l(0){};
~cMultiPwms(){
removePwm();
};
cMultiPwms(unsigned gpio, unsigned period_us, unsigned set_steps,\
bool inverted=false, bool stop_high=false):\
owner(0), uid(0), stop_h_l(!!stop_high){ // if a step is 1%, use 100 steps, not 101 steps.
configPwm(gpio, period_us, set_steps, inverted, stop_high);
};
cMultiPwms(const cMultiPwms &a): owner(0), uid(0){
// default is GPIO0. the gpio is not copied and must assigned it later.
// also there is not sync for the new object to the existing object.
if (!a.uid) return;
configPwm(MULTIPWMS_GPIO_PARKING, a.period, a.steps, ((a.owner)->data).is_inverted, a.stop_h_l);
};
const cMultiPwms& operator=(const cMultiPwms &b){
if (!b.uid) return *this;
unsigned copy_gpio;
if (this->owner){
copy_gpio=(this->owner->data).gpio;
this->removePwm();
}
else copy_gpio=MULTIPWMS_GPIO_PARKING;
configPwm(copy_gpio, b.period, b.steps, ((b.owner)->data).is_inverted, b.stop_h_l);
return *this;
};
bool configPwm(unsigned gpio, unsigned period_us, unsigned set_steps, bool inverted, bool stop_high);
bool setGpio(unsigned gpio){
if (!owner) return false;
/// [CDPAV]
isr_sneak(); ///
(owner->data).gpio=gpio;
return true;
};
bool setInvert(bool invert_or_not){
if (!owner) return false;
/// [CDPAV]
isr_sneak(); ///
(owner->data).is_inverted=!!invert_or_not;
return true;
};
bool setStopLevel(bool stop_high){ // assign the level when stopped or deallocated.
if (uid){stop_h_l=stop_high; return true;}
return false;
};
bool setDC(float percentage, unsigned set_by_steps=0);
bool setPeriod(unsigned new_period, unsigned new_steps, float percentage, unsigned set_by_steps=0);
// the pause, stop and resume are paired use.
void Pause(){isr_sneak(); (this->owner->data).stall_h_or_l=this->stop_h_l; this->pause();}; // nonblocking
void Stop(){isr_sneak(); (this->owner->data).stall_h_or_l=this->stop_h_l; this->stop();}; // nonblocking
void Resume(){this->resume();};
void waitForStop(){ // spin waiting for stopped to make sure isr has encountered the stop state.
if (!uid || !owner || !timers[0].isRunning()) return;
Stop();
while (!ack()) delayMicroseconds(200);
////delay(2); // if no it, frequently exception(28) wdt-rst(2). i do not know why!!!
};
static void traverseLinkedList();
bool Sync(cMultiPwms &base, unsigned offset_us);
static bool SyncStart(cMultiPwms &base);
static bool SyncNext(cMultiPwms &follower, unsigned offset_us);
static bool SyncEnd(cMultiPwms &base);
static void trigger(sNode **u);
static void timerISR0();
static void timerISR1();
static void timerISR2();
static void timerISR3();
// ===================== supplementary functions, ordinary functions.
static bool Timeout(unsigned ms, unsigned &store_start_time_us, bool one_shot=false, bool one_shot_lasting=false);
unsigned getId() const{return uid;};
bool isAlive() const{return !!owner;};
};
#endif // _c_MULTI_PWMS_H_Esp8266MultiPwms.cpp
// Esp8266MultiPwms.cpp ver.0.7
// https://waterfalls.ddns.net
// by Ken Woo
// 2020.12.23
#include"Esp8266MultiPwms.h"
#if C_MULTI_PWMS_DEBUG
IRAM_ATTR unsigned z1, z2, z3, z4;
IRAM_ATTR unsigned t1, t11, t2, t22, t3, t33, t4, t44, ttt, ttt1;
IRAM_ATTR unsigned w;
IRAM_ATTR int syncoffset_d[16]; // after test, it is more analogy to oscope, so fine ref.
#endif
IRAM_ATTR cHwTimer cMultiPwms::timers[4];
IRAM_ATTR cMultiPwms::sNode* cMultiPwms::pwms[4]={0, 0, 0, 0};
IRAM_ATTR unsigned cMultiPwms::stop_all=0;
IRAM_ATTR unsigned cMultiPwms::isr_key=0;
unsigned cMultiPwms::gid=0;
cMultiPwms::sGcNode* cMultiPwms::memo_park=0;
unsigned cMultiPwms::wellAdd(cMultiPwms::sNode *a){ // add to proper ISR position, return the position.
// considering that, do it while runtime it is not much effective, right.
/// and it is also a sort of critical data potentially access violation([CDPAV]).
/// so, isr_sneak() needs to add, or the global_stop, or none.
/// which one is up to user to rewrite since it concerns about latency and efficiency.
enter_global_stop_wait(); ///
unsigned i=0, j=0, pos=0, min=-1;
for (; i<4; i++){
if (pwms[i]){
if ((j=node_get_length(pwms[i]))<min){
pos=i;
min=j;
}
}
else {pos=i; break;} // empty
}
node_add(&(pwms[pos]), a);
leave_global_stop_wait(); ///
return pos;
}
bool cMultiPwms::setStallLevel(bool high_or_low){
// set the stayed level when freeze, stop, renew, and aside dc, etc.
// default/normally would be low since tasks to do usually at the time of low-ended.
// this function/bit is used when demanded, e.g., stopped at certain level. however,
// set-dc hence ignores this bit.
// note that it will return the prior set state.
/// [CDPAV]
isr_sneak(); ///
bool tmp=!!((owner->data).stall_h_or_l);
(owner->data).stall_h_or_l=!!high_or_low;
return tmp;
}
void cMultiPwms::configTimer(){
timers[0].setTimer(196, cMultiPwms::timerISR0);
timers[1].setTimer(196, cMultiPwms::timerISR1);
timers[2].setTimer(196, cMultiPwms::timerISR2);
timers[3].setTimer(196, cMultiPwms::timerISR3);
timers[1].ForceHaltForSync(timers[0], 49);
timers[2].ForceHaltForSync(timers[1], 49);
timers[3].ForceHaltForSync(timers[2], 49);
}
void* cMultiPwms::getMemory(int obj_size){ // use sizeof(unsigned) and alignment; little endian.
int a=(obj_size+sizeof(unsigned)-1)/sizeof(unsigned);
void *b=malloc(sizeof(unsigned)*a);
if (b && (unsigned(b)/sizeof(unsigned)*sizeof(unsigned)==unsigned(b))){
for (; a--; ((unsigned*)b)[a]=0);
return b;
}
free(b);
return 0;
}
void cMultiPwms::freeMemory(void *b){free(b);}
void cMultiPwms::enter_global_stop(){ // it belongs to nonblocking.
#if C_MULTI_PWMS_DEBUG
static bool halt=0;
while (halt); // it should not happen; if so, check the client code to avoid.
halt=true;
#endif // C_MULTI_PWMS_DEBUG
// ----
delayMicroseconds(75); // since isr int at each 50us. 75us is a prepare time if timer not running-ready.
if (timers[0].isRunning() && !stop_all){
stop_all=1;
delayMicroseconds(25); // wait for isr entered.
int time_cnt=10;
while (stop_all<2 && time_cnt--) delayMicroseconds(25); // no patient to wait
}
else stop_all=2; // specifically for the case timer not running.
// ----
#if C_MULTI_PWMS_DEBUG
halt=false;
#endif // C_MULTI_PWMS_DEBUG
}
void cMultiPwms::leave_global_stop(){
#if C_MULTI_PWMS_DEBUG
static bool halt=0;
while (halt); // it should not happen; if so, check the client code to avoid.
halt=true;
#endif // C_MULTI_PWMS_DEBUG
if (timers[0].isRunning()){
// ---- resume entire isr, which starting from where paused.
switch (stop_all){
case 2: stop_all=6; break;
case 3: stop_all=7; break;
case 4: stop_all=8; break;
case 5: stop_all=9; break;
default: while (1);
}
int time_cnt=10;
while (stop_all && time_cnt--) delayMicroseconds(25); // no patient to wait
// ---- resume entire isr
}
else stop_all=6; // specifically for the case timer not running.
#if C_MULTI_PWMS_DEBUG
halt=false;
#endif // C_MULTI_PWMS_DEBUG
}
void cMultiPwms::enter_global_stop_wait(){ // unfortunately stay and wait is better.
#if C_MULTI_PWMS_DEBUG
static bool halt=0;
while (halt); // it should not happen; if so, check the client code to avoid.
halt=true;
#endif // C_MULTI_PWMS_DEBUG
// ----
if (timers[0].isRunning() && !stop_all){
stop_all=1;
while (stop_all<2) delayMicroseconds(100); // the delay is must or wdt-reset.
}
else stop_all=2; // specifically for the case timer not running.
// ----
#if C_MULTI_PWMS_DEBUG
halt=false;
#endif // C_MULTI_PWMS_DEBUG
}
void cMultiPwms::leave_global_stop_wait(){ // accompanying with enter_global_stop_wait().
#if C_MULTI_PWMS_DEBUG
static bool halt=0;
while (halt); // it should not happen; if so, check the client code to avoid.
halt=true;
#endif // C_MULTI_PWMS_DEBUG
if (timers[0].isRunning()){
// ---- resume entire isr, which starting from where paused.
switch (stop_all){
case 2: stop_all=6; break;
case 3: stop_all=7; break;
case 4: stop_all=8; break;
case 5: stop_all=9; break;
default: while (1);
}
while (stop_all) delayMicroseconds(100);
// ---- resume entire isr
}
else stop_all=6; // specifically for the case timer not running.
#if C_MULTI_PWMS_DEBUG
halt=false;
#endif // C_MULTI_PWMS_DEBUG
}
bool cMultiPwms::configPwm(unsigned gpio, unsigned period_us, unsigned set_steps,\
bool inverted, bool stop_high){ // if a step is 1%, use 100 steps, not 101 steps. this func is only for initiallized use.
if (period_us%200 || !set_steps || period_us%set_steps || period_us/set_steps%50 || period_us>13000000) return false;
if (owner) return false;
owner=(sNode*)getMemory(sizeof(sNode));
if (!owner) return false;
period=period_us;
steps=set_steps;
stop_h_l=stop_high;
if (!uid) uid=++gid;
if (uid>=31){ //// the last one. not fault but is going to fault.
printf("\r\ndepleted\r\n");
freeMemory(owner);
uid=0;
owner=0;
return false;
}
#if C_MULTI_PWMS_DEBUG
printf("\r\npwm object id %d created/recreated, max 31.\r\n", uid);
#endif
(owner->data).id=uid;
(owner->data).is_inverted=!!inverted;
(owner->data).is_high_level=0; // at the outset, it is going to high, so it is under low before beginning.
(owner->data).stall_h_or_l=stop_h_l; // default is 0 unless explicitly specified by setStallLevel within this code.
setGpio(gpio);
(owner->data).accepted=0; // for stall
// ---- fixed at v.0.7 to stop it and fake the parameters which brings the advantage capable of setting sync before pwm running.
// prior bug also at tr_low_pos is 0, etc., in a freezed state.
// since the node is running once wellAdd, however in stopped state parameters are still intact in isr and safe.
(owner->data).stopit=1; // stopped
(owner->data).counter=1; /// 1 rather than 0 might affects sync.
(owner->data).reload_high=(this->period/this->steps/50+3)/4;
(owner->data).reload_low=(this->period/50-this->period/this->steps/50+3)/4;
// ----
(owner->data).tr_high_pos=wellAdd(owner); // at the outset, raise high then immed change pos to tr_low_pos.
// ---- fixed at v.0.7
(owner->data).tr_low_pos=((owner->data).tr_high_pos+this->period/this->steps/50)%4;
// ----
return true;
}
bool cMultiPwms::setDC(float percentage, unsigned set_by_steps){ // will by steps if it is nonzero
// you would see that any PWM would start to work after a setDC is called.
if (!owner) return false;
if (!set_by_steps){
(percentage*=this->steps)/=100.0f;
if ((set_by_steps=unsigned(percentage))<percentage) set_by_steps++;
}
if (set_by_steps>this->steps) set_by_steps=this->steps;
set_by_steps*=this->period/this->steps/50; // times the magnifier to get the native count
// important note that the counting for high, time-up is decided at tr_low_pos, but time starts at tr_high_pos.
// different position means different time, that is the problem.
// integer quotient, 0 remainder, means integer rounds starts from pos and ends at pos.
// remainder if any means the last round that is not a complete round and ends at tr_pos other than pos.
// so, quotient+1 would be the final count.
// however one more to consider, if remainder is 0, expected time-up and count-up are exactly matched at the same pos,
// but what if in such case, we take other position for end? yes, beyond or behind the expected time when count is up.
// so how to do right the code here(tr_high_pos and tr_low_pos are diff pos, could the COUNT handle it all correctly)?
// that is right, nothing to do about this problem since tr_low_pos of its position had taken care, think about it.
// yet the other problem to think about, the boundary condition. when counter becomes 1 which is minimum because
// we either add 1 if remainder or quotient is nonzero/because 0% is excluded, is for tr_low_pos to make decision,
// hence the 1 means time is up; the 1 represents time spent from tr_high_pos to tr_low_pos under a round(equal if same pos).
// however what about the time span for low level at the condition of high level counts is only 1 and high-counts > low-counts?
// it could happen for example period=200us, step=4, dc=25~75%/count-always-1, low should be 0 by calculation.
// as a whole if calculation lead to 0 for low level, our decision making uses >1 in node_pwm_dec_cnt could cover each condition,
// that is, time spent is correct.
if (!set_by_steps){ // 0%
setStallLevel((owner->data).is_inverted); // set it stall at low
aside_duty();
set_by_steps=this->period/this->steps/50; // fake it to be duty low long enough.
}
else if (set_by_steps==this->period/50){ // 100%
setStallLevel(!(owner->data).is_inverted); // set it stall at high
aside_duty();
set_by_steps=this->period/this->steps/50; // fake it to be duty low long enough.
}
else de_aside_duty();
int pos=(owner->data).tr_high_pos;
int tr_pos=set_by_steps%4;
// considering the count,
// since encountering the count either 0 or 1 represents count-up,
// so if quotient is 1, means needs at least a round, which by this cases,
// if no remainder, quotient is the result, fitted.
// if remainder(needs a round and a few advances<4),
// add one up is the result as also fits the case if quotient 0,
// because quotient 0 and 1 are the same just mention above.
int count=set_by_steps/4;
if (!tr_pos) tr_pos=pos;
else {
count++;
tr_pos+=pos;
if (tr_pos>3) tr_pos-=4;
}
while ((owner->data).is_new_reload) delayMicroseconds(this->period/this->steps); // let previous committed.
unsigned tmp1=(this->period/50-set_by_steps+3)/4;
isr_sneak(); // the bug fixed at v.0.6. it is needed or data access violation could happen. [CDPAV].
(owner->data).n_tr_low_pos=tr_pos; // this is the "duty-cycle count" cast into "tr_low_pos".
(owner->data).n_reload_high=count;
////(owner->data).n_reload_low=period/200-count;
// it is the time counted by tr_high_pos, but time start of the counting is at tr_low_pos,
// so, the native counts is the time for level-low counted by tr_high_pos and must base
// on the relative position between tr_high_pos and tr_low_pos.
// one certain condition is the native counts certainly end up at tr_high_pos.
// another certainly that position of tr_high and tr_low are within 4 which as the remainder.
// add one up if remainder holds such conditions.
(owner->data).n_reload_low=tmp1;
renew();
// priorly we did not stall however we still need resume for new object.
Resume();
if (!timers[0].isActive()) configTimer();
return true;
}
bool cMultiPwms::setPeriod(unsigned new_period, unsigned new_steps, float percentage, unsigned set_by_steps){ // will by steps if it is nonzero
// for simplicity, user should reassign the current duty cycle, new one is fine.
// you would see that any PWM would start to work after a setPeriod is called.
if (!uid || !owner || (this->steps==new_steps) && (new_period==this->period)) return false;
if (new_period%200 || !new_steps || new_period%new_steps || new_period/new_steps%50 || new_period>13000000) return false;
this->period=new_period;
this->steps=new_steps;
if (!set_by_steps){
(percentage*=this->steps)/=100.0f;
if ((set_by_steps=unsigned(percentage))<percentage) set_by_steps++;
}
if (set_by_steps>this->steps) set_by_steps=this->steps;
set_by_steps*=this->period/this->steps/50; // times the magnifier to get the native count
if (!set_by_steps){ // 0%
setStallLevel((owner->data).is_inverted); // set it stall at low
aside_duty();
set_by_steps=this->period/this->steps/50; // fake it to be duty low long enough.
}
else if (set_by_steps==this->period/50){ // 100%
setStallLevel(!(owner->data).is_inverted); // set it stall at high
aside_duty();
set_by_steps=this->period/this->steps/50; // fake it to be duty low long enough.
}
else de_aside_duty();
int pos=(owner->data).tr_high_pos;
int tr_pos=set_by_steps%4;
int count=set_by_steps/4;
if (!tr_pos) tr_pos=pos;
else {
count++;
tr_pos+=pos;
if (tr_pos>3) tr_pos-=4;
}
while ((owner->data).is_new_reload) delayMicroseconds(this->period/this->steps); // let previous committed.
unsigned tmp1=(this->period/50-set_by_steps+3)/4;
isr_sneak(); // the bug fixed at v.0.6. it is needed or data access violation could happen. [CDPAV].
(owner->data).n_tr_low_pos=tr_pos; // this is the "duty-cycle count" cast into "tr_low_pos".
(owner->data).n_reload_high=count;
(owner->data).n_reload_low=tmp1;
renew();
// priorly we did not stall however we still need resume for new object.
Resume();
if (!timers[0].isActive()) configTimer();
return true;
}
void cMultiPwms::traverseLinkedList(){
#if C_MULTI_PWMS_DEBUG
int c=0;
#if MULTIPWMS_PREVENT_WDT_RESET
enter_global_stop_wait(); // if so, waveform not consecutive.
printf("\r\n[counter pos=%d]\r\n", stop_all-2);
#endif // MULTIPWMS_PREVENT_WDT_RESET
for (int i=0; i<4; i++){
sNode *a=pwms[i];
while (a){ // might failed/wdt-reset if some object is moving. instead, could use stop_all then print.
printf("id, gpio, level, tr_high_pos, tr_low_pos, rld_high, rld_low, counter,\r\n\
(%d, %d, %d, % 2d, % 2d, %d, %d, %d)\r\n",\
(*a).data.id,\
(*a).data.gpio,\
(*a).data.is_high_level,\
(*a).data.tr_high_pos,\
(*a).data.tr_low_pos,\
(*a).data.reload_high,\
(*a).data.reload_low,\
(*a).data.counter);
a=a->next;
c++;
}
printf("(%d) ----\r\n", i);
}
#if MULTIPWMS_PREVENT_WDT_RESET
leave_global_stop_wait();
#endif // MULTIPWMS_PREVENT_WDT_RESET
printf("the [sync offset]:\r\n");
printf("[%d][%d][%d][%d]\r\n", 0, syncoffset_d[1], syncoffset_d[2], syncoffset_d[3]);
printf("[%d][%d][%d][%d]\r\n", syncoffset_d[4], syncoffset_d[5], syncoffset_d[6], syncoffset_d[7]);
printf("[%d][%d][%d][%d]\r\n", syncoffset_d[8], syncoffset_d[9], syncoffset_d[10], syncoffset_d[11]);
printf("[%d][%d][%d][%d]\r\n", syncoffset_d[12], syncoffset_d[13], syncoffset_d[14], syncoffset_d[15]);
printf("ISR lost(%u/%u). The 4 ISRs (%d nodes in it) each costs us time (%d %d %d %d)\r\n\r\n\r\n",\
ttt, ttt1, c, z1, z2, z3, z4);
#endif // C_MULTI_PWMS_DEBUG
}
bool cMultiPwms::Sync(cMultiPwms &base, unsigned offset_us){ // must at least a setDC call before sync.
// the most important note that, this is a relatively sync, which means the two sync here,
// will deviate from other waveforms since we use stall here.
// if more than 2 pwms need to sync, instead to use SyncStart, SyncNext, SyncEnd of a static process;
// also they not only deviate from the others but also stalled till call SyncEnd().
//
// think about we want to synchronize to the base, head(h-level) to head(h-level) or an offset of head to head.
// what if an offset of l-level-head? my conclusion is not necessary because low-level will change by dc,
// we can set inverse-dc then invert for the purpose after synced.
if (!uid || !base.uid || (uid==base.uid) || !owner || !base.owner) return false;
if ((period!=base.period) || (period<=offset_us) || offset_us%50) return false;
offset_us/=50; // note that one count is 50us for native count.
// stop 2 nodes in isr for they are in the transition state, to high.
base.waitForStop();
this->waitForStop();
enter_global_stop_wait();
unsigned a=((base.owner)->data).tr_high_pos;
unsigned old_pos=(owner->data).tr_high_pos;
unsigned b=(owner->data).tr_high_pos=(a+offset_us)%4;
if (b!=old_pos) node_pwm_move_to(node_pwm_find_parent(this->uid, old_pos), b);
//// ---- at v.0.6. bug fixed.
//// (owner->data).tr_low_pos=((owner->data).tr_low_pos+offset_us)%4;
////
//// the low-position and counter calculations are wrong since at setDC(), the complete calculation of parameters,
//// which are fine-adjusted. here should do so too.
//// therefore let to get the dc first then recalculate.
unsigned dc=(owner->data).reload_high;
unsigned low_pos=(owner->data).tr_low_pos;
if (low_pos!=old_pos) dc--;
dc<<=2;
if (old_pos>low_pos) low_pos+=4;
dc+=(low_pos-old_pos);
low_pos=dc%4;
unsigned count=dc/4;
if (!low_pos) low_pos=b;
else {
count++;
low_pos+=b;
if (low_pos>3) low_pos-=4;
}
(owner->data).reload_high=count; // the new reload_high
(owner->data).reload_low=(this->period/50-dc+3)/4; // the new reload_low
(owner->data).tr_low_pos=low_pos; // the new tr_low_pos
//// ----
(owner->data).counter=((base.owner)->data).counter+offset_us/4; // counter beyond and behind and mid?
// fix the problem that isr position could affect counter value.
unsigned c=stop_all-2;
if ((a<b && c<=b && c>a) || (b<a && c<=b) || (b<a && c>a)) (owner->data).counter++;
// resume 2 nodes in isr
base.Resume();
this->Resume();
// resume entire isr
leave_global_stop_wait();
return true;
}
bool cMultiPwms::SyncStart(cMultiPwms &base){ // note that if no SyncEnd, there will be a memory leak.
if (!base.uid || !base.owner || memo_park) return false;
memo_park=(sGcNode*)base.getMemory(sizeof(sGcNode));
if (!memo_park) return false;
memo_park->tmp_offset=0; // store offset, native count
memo_park->tmp_stop_h_l=base.stop_h_l; // store stop state
memo_park->tmp_period=base.period; // store period
memo_park->obj=base.owner; // store node address
memo_park->next=0; // store next sGcNode address
return true;
}
bool cMultiPwms::SyncNext(cMultiPwms &follower, unsigned offset_us){
if (!follower.uid || !follower.owner) return false;
if ((follower.period<=offset_us) || offset_us%50) return false;
if (!memo_park) return false;
sGcNode *a=(sGcNode*)follower.getMemory(sizeof(sGcNode));
if (!a) return false;
a->tmp_offset=offset_us/50;
a->tmp_stop_h_l=follower.stop_h_l;
a->tmp_period=follower.period;
a->obj=follower.owner;
a->next=0;
follower.node_add((sNode**)(&memo_park), (sNode*)(a));
return true;
}
bool cMultiPwms::SyncEnd(cMultiPwms &base){ // must specify the base actually for me to use non-static funcs.
if (!base.uid || !base.owner || !memo_park) return false;
int len=base.node_get_length((sNode*)(memo_park));
if (memo_park->obj!=base.owner) return false; // still chances
if (len==1){ // no chance
base.node_delete((sNode*)(memo_park));
memo_park=0;
return true; // should return false or true?
}
for (sGcNode *iter1=memo_park; iter1; iter1=iter1->next){
// stop each node ensuring it stays at cycle-end.
base.isr_sneak();
(iter1->obj->data).stall_h_or_l=iter1->tmp_stop_h_l; // set stopped level state.
(iter1->obj->data).stopit=1;
(iter1->obj->data).accepted=0;
if (timers[0].isRunning()) do delayMicroseconds(200); while (!(iter1->obj->data).accepted);
////delay(2); // if no it, frequently exception(28) wdt-rst(2). i do not know why!!! again, must have!
}
// stall entire isr
base.enter_global_stop_wait();
unsigned a=(memo_park->obj->data).tr_high_pos;
unsigned e=(memo_park->obj->data).counter;
// resume first first; it is ok since all nodes global stopped.
(memo_park->obj->data).freeze=0;
(memo_park->obj->data).stopit=0;
(memo_park->obj->data).accepted=0;
for (sGcNode *iter=memo_park->next; iter; iter=iter->next){
unsigned old_pos=(iter->obj->data).tr_high_pos;
unsigned b=(iter->obj->data).tr_high_pos=(a+iter->tmp_offset)%4;
if (b!=old_pos) node_pwm_move_to(base.node_pwm_find_parent((iter->obj->data).id, old_pos), b);
//// ---- at v.0.6. bug fixed.
//// (iter->obj->data).tr_low_pos=((iter->obj->data).tr_low_pos+iter->tmp_offset)%4;
////
//// the low-position and counter calculations are wrong since at setDC(), the complete calculation of parameters,
//// which are fine-adjusted. here should do so too.
//// therefore let to get the dc first then recalculate.
unsigned dc=(iter->obj->data).reload_high;
unsigned low_pos=(iter->obj->data).tr_low_pos;
if (low_pos!=old_pos) dc--;
dc<<=2;
if (old_pos>low_pos) low_pos+=4;
dc+=(low_pos-old_pos);
low_pos=dc%4;
unsigned count=dc/4;
if (!low_pos) low_pos=b;
else {
count++;
low_pos+=b;
if (low_pos>3) low_pos-=4;
}
(iter->obj->data).reload_high=count; // the new reload_high
(iter->obj->data).reload_low=(iter->tmp_period/50-dc+3)/4; // the new reload_low
(iter->obj->data).tr_low_pos=low_pos; // the new tr_low_pos
//// ----
(iter->obj->data).counter=e+iter->tmp_offset/4;
// fix the problem that isr position could affect counter value.
unsigned c=stop_all-2;
if ((a<b && c<=b && c>a) || (b<a && c<=b) || (b<a && c>a)) (iter->obj->data).counter++;
// resume
(iter->obj->data).freeze=0;
(iter->obj->data).stopit=0;
(iter->obj->data).accepted=0;
}
// resume entire isr
base.leave_global_stop_wait();
base.node_delete((sNode*)(memo_park));
memo_park=0;
return true;
}
IRAM_ATTR void cMultiPwms::trigger(cMultiPwms::sNode **u){
while (u=node_pwm_dec_cnt(u)){ // when true, count is up, time to transition.
/// probably might improve by using an unsigned to cap the u and refresh at the end.
if (IS_HIGH_LEVEL((*u)->data)){ // now high, if going to low counting.
// right here is at the end of high level,
// it is the right time for us to do something or change something.
if (IS_NEED_LOOKINTO((*u)->data)){ // it means this is at the stall.
// for the stall issued, we have some tasks to do,
// in such cases the waveform could stopped or still running.
// so, here inside, no waveform, unless explicitly do toggling if required.
// but most cases, reload and level-data alternating have to do in order to keep sync timing.
// another important note that, leave away without do something, it will enter again only this level-end.
// same is the other level-end.
if (!IS_ASIDE_DUTY((*u)->data)) digitalWrite(OP_GET_GPIO((*u)->data), IS_INVERTED((*u)->data));
}
else digitalWrite(OP_GET_GPIO((*u)->data), IS_INVERTED((*u)->data));
OP_SET_LVL_LOW((*u)->data);
OP_RLD_LOW((*u)->data);
if (OP_GET_TR_HIGH_POS((*u)->data)!=OP_GET_TR_LOW_POS((*u)->data))
node_pwm_move_to(u, OP_GET_TR_HIGH_POS((*u)->data));
else u=&((*u)->next);
}
else { // now low, if going to high counting; also, the end of a finished cycle.
if (IS_NEED_LOOKINTO((*u)->data)){
if (IS_RLD_NEW((*u)->data)){ // set-dc ignores setting the level.
OP_RLD_NEWHIGH((*u)->data);
OP_RLD_NEWLOW((*u)->data);
OP_RLD_NEWTRLOWPOS_C((*u)->data);
///digitalWrite(OP_GET_GPIO((*u)->data), !IS_INVERTED((*u)->data));///
OP_DO_ACCEPT((*u)->data); ////// not use this to prevent from reentering this block after continue.
continue;
}
else digitalWrite(OP_GET_GPIO((*u)->data), OP_GET_STALL_LVL((*u)->data));
if (IS_STOP((*u)->data)){ // skip this one, no state changes.
OP_DO_ACCEPT((*u)->data);
u=&((*u)->next);
continue;
}
///// else if (IS_FREEZE((*u)->data));
///// else if (IS_ASIDE_DUTY((*u)->data));
OP_DO_ACCEPT((*u)->data);
}
else digitalWrite(OP_GET_GPIO((*u)->data), !IS_INVERTED((*u)->data));
OP_SET_LVL_HIGH((*u)->data);
OP_RLD_HIGH((*u)->data);
#if C_MULTI_PWMS_DEBUG
w=micros();
if (((*u)->data).id==1) syncoffset_d[0]=w;
else syncoffset_d[((*u)->data).id-1]=w-syncoffset_d[0];
#endif // C_MULTI_PWMS_DEBUG
if (OP_GET_TR_HIGH_POS((*u)->data)!=OP_GET_TR_LOW_POS((*u)->data))
node_pwm_move_to(u, OP_GET_TR_LOW_POS((*u)->data));
else u=&((*u)->next);
}
}
isr_key=0; // extermely note that, in client code, if access critical data, violation did happen.
// so, must use this facility isr_sneak() if potential violations exist.
}
#if !C_MULTI_PWMS_DEBUG
IRAM_ATTR void cMultiPwms::timerISR0(){
if (!stop_all) trigger(&(pwms[0]));
else if (stop_all==1){ // do what to do as follows when stop all.
// stop_all is 1 set by user, means every isr can ack it into 2~5 and stopped, such that where stopped is known.
// moreover stop_all could be set 6~9 by user means only isr0~3 can ack it and reset it and be the first one in.
// the timing would be affected when use such a method however fine than nothing could do.
// stop_all is 2~5 to ack back to user.
// care must be taken where the stop_all were used whether or not possibly temporally lead to conflict!
// note that a stop_all penality is 200us*n.
stop_all=2;
}
else if (stop_all==6){ // 6cue isr0
stop_all=0;
trigger(&(pwms[0]));
}
}
IRAM_ATTR void cMultiPwms::timerISR1(){
if (!stop_all) trigger(&(pwms[1]));
else if (stop_all==1){
stop_all=3;
}
else if (stop_all==7){ // 7cue isr1
stop_all=0;
trigger(&(pwms[1]));
}
}
IRAM_ATTR void cMultiPwms::timerISR2(){
if (!stop_all) trigger(&(pwms[2]));
else if (stop_all==1){
stop_all=4;
}
else if (stop_all==8){ // 8cue isr2
stop_all=0;
trigger(&(pwms[2]));
}
}
IRAM_ATTR void cMultiPwms::timerISR3(){
if (!stop_all) trigger(&(pwms[3]));
else if (stop_all==1){
stop_all=5;
}
else if (stop_all==9){ // 9cue isr3
stop_all=0;
trigger(&(pwms[3]));
}
}
#else // C_MULTI_PWMS_DEBUG
IRAM_ATTR void cMultiPwms::timerISR0(){
static int x;
x=micros(); ttt1++; t1=x; if ((t1-=t44)<24 || t1>72) ttt++;
if (!stop_all) trigger(&(pwms[0]));
else if (stop_all==1){
stop_all=2;
}
else if (stop_all==6){ // 6cue isr0
stop_all=0;
trigger(&(pwms[0]));
}
z1=(t11=micros())-x;
}
IRAM_ATTR void cMultiPwms::timerISR1(){
static int x;
x=micros(); ttt1++; t2=x; if ((t2-=t11)<24 || t2>72) ttt++;
if (!stop_all) trigger(&(pwms[1]));
else if (stop_all==1){
stop_all=3;
}
else if (stop_all==7){ // 7cue isr1
stop_all=0;
trigger(&(pwms[1]));
}
z2=(t22=micros())-x;
}
IRAM_ATTR void cMultiPwms::timerISR2(){
static int x;
x=micros(); ttt1++; t3=x; if ((t3-=t22)<24 || t3>72) ttt++;
if (!stop_all) trigger(&(pwms[2]));
else if (stop_all==1){
stop_all=4;
}
else if (stop_all==8){ // 8cue isr2
stop_all=0;
trigger(&(pwms[2]));
}
z3=(t33=micros())-x;
}
IRAM_ATTR void cMultiPwms::timerISR3(){
static int x;
x=micros(); ttt1++; t4=x; if ((t4-=t33)<24 || t4>72) ttt++;
if (!stop_all) trigger(&(pwms[3]));
else if (stop_all==1){
stop_all=5;
}
else if (stop_all==9){ // 9cue isr3
stop_all=0;
trigger(&(pwms[3]));
}
z4=(t44=micros())-x;
}
#endif // !C_MULTI_PWMS_DEBUG
// ===================== supplementary functions, ordinary functions.
bool cMultiPwms::Timeout(unsigned ms, unsigned &store_start_time_us, bool one_shot, bool one_shot_lasting){
if (one_shot && !store_start_time_us) return one_shot_lasting;
if (micros()>=(ms*1000+store_start_time_us)){
store_start_time_us=one_shot? 0: micros();
return true;
}
return false;
}