Sigma-delta support

[Jsolo1]

#define fanpwm 15
#include "sigma_delta.h"

void setup() {
  pinMode(fanpwm, OUTPUT);
  // put your setup code here, to run once:
sigma_delta_setup(PERIPHS_IO_MUX_MTDI_U,fanpwm,FUNC_GPIO15);
set_sigma_duty_312KHz(2);

}

void loop() {
  // put your main code here, to run repeatedly:

}

### Debug Messages

error: 'sigma_delta_setup' was not declared in this scope

Things I've done:

Removed the extension ".unused" and the file seems working now
Redeclared the functions, specially the "sigma_delta_setup" which is completely undeclared in the header file
Include the header file in the sketch:

extern "C"{
#include "sigma_delta.h"
} 

But I don't have any output in the pin, what can it be the problem?

[igrr]

Sorry, i don't think that sigma_delta was ever tested/supported, which is why it has .unused extension. I'm actually surprised it was checked into git, I must have done that by accident.

If you can get it to work, then a PR with the necessary changes would certainly be appreciated.

[Jsolo1]

Ok.

I found the following link: http://bbs.espressif.com/viewtopic.php?t=49
And I just copied the sigma_delta.c file as follows, i found the frequency definition equation was wrong:

/*
/******************************************************************************
 * MODULEName : set_sigma MODULE

EACH PIN CAN CONNET TO A SIGMA-DELTA , ALL PINS SHEARS THE SAME SIGMA-DELTA SOURCE.

THE TARGET DUTY AND FREQUENCY CAN BE MODIFIED VIA THE REG ADDR GPIO_SIGMA_DELTA

THE TARGET FREQUENCY IS DEFINED AS:

FREQ = 80,000,000/((prescale / target) * 256  HZ),     0<target<128
FREQ = 80,000,000/((prescale / (256-target)) * 256  HZ),     128<target<256
target: duty ,0-255
prescale: clk_div,0-255
so the target and prescale will both affect the freq.


YOU CAN DO THE TEST LIKE THIS:
1. INIT :  sigma_delta_setup(PERIPHS_IO_MUX_MTDI_U,12,FUNC_GPIO12);
2. USE 312K:   set_sigma_duty_312KHz(2);
OR 2. SET VAL:  set_sigma_target(uint8 target) AND  set_sigma_prescale

3. DEINIT AND DISABLE: sigma_delta_close(uint32 GPIO_NUM), eg.sigma_delta_close(2)

*******************************************************************************/



#include "osapi.h"
#include "c_types.h"
#include "ets_sys.h"
#include "eagle_soc.h"
#include "gpio.h"
//#include "esp8266.h"


//uint32 GPIO_SIGMA_DELTA_NUM=0x68;

#define GPIO_SIGMA_DELTA_NUM  0x68
 // modify for pin

#define GPIO_SIGMA_DELTA      0x68  //defined in gpio register.xls


#define   PERIPHS_GPIO_BASEADDR   0x60000300
#define GPIO_PIN_ADDR(i)    (GPIO_PIN0_ADDRESS + i*4)
#define GPIO_SIGMA_DELTA_ADDRESS   (PERIPHS_GPIO_BASEADDR + 0x68)  //defined in gpio register.xls


#define GPIO_SIGMA_DELTA_SETTING_MASK  (0x00000001ff)

#define GPIO_SIGMA_DELTA_ENABLE  1
#define GPIO_SIGMA_DELTA_DISABLE   (~GPIO_SIGMA_DELTA_ENABLE)
#define GPIO_SIGMA_DELTA_MSB                     16
#define GPIO_SIGMA_DELTA_LSB                      16
#define GPIO_SIGMA_DELTA_MASK                  (0x00000001<<GPIO_SIGMA_DELTA_LSB)
#define GPIO_SIGMA_DELTA_GET(x)                 (((x) & GPIO_SIGMA_DELTA_MASK) >> GPIO_SIGMA_DELTA_LSB)
#define GPIO_SIGMA_DELTA_SET(x)                  (((x) << GPIO_SIGMA_DELTA_LSB) & GPIO_SIGMA_DELTA_MASK)


#define GPIO_SIGMA_DELTA_TARGET_MSB  7
#define GPIO_SIGMA_DELTA_TARGET_LSB  0
#define GPIO_SIGMA_DELTA_TARGET_MASK                  (0x000000FF<<GPIO_SIGMA_DELTA_TARGET_LSB)
#define GPIO_SIGMA_DELTA_TARGET_GET(x)                 (((x) & GPIO_SIGMA_DELTA_TARGET_MASK) >> GPIO_SIGMA_DELTA_TARGET_LSB)
#define GPIO_SIGMA_DELTA_TARGET_SET(x)                  (((x) << GPIO_SIGMA_DELTA_TARGET_LSB) & GPIO_SIGMA_DELTA_TARGET_MASK)


#define GPIO_SIGMA_DELTA_PRESCALE_MSB  15
#define GPIO_SIGMA_DELTA_PRESCALE_LSB  8
#define GPIO_SIGMA_DELTA_PRESCALE_MASK  (0x000000FF<<GPIO_SIGMA_DELTA_PRESCALE_LSB)
#define GPIO_SIGMA_DELTA_PRESCALE_GET(x)                 (((x) & GPIO_SIGMA_DELTA_PRESCALE_MASK) >> GPIO_SIGMA_DELTA_PRESCALE_LSB)
#define GPIO_SIGMA_DELTA_PRESCALE_SET(x)                  (((x) << GPIO_SIGMA_DELTA_PRESCALE_LSB) & GPIO_SIGMA_DELTA_PRESCALE_MASK)


/******************************************************************************
 * FunctionName : sigma_delta_setup
 * Description  : Init Pin Config for Sigma_delta , change pin source to sigma-delta
 * Parameters   : uint32 GPIO_MUX, GPIO MUX REG ,DEFINED IN EAGLE_SOC.H, e.g.: PERIPHS_IO_MUX_MTCK_U
        uint32 GPIO_NUM, GPIO NUM ACCORDING TO THE MUX NUM , e.g.: 13 for MTCK
        uint32 GPIO_FUNC, GPIO PIN FUNC , DEFINED IN EAGLE_SOC.H , e.g.: FUNC_GPIO13
 * Returns      : none
*******************************************************************************/



void ICACHE_FLASH_ATTR
sigma_delta_setup(uint32 GPIO_MUX,uint32 GPIO_NUM,uint32 GPIO_FUNC)
{
//GPIO_SIGMA_DELTA_NUM= 0x68;//GPIO_NUM;
  uint32 pinaddr = GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_NUM));


    //============================================================================
    //STEP 1: SIGMA-DELTA CONFIG;REG SETUP
/*
    GPIO_REG_WRITE(GPIO_SIGMA_DELTA,
       (GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_SIGMA_DELTA_NUM)))
        &(~GPIO_SIGMA_DELTA_SETTING_MASK))|
       GPIO_SIGMA_DELTA_SET(GPIO_SIGMA_DELTA_ENABLE)|
        GPIO_SIGMA_DELTA_TARGET_SET(0x00)|
         GPIO_SIGMA_DELTA_PRESCALE_SET(0x00) );
*/
    //============================================================================

    //STEP 2: PIN FUNC CONFIG :SET PIN TO GPIO MODE AND ENABLE OUTPUT
  //  PIN_FUNC_SELECT(GPIO_MUX, GPIO_FUNC);
  //  gpio_output_set(0,0,0x1<<GPIO_NUM,0);

   //gpio_output_set(1<<GPIO_NUM,0,1<<GPIO_NUM,0);
    //============================================================================

    //STEP 3: CONNECT SIGNAL TO GPIO PAD
    GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_NUM)),
         GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_NUM)))|
       GPIO_PIN_SOURCE_SET(  SIGMA_AS_PIN_SOURCE )  );
    //============================================================================
    //ets_printf("test reg gpio mtdi : 0x%08x \n",GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_NUM))));

   gpio_output_set(1<<GPIO_NUM,0,1<<GPIO_NUM,0);

   // Make it output PWM signal
  GPIO_REG_WRITE(pinaddr, GPIO_REG_READ(pinaddr) | 1);

   GPIO_REG_WRITE(GPIO_SIGMA_DELTA, 0x1FFFF);
}




/******************************************************************************
 * FunctionName : sigma_delta_close
 * Description  : DEinit Pin ,from Sigma_delta mode to GPIO input mode
 * Parameters   : uint32 GPIO_NUM, GPIO NUM ACCORDING TO THE MUX NUM , e.g.: 13 for MTCK
 * Returns      : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
    sigma_delta_close(uint32 GPIO_NUM)
{

    //============================================================================
    //STEP 1: SIGMA-DELTA DEINIT
    GPIO_REG_WRITE(GPIO_SIGMA_DELTA,
           (GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_SIGMA_DELTA_NUM))) &(~GPIO_SIGMA_DELTA_SETTING_MASK))|
             GPIO_SIGMA_DELTA_SET(GPIO_SIGMA_DELTA_DISABLE)|
                GPIO_SIGMA_DELTA_TARGET_SET(0x00)|
                     GPIO_SIGMA_DELTA_PRESCALE_SET(0x00) );

    //ets_printf("test reg gpio sigma : 0x%08x \n",GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_SIGMA_DELTA_NUM))));
    //============================================================================

    //STEP 2: GPIO OUTPUT DISABLE
    //gpio_output_set(0,0,0,0x1<<GPIO_NUM);
    //============================================================================

    //STEP 3: CONNECT GPIO TO PIN PAD
    GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_NUM)),
            GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_NUM)))|
              GPIO_PIN_SOURCE_SET(  GPIO_AS_PIN_SOURCE )       );
    //============================================================================


}



/******************************************************************************
 * FunctionName : set_sigma_target
 * Description  : SET TARGET DUTY FOR SIGMA-DELTA
 * Parameters   : uint8 target, DUTY NUM , 1BYTE , DUTY RANGE : 0-255
 * Returns      : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
    set_sigma_target(uint8 target)
{
    uint32 reg_r;
    //uint32 t_tar=target;
    //set sigma signal duty target
/*
        GPIO_REG_WRITE(GPIO_SIGMA_DELTA,
       (GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_SIGMA_DELTA_NUM)))
        &(~GPIO_SIGMA_DELTA_TARGET_MASK))|
        GPIO_SIGMA_DELTA_TARGET_SET(target));

   */
        reg_r=GPIO_REG_READ(GPIO_SIGMA_DELTA);
        reg_r= reg_r & 0xFFFFFF00 ;
        reg_r= reg_r|target;
        GPIO_REG_WRITE(GPIO_SIGMA_DELTA, reg_r);

}



/******************************************************************************
 * FunctionName : set_sigma_prescale
 * Description  : SET SIGMA-DELTA SIGNAL CLK PRESCALE(CLE_DIV)
 * Parameters   : uint8 prescale, CLK_DIV , 0-255
 * Returns      : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
    set_sigma_prescale(uint8 prescale)
{
    uint32 reg_r;
     uint16 p_r=prescale;
    //set sigma signal clk prescale(clk div)
/*
        GPIO_REG_WRITE(GPIO_SIGMA_DELTA,
           (GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(GPIO_SIGMA_DELTA_NUM)))
            &(~GPIO_SIGMA_DELTA_PRESCALE_MASK))|
           GPIO_SIGMA_DELTA_PRESCALE_SET(prescale) );

*/
        reg_r=GPIO_REG_READ(GPIO_SIGMA_DELTA);
        reg_r= reg_r & 0xFFFF00FF ;
        reg_r= reg_r|( p_r<<8);
        GPIO_REG_WRITE(GPIO_SIGMA_DELTA, reg_r);

}



/******************************************************************************
 * FunctionName : set_sigma_duty_312KHz
 * Description  : 312K CONFIG EXAMPLE
 * Parameters   : uint8 duty, TARGET DUTY FOR 312K,  0-255
 * Returns      : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
    set_sigma_duty_312KHz(uint8 duty)
{

    uint8 target = 0,prescale=0;
    target = (duty>128)?(256-duty):duty;
    prescale = (target==0)?0:(target-1);

    //freq = 80000 (khz) /256 /duty_target * (prescale+1)
    set_sigma_target(duty);//SET DUTY TARGET
    set_sigma_prescale(prescale);//SET CLK DIV

}

And the sigma_delta.h:

/* 
 sigma_delta.h - esp8266 sigma-delta source

 Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
 This file is part of the esp8266 core for Arduino environment.
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef SIGMA_DELTA_H
#define SIGMA_DELTA_H

#include <stdint.h>

void sigma_delta_setup(uint32_t GPIO_MUX,uint32_t GPIO_NUM,uint32_t GPIO_FUNC);
void sigma_delta_close(uint32 GPIO_NUM);
void set_sigma_target(uint8 target);
void set_sigma_prescale(uint8 prescale);
void set_sigma_duty_312KHz(uint8 duty);

#endif//SIGMA_DELTA_H

And it works! There is output in the pin, but it requires a pull up resistor, how can a push-pull output configuration be enabled for the pin? I tried uncommenting a couple of lines in the code that sets the output:

//Step 2 in setup:

  PIN_FUNC_SELECT(GPIO_MUX, GPIO_FUNC);
  gpio_output_set(0,0,0x1<<GPIO_NUM,0);

   gpio_output_set(1<<GPIO_NUM,0,1<<GPIO_NUM,0);

With no luck. Also tried setting it up as output in arduino.
Any ideas?

Regards

[Jsolo1]

Ok, i found a solution, in order to make it push-pull output, I added this line in the arduino:

GPC(pin) = (GPC(pin) & (0 << GPCD));

That can be found in the pin_mode function:
https://github.com/esp8266/Arduino/blob/master/cores/esp8266/core_esp8266_wiring_digital.c

Would be good to figure it out which registers is it modifying and do it automatically in the library.
I also added this other functions to the library to create pwm signals at a different frequency (1.2khz to 37MHz):

int get_duty(uint8 prescale, uint8 duty, float freq){
	int duty_new;
	int target;
	
	target = (int)((prescale + 1)*freq);
	//target = (duty > 128)?(256-duty):duty;
	duty_new = (duty>128)?(256-target):target;
	return duty_new;
	
}


int get_prescale(uint8 duty, float freq){
	
	uint8 target = 0;
	int prescale=0;
    target = (duty>128)?(256-duty):duty;
	if (target == 0){
		prescale = 0;
	}else{
		prescale = (int)(((float)target) / freq) - 1;
		
	}
	//prescale = (int)(((float)target) / freq) - 1;
	return prescale;
	
}

/******************************************************************************
 * FunctionName : set_sigma_duty_freq.
 * Description  : Creates a pwm signal at a defined frequency and duty cycle.
 * Parameters   : uint8 duty, TARGET DUTY,  0-255
 *				  float freq, TARGET FREQUENCY,  0.05-120, 1 means 312Khz. Frequency range 1.2Khz-37.5MHz
 *				  bool const_freq, if true, it will limit the duty cycle to try to keep the frequency constant.
 *							if false, the frequency will shift at high duty cycles and "freq" less than 1,
 *							but the duty cycle will remain as constant as possible
 * Returns      : none
*******************************************************************************/
void ICACHE_FLASH_ATTR set_sigma_duty_freq(uint8 duty, float freq, bool const_freq)
{
	uint8 target = 0;
	int prescale = 0;
	int duty_new = duty;
   
	
	prescale = get_prescale(duty,freq);	
	
	if (prescale <= 0){
		prescale = 0;
		duty_new = get_duty(prescale,duty,freq);
	}
	
	
	if (const_freq == true){
		//target = 1;
		if (prescale > 255){
			prescale = 255;
			duty_new = get_duty(prescale,duty,freq);
		}
	}else{
		//target = 10;
		if (prescale > 255){
			prescale = 255;
		}
	}
	//prescale = (target==0)?0:(target-1);
    //freq = 80000 (khz) /256 /duty_target * (prescale+1)
    set_sigma_target((uint8)duty_new);//SET DUTY TARGET
    set_sigma_prescale((uint8)prescale);//SET CLK DIV

}

[stefaandesmet2003]

A working demo, and suggestion for interfacing the sigma delta generator.
still figuring out how to do a pull request and upload the code properly ..
SigmaDeltaDemo.zip

[devyte]

@stefaandesmet2003 fork the repo, map your fork to your ccomputer, create a branch, submit your changes, push upstream (to your remote, I.e. your fork).
Then, visit this repo again, and you should see a notification about your submit. You can review, and create the PR right there on the webpage with just a click on the button.

[stefaandesmet2003]

Ok, thanks!

[pashinen]

Im trying to run above sigma delta program in non-os SDK.. will it work?
If yes how can i put my dynamic data on i2s sigma delta.

[pashinen]

I'm generating a sine lookup table of size 256 and want tp play random frequency via play function.
Let me know how can i put samples on i2s sigma delta pin/line.

[stefaandesmet2003]

Yes, the example code will work in arduino (non-os sdk) environment.The sigma-delta generator is different from the i2s peripheral. For creating i2s samples to send to an external DAC, you will need the i2s peripheral.The SD generator has only limited control over the output frequency, I haven't tried if it's sufficiently accurate in the audio frequency range. Best have a look at the esp8266 documentation. From: pashinen <notifications@github.com> To: esp8266/Arduino <Arduino@noreply.github.com> Cc: stefaandesmet2003 <stefaandesmet2003@yahoo.co.uk>; Mention <mention@noreply.github.com> Sent: Tuesday, 5 June 2018, 12:44 Subject: Re: [esp8266/Arduino] Sigma-delta support (#3673) I'm generating a sine lookup table of size 256 and want tp play random frequency via play function. Let me know how can i put samples on i2s sigma delta pin/line.— You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub, or mute the thread.

[pashinen]

Okay tell me how to generate specific frequency say 6029.29HZ through sigma delta for 40ms.