在Java中，如何使该脉冲波在占空比样本之间进行更精细的转换

我正在建造一个扩展方波发生器的脉冲波发生器

我的问题是我希望脉宽调制转换更平滑 我试图使波峰和波谷之间的中间样品在宽度被调制时平滑地向上或向下移动。 这是如此之高的声音，如2093赫兹的C7，在占空比被调制时，听起来不会发出咔哒声

需要做什么

抽样率为44100 比特率是16 ampLimit是可能的最高值。 持续时间是以秒为单位的波形长度 占空比是波形的起始周期

public class PulseGenerator extends SquareGenerator {

    // constants
    public static final double DEF_MIN_DUTY_CYCLE = 0.05;
    public static final double DEF_MAX_DUTY_CYCLE = 0.95;
    public static final double DEF_CYCLE_FREQ = 2;
    public static final double DEF_HOLD_CYCLE = 0;

    // instance variables
    double minDutyCycle; // minimum value of duty cycle
    double maxDutyCycle; // maximum value of duty cycle
    double cycleFreq;
    double holdCycle; // if more than zero, the wave will hold the modulation for that period
    double dutyCycleRange;  // maxDutyCycle - minDutyCycle
    boolean setDirection;

    // constructor
    public PulseGenerator(double amplitude, double frequency, int bitRate,
            double duration, double dutyCycle, double minDutyCycle,
            double maxDutyCycle, double cycleFreq, double holdCycle) {
        super(amplitude, frequency, bitRate, duration, dutyCycle);
        // sample data
        squareSample = new int[sampleLength];
        calculateAmpLimit();
        this.dutyCycle = dutyCycle;
        waveLength = SAMPLE_RATE / this.frequency;
        this.minDutyCycle = minDutyCycle;
        this.maxDutyCycle = maxDutyCycle;
        this.cycleFreq = cycleFreq * SAMPLE_RATE;
        this.holdCycle = holdCycle * SAMPLE_RATE;
        dutyCycleRange = this.maxDutyCycle - this.minDutyCycle;
        setDirection = false;
    }

    // one arg cunstructor
    public PulseGenerator(double frequency) {
        this(AMPLITUDE, frequency, BIT_RATE, DURATION, DEF_DUTY_CYCLE,
                DEF_MIN_DUTY_CYCLE, DEF_MAX_DUTY_CYCLE, DEF_CYCLE_FREQ,
                DEF_HOLD_CYCLE);
    }

    // no args constructor
    public PulseGenerator() {
        this(AMPLITUDE, FREQUENCY, BIT_RATE, DURATION, DEF_DUTY_CYCLE,
                DEF_MIN_DUTY_CYCLE, DEF_MAX_DUTY_CYCLE, DEF_CYCLE_FREQ,
                DEF_HOLD_CYCLE);
    }

    // generate waveform method
    @Override
    public int[] generateWaveForm() {

        // define cycle point
        int cyclePoint = (int)(cycleFreq / 2 * ((dutyCycle * dutyCycleRange) + minDutyCycle));

        // generate the actual waveform
        for (int i = 0, j = 0; i < sampleLength; i++, j++) {

            double waveCycleRatio = waveLength * dutyCycle;

            // same as square generate method
            if (j - waveCycleRatio < 0.0) {
                finePoint = 1.0;
            } else if (j - waveCycleRatio >= 0.0 
                    && j - waveCycleRatio < 1) {
                finePoint = 1 - (j - waveCycleRatio);
            } else if (j - waveLength < 0.0) {
                finePoint = -1.0;
            } else if (j - waveLength >= 0.0) {
                finePoint = -1 + (waveLength - j);
            }
            if (j >= waveLength) {
                j = 1;
            }
            point = (int)finePoint * ampLimit;
            squareSample[i] = point;

            if (holdCycle > 0) {
                holdCycle--;
            } else {
                dutyCycle = (cyclePoint / (cycleFreq / 2) * dutyCycleRange)
                        + minDutyCycle;
                if (cyclePoint < cycleFreq / 2 && !setDirection) {
                    cyclePoint++;
                } else if (cyclePoint >= cycleFreq / 2 && !setDirection) {
                    cyclePoint--;
                    setDirection = true;
                } else if (cyclePoint > 0 && setDirection) {
                    cyclePoint--;
                } else if (cyclePoint <= 0 && setDirection) {
                    cyclePoint++;
                    setDirection = false;
                }
            }
        }

        // return the sample data
        return squareSample;
    }

}

公共类脉冲发生器{
//常数
公共静态最终双定义最小占空比=0.05；
公共静态最终双定义最大占空比=0.95；
公共静态最终双定义循环频率=2；
公共静态最终双定义保持循环=0；
//实例变量
double minDutyCycle；//占空比的最小值
double maxDutyCycle；//占空比的最大值
双循环；
double holdCycle；//如果大于零，波将在该周期内保持调制
双dutyCycleRange；//maxDutyCycle-minDutyCycle
布尔集合方向；
//建造师
公共脉冲发生器（双振幅、双频率、整数比特率、，
双倍持续时间，双倍责任周期，双倍意识周期，
双maxDutyCycle，双cycleFreq，双holdCycle）{
super（振幅、频率、比特率、持续时间、dutyCycle）；
//样本数据
squareSample=新整数[sampleLength]；
calculateAmpLimit（）；
this.dutyCycle=dutyCycle；
波长=采样率/该频率；
this.minDutyCycle=minDutyCycle；
this.maxDutyCycle=maxDutyCycle；
this.cycleFreq=cycleFreq*采样率；
this.holdCycle=holdCycle*采样率；
dutyCycleRange=this.maxDutyCycle-this.minDutyCycle；
setDirection=false；
}
//一个arg结构器
公共脉冲发生器（双频）{
这（振幅、频率、比特率、持续时间、DEF_占空比、，
DEF_最小占空比、DEF_最大占空比、DEF_循环频率、，
DEF_保持_循环）；
}
//无参数构造函数
公共脉冲发生器（）{
这（振幅、频率、比特率、持续时间、DEF_占空比、，
DEF_最小占空比、DEF_最大占空比、DEF_循环频率、，
DEF_保持_循环）；
}
//波形生成法
@凌驾
public int[]generateWaveForm（）{
//定义循环点
int cyclePoint=（int）（cycleFreq/2*（（dutyCycle*dutyCycleRange）+minDutyCycle））；
//生成实际波形
for（inti=0，j=0；i=0.0
&&j-波循环次数<1）{
finePoint=1-（j-波周期）；
}else if（j-波长<0.0）{
精细点=-1.0；
}else如果（j-波长>=0.0）{
细点=-1+（波长-j）；
}
如果（j>=波长）{
j=1；
}
点=（int）精细点*ampLimit；
平方样本[i]=点；
如果（保持周期>0）{
保持循环--；
}否则{
dutyCycle=（cyclePoint/（cycleFreq/2）*dutyCycleRange）
+明度周期；
if（循环点=cycleFreq/2&&！setDirection）{
循环点--；
setDirection=true；
}else if（循环点>0&&setDirection）{
循环点--；
}否则，如果（cyclePoint我确实发现了问题所在，首先我将精细点转换为一个整数，然后再乘以安培极限。第二，精细点的代码需要重新定位并乘以2

// generate the actual waveform
        for (int i = 0, j = 0; i < sampleLength; i++, j++) {

            double waveCycleRatio = waveLength * dutyCycle;

            // same as square
            if (j - waveCycleRatio < 0.0) {
                finePoint = 1.0;
            } else if (j - waveCycleRatio >= 0.0 
                    && j - waveCycleRatio < 1) {
                finePoint = 0 - (j - waveCycleRatio - 0.5) * 2;
            } else if (j - waveLength < 0.0) {
                finePoint = -1.0;
            } else if (j - waveLength >= 0.0) {
                finePoint = (j - waveLength - 0.5) * 2;
            }
            if (j >= waveLength) {
                j = 1;
            }
            point = (int)(finePoint * ampLimit);
            squareSample[i] = point;

            if (holdCycle > 0) {
                holdCycle--;
            } else {
                dutyCycle = (cyclePoint / (cycleFreq / 2) * dutyCycleRange)
                        + minDutyCycle;
                if (cyclePoint < cycleFreq / 2 && !setDirection) {
                    cyclePoint++;
                } else if (cyclePoint >= cycleFreq / 2 && !setDirection) {
                    cyclePoint--;
                    setDirection = true;
                } else if (cyclePoint > 0 && setDirection) {
                    cyclePoint--;
                } else if (cyclePoint <= 0 && setDirection) {
                    cyclePoint++;
                    setDirection = false;
                }
            }
        }

//生成实际波形
for（inti=0，j=0；i=0.0
&&j-波循环次数<1）{
finePoint=0-（j-波动周期-0.5）*2；
}else if（j-波长<0.0）{
精细点=-1.0；
}else如果（j-波长>=0.0）{
细点=（j-波长-0.5）*2；
}
如果（j>=波长）{
j=1；
}
点=（int）（精细点*ampLimit）；
平方样本[i]=点；
如果（保持周期>0）{
保持循环--；
}否则{
dutyCycle=（cyclePoint/（cycleFreq/2）*dutyCycleRange）
+明度周期；
if（循环点=cycleFreq/2&&！setDirection）{
循环点--；
setDirection=true；
}else if（循环点>0&&setDirection）{
循环点--；
}否则，如果（cyclePoint）你确定“咔嗒声”不是振荡器进入可听见的范围吗？信号正在被调制，之后你对它做什么样的后处理？平滑算法在哪里？振荡器只在