vansinba
diff --git a/‎README.md
Lines changed: 1 addition & 1 deletion b/‎README.md
Lines changed: 1 addition & 1 deletion
diff --git a/‎cores/esp32/esp32-hal-sd.c renamed to ‎cores/esp32/esp32-hal-sigmadelta.c
Lines changed: 15 additions & 15 deletions b/‎cores/esp32/esp32-hal-sd.c renamed to ‎cores/esp32/esp32-hal-sigmadelta.c
Lines changed: 15 additions & 15 deletions
diff --git a/‎cores/esp32/esp32-hal-sd.h renamed to ‎cores/esp32/esp32-hal-sigmadelta.h b/‎cores/esp32/esp32-hal-sd.h renamed to ‎cores/esp32/esp32-hal-sigmadelta.h
diff --git a/‎cores/esp32/esp32-hal.h
Lines changed: 1 addition & 1 deletion b/‎cores/esp32/esp32-hal.h
Lines changed: 1 addition & 1 deletion
@@ -16,7 +16,7 @@
 ## Development Status
 Most of the framework is implemented. Most noticable is the missing analogWrite. While analogWrite is on it's way, there are a few other options that you can use:
 - 16 channels [LEDC](https://github.com/espressif/arduino-esp32/blob/master/cores/esp32/esp32-hal-ledc.h) which is PWM
-- 8 channels [SigmaDelta](https://github.com/espressif/arduino-esp32/blob/master/cores/esp32/esp32-hal-sd.h) which uses SigmaDelta modulation
+- 8 channels [SigmaDelta](https://github.com/espressif/arduino-esp32/blob/master/cores/esp32/esp32-hal-sigmadelta.h) which uses SigmaDelta modulation
 - 2 channels [DAC](https://github.com/espressif/arduino-esp32/blob/master/cores/esp32/esp32-hal-dac.h) which gives real analog output
 
 ## Installation Instructions
 
@@ -31,53 +31,53 @@
 xSemaphoreHandle _sd_sys_lock;
 #endif
 
-uint32_t sdSetup(uint8_t channel, uint32_t freq) //chan 0-7 freq 1220-312500
+uint32_t sigmaDeltaSetup(uint8_t channel, uint32_t freq) //chan 0-7 freq 1220-312500
 {
     if(channel > 7) {
         return 0;
     }
+#if !CONFIG_DISABLE_HAL_LOCKS
     static bool tHasStarted = false;
     if(!tHasStarted) {
         tHasStarted = true;
-#if !CONFIG_DISABLE_HAL_LOCKS
         _sd_sys_lock = xSemaphoreCreateMutex();
-#endif
     }
-    gpio_sd_dev_t * gpio_sd_dev = (volatile gpio_sd_dev_t *)(DR_REG_GPIO_SD_BASE);
+#endif
     uint32_t prescale = (10000000/(freq*32)) - 1;
     if(prescale > 0xFF) {
         prescale = 0xFF;
     }
     SD_MUTEX_LOCK();
-    gpio_sd_dev->channel[channel].prescale = prescale;
-    gpio_sd_dev->cg.clk_en = 0;
-    gpio_sd_dev->cg.clk_en = 1;
+    SIGMADELTA.channel[channel].prescale = prescale;
+    SIGMADELTA.cg.clk_en = 0;
+    SIGMADELTA.cg.clk_en = 1;
     SD_MUTEX_UNLOCK();
     return 10000000/((prescale + 1) * 32);
 }
 
-void sdWrite(uint8_t channel, uint8_t duty) //chan 0-7 duty 8 bit
+void sigmaDeltaWrite(uint8_t channel, uint8_t duty) //chan 0-7 duty 8 bit
 {
     if(channel > 7) {
         return;
     }
     duty += 128;
-    gpio_sd_dev_t * gpio_sd_dev = (volatile gpio_sd_dev_t *)(DR_REG_GPIO_SD_BASE);
     SD_MUTEX_LOCK();
-    gpio_sd_dev->channel[channel].duty = duty;
+    SIGMADELTA.channel[channel].duty = duty;
     SD_MUTEX_UNLOCK();
 }
 
-uint8_t sdRead(uint8_t channel) //chan 0-7
+uint8_t sigmaDeltaRead(uint8_t channel) //chan 0-7
 {
     if(channel > 7) {
         return 0;
     }
-    gpio_sd_dev_t * gpio_sd_dev = (volatile gpio_sd_dev_t *)(DR_REG_GPIO_SD_BASE);
-    return gpio_sd_dev->channel[channel].duty - 128;
+    SD_MUTEX_LOCK();
+    uint8_t duty = SIGMADELTA.channel[channel].duty - 128;
+    SD_MUTEX_UNLOCK();
+    return duty;
 }
 
-void sdAttachPin(uint8_t pin, uint8_t channel) //channel 0-7
+void sigmaDeltaAttachPin(uint8_t pin, uint8_t channel) //channel 0-7
 {
     if(channel > 7) {
         return;
@@ -86,7 +86,7 @@ void sdAttachPin(uint8_t pin, uint8_t channel) //channel 0-7
     pinMatrixOutAttach(pin, GPIO_SD0_OUT_IDX + channel, false, false);
 }
 
-void sdDetachPin(uint8_t pin)
+void sigmaDeltaDetachPin(uint8_t pin)
 {
     pinMatrixOutDetach(pin, false, false);
 }
@@ -56,7 +56,7 @@ void vPortYield( void );
 #include "esp32-hal-spi.h"
 #include "esp32-hal-i2c.h"
 #include "esp32-hal-ledc.h"
-#include "esp32-hal-sd.h"
+#include "esp32-hal-sigmadelta.h"
 #include "esp32-hal-timer.h"
 #include "esp_system.h"
Original file line number	Diff line number	Diff line change
`@@ -31,53 +31,53 @@`
`31`	`31`	`xSemaphoreHandle _sd_sys_lock;`
`32`	`32`	`#endif`
`33`	`33`
`34`		`-uint32_t sdSetup(uint8_t channel, uint32_t freq) //chan 0-7 freq 1220-312500`
	`34`	`+uint32_t sigmaDeltaSetup(uint8_t channel, uint32_t freq) //chan 0-7 freq 1220-312500`
`35`	`35`	`{`
`36`	`36`	`if(channel > 7) {`
`37`	`37`	`return 0;`
`38`	`38`	`}`
	`39`	`+#if !CONFIG_DISABLE_HAL_LOCKS`
`39`	`40`	`static bool tHasStarted = false;`
`40`	`41`	`if(!tHasStarted) {`
`41`	`42`	`tHasStarted = true;`
`42`		`-#if !CONFIG_DISABLE_HAL_LOCKS`
`43`	`43`	`_sd_sys_lock = xSemaphoreCreateMutex();`
`44`		`-#endif`
`45`	`44`	`}`
`46`		`- gpio_sd_dev_t * gpio_sd_dev = (volatile gpio_sd_dev_t *)(DR_REG_GPIO_SD_BASE);`
	`45`	`+#endif`
`47`	`46`	`uint32_t prescale = (10000000/(freq*32)) - 1;`
`48`	`47`	`if(prescale > 0xFF) {`
`49`	`48`	`prescale = 0xFF;`
`50`	`49`	`}`
`51`	`50`	`SD_MUTEX_LOCK();`
`52`		`- gpio_sd_dev->channel[channel].prescale = prescale;`
`53`		`- gpio_sd_dev->cg.clk_en = 0;`
`54`		`- gpio_sd_dev->cg.clk_en = 1;`
	`51`	`+ SIGMADELTA.channel[channel].prescale = prescale;`
	`52`	`+ SIGMADELTA.cg.clk_en = 0;`
	`53`	`+ SIGMADELTA.cg.clk_en = 1;`
`55`	`54`	`SD_MUTEX_UNLOCK();`
`56`	`55`	`return 10000000/((prescale + 1) * 32);`
`57`	`56`	`}`
`58`	`57`
`59`		`-void sdWrite(uint8_t channel, uint8_t duty) //chan 0-7 duty 8 bit`
	`58`	`+void sigmaDeltaWrite(uint8_t channel, uint8_t duty) //chan 0-7 duty 8 bit`
`60`	`59`	`{`
`61`	`60`	`if(channel > 7) {`
`62`	`61`	`return;`
`63`	`62`	`}`
`64`	`63`	`duty += 128;`
`65`		`- gpio_sd_dev_t * gpio_sd_dev = (volatile gpio_sd_dev_t *)(DR_REG_GPIO_SD_BASE);`
`66`	`64`	`SD_MUTEX_LOCK();`
`67`		`- gpio_sd_dev->channel[channel].duty = duty;`
	`65`	`+ SIGMADELTA.channel[channel].duty = duty;`
`68`	`66`	`SD_MUTEX_UNLOCK();`
`69`	`67`	`}`
`70`	`68`
`71`		`-uint8_t sdRead(uint8_t channel) //chan 0-7`
	`69`	`+uint8_t sigmaDeltaRead(uint8_t channel) //chan 0-7`
`72`	`70`	`{`
`73`	`71`	`if(channel > 7) {`
`74`	`72`	`return 0;`
`75`	`73`	`}`
`76`		`- gpio_sd_dev_t * gpio_sd_dev = (volatile gpio_sd_dev_t *)(DR_REG_GPIO_SD_BASE);`
`77`		`- return gpio_sd_dev->channel[channel].duty - 128;`
	`74`	`+ SD_MUTEX_LOCK();`
	`75`	`+ uint8_t duty = SIGMADELTA.channel[channel].duty - 128;`
	`76`	`+ SD_MUTEX_UNLOCK();`
	`77`	`+ return duty;`
`78`	`78`	`}`
`79`	`79`
`80`		`-void sdAttachPin(uint8_t pin, uint8_t channel) //channel 0-7`
	`80`	`+void sigmaDeltaAttachPin(uint8_t pin, uint8_t channel) //channel 0-7`
`81`	`81`	`{`
`82`	`82`	`if(channel > 7) {`
`83`	`83`	`return;`
`@@ -86,7 +86,7 @@ void sdAttachPin(uint8_t pin, uint8_t channel) //channel 0-7`
`86`	`86`	`pinMatrixOutAttach(pin, GPIO_SD0_OUT_IDX + channel, false, false);`
`87`	`87`	`}`
`88`	`88`
`89`		`-void sdDetachPin(uint8_t pin)`
	`89`	`+void sigmaDeltaDetachPin(uint8_t pin)`
`90`	`90`	`{`
`91`	`91`	`pinMatrixOutDetach(pin, false, false);`
`92`	`92`	`}`