TL494 duty cycle adjustment

The TL494 can be used as a PWM generator. It's not clear what frequency you need, but the part is not fast. It might generate usable PWM up to about 30kHz. After that switch overlap can become a problem. But, following your questions:

1. It's probably not a good idea to drive the feedback pin directly with a pot wiper. Better would be to choose one of the error amps, make it unity gain, and then feed the pot wiper into the non-inverting input. That takes the loading off of the pot, and lets the amp do what it was meant to do.

2. The error amp you don't use needs to be biased on the input so that the output is low. Tie the inverting input to Vref through a 1KOhm and tie the non-inverting input to ground through a 1KOhm. DTC sets the dead time on the PWM waveform, with low being maximum PWM (minimal dead time), dead time increasing as DTC voltage rises. For maximal PWM, keep DTC below about 100mV.

3. Vref can be used to supply voltage, but has to be done carefully. Vref can't source more than 5 or 10 mA, so any more current than that and a buffer BJT (pnp) would be needed to supplement. Unless the extra load is very constant, more filtering would probably be needed. Vref is used inside the chip, so any noise added to it could mess up operation.

4. Normally to get a single output, one would connect E1 and E2 to ground and tie C1 and C2 together with a single pull-up resistor as a wire-or.

The TL494 is a bit unusual in that PWM duty cycle is inversely proportional to the feedback voltage, when feedback voltage is low PWM is maximal, as feedback voltage increases PWM duty cycle is reduced. If you haven't read "Designing Switching Voltage Regulators with the TL494" you should.

Main problem

You are setting the Compare Match Output pin in the wrong register. Replace

TCCR0A |= (1<<WGM01) | (1<<WGM00);
TCCR0B |= (1<<COM0B1) | (1<<WGM02) | (1<<CS01);

with

TCCR0A = (1<<COM0B1) | (1<<WGM01) | (1<<WGM00);
TCCR0B = (1<<WGM02) | (1<<CS01);

Of course, this assumes you have a 16MHz CPU frequency with no clock divide as you are using a prescaler of 8 with a TOP value of 100.

F_OCRO = F_CPU / (Prescaler * (1 + OCR0A)) = 16MHz / (8 * 100) = 20kHz

Other problems

This might be working, but it's not the best idea. There's lots I could go over, but let's just talk about this

double duty_cyle = 50;
OCR0B = (duty_cycle * 99) / 100;

AVR is 8-bit. Double is a 64-bit number with decimal places. Actually, (in GCC, at least), doubles are automatically replaced with Floats (single-precision). AVR doesn't have a floating-point unit (FPU) and any floating-point operations (which have 32-bit storage) will take an order of magnitude MORE clock cycles to complete than a typical 8-bit operation. Division is also not supported in AVR hardware, so the compiler emulates it in software. You are also doing all of this math in an interrupt service routine. That's ... not good.

OCR0B is an 8-bit register (max of 255, unsigned). Since you are using OCR0A as the timer TOP with a value of 99, you have a nice 0 - 99% duty cycle setup. So, just set OCR0B to whatever duty cycle you want. Why do (50 / 99 * 100) which equals 49.5 and will be chopped to 49 anyway? Just do this:

static volatile uint8_t duty_cycle = 50;   // unsigned 8-bit integer
OCR0B = duty_cycle;

The "static" keyword means this variable is only available in the current file - it's like a local global. You should also use it on any local functions that aren't accessed outside of this .c file. The "volatile" keywords tells the compiler not to optimize the variable because it could be updated somewhere not expected (like in an ISR). You don't need volatile if you aren't changing the duty_cycle variable in an ISR. Better yet, why use a global variable at all when you can access the register directly?

OCR0B = 50;

If you don't like that, use a macro or static inline function:

#define SET_DUTY(PERCENT)     OCR0B = (PERCENT)
// ...
SET_DUTY(50);
// OR
static inline void set_duty(const uint8_t percent) {
     OCR0B = percent;
}
// ...
set_duty(50);

Also, unless you plan on re-initializing the timer at some point while keeping other changes you've made to those registers, you don't need to do "|=" which is a "read-modify-write" operation. Just use "=". The "|=" means to set only the specified bit while leaving everything else alone, which is pointless during initialization when you want everything not specifically set to be 0.