Bit Banging I2C for communication between Raspberry Pi and PCF8591

I am trying to interface multiple PCF8591 (around 5) to a single Raspberry Pi using I2C protocol. Since a Rpi has only one set of SDA and SCL pins, I am trying to bit-bang to make the other GPIO pins work as SDA and SCL. I am trying to use RPi.GPIO library for making the bit banging code in python.

I don't understand how to communicate with PCF8591 even after referring to the manual plenty of times. I could not figure out how to receive data from a specific pin from PCF8591 since there are 4 pins available (AIN0, AIN1, AIN2, AIN3). I also want the input voltage as the differential voltage between two pins. It would be very helpful if anyone could tell me the steps to change and access different pins of PCF8591.

I am attaching the code I am using. I get a reading of '255' throughout whenever I run it. It is working more or less as I could see the SCA and SDA waveforms in an oscilloscope.
import RPi.GPIO as GPIO
import time
import matplotlib.pyplot as plt

pin_SCL = 0
pin_SDA = 0
signal = []

def plot_graph(time, data, graph_no, label_):
    fig = plt.figure(graph_no)
    axes = fig.add_subplot(111)
    axes.patch.set_facecolor('black')
    plt.plot(time, data, label = label_)
    plt.ylabel('Voltage')
    plt.xlabel('Time')
    plt.legend(loc='upper right')

def set_pin(SCL, SDA):
    global pin_SCL
    global pin_SDA
    pin_SCL = SCL
    pin_SDA = SDA
    GPIO.setup(pin_SCL, GPIO.OUT)

def start():
    GPIO.setup(pin_SDA, GPIO.OUT)

    GPIO.output(pin_SCL, GPIO.HIGH)
    GPIO.output(pin_SDA, GPIO.HIGH)

    time.sleep(10)

    GPIO.output(pin_SDA, GPIO.LOW)
    GPIO.output(pin_SCL, GPIO.LOW)

def send_byte(byte):
    GPIO.setup(pin_SDA,GPIO.OUT)

    for i in range(8):
        GPIO.output(pin_SDA,byte & 0b10000000)
        GPIO.output(pin_SCL,GPIO.HIGH)
        GPIO.output(pin_SCL,GPIO.LOW)
        byte = byte << 1

def acknowledge_from_slave():
    GPIO.setup(pin_SDA,GPIO.IN)

    GPIO.output(pin_SCL,GPIO.HIGH)
    status = GPIO.input(pin_SDA)
    GPIO.output(pin_SCL,GPIO.LOW)

    if(status == GPIO.HIGH):
        print("BYTE NOT RECEIVED")

def acknowledge_from_master():
    GPIO.setup(pin_SDA,GPIO.OUT)

    GPIO.output(pin_SCL,GPIO.HIGH)
    GPIO.output(pin_SDA,GPIO.LOW)
    GPIO.output(pin_SCL,GPIO.LOW)

def receive_byte():
    global signal
    byte = ''

    GPIO.setup(pin_SDA,GPIO.IN)

    for i in range(8):
            GPIO.output(pin_SCL,GPIO.HIGH)
            byte = byte + str(GPIO.input(pin_SDA))
            GPIO.output(pin_SCL,GPIO.LOW)

    byte = int(byte,2)
    signal.append(byte)

if __name__ == "__main__":
    global signal

    GPIO.setmode(GPIO.BOARD)
    set_pin(38,40)
    start()
    send_byte(0b10010001)
    acknowledge_from_slave()

    send_byte(0b00110000)#control byte to tell pcf8591 work as differential input

    acknowledge_from_master()

    try:
        while True:
            receive_byte()
            acknowledge_from_master()

    except KeyboardInterrupt:
        plot_graph(range(len(signal)),signal,1,'Detected Signal')

    plt.show()
    GPIO.cleanup()

I2C is designed to control multiple devices from a  single common clock and data line. If you read the functional description of the PCF8591, the first byte sent, an address byte, allows for multiple instances of the device  since you have the hardware lines A0-A2, and you can tie those pins high or low so they are different for each chip.  The second byte sent is the control bytes, which controls which ADC channel is used, and how the input is configured, which includes single ended, differential, or a mix of both. The third byte controls the DAC. Sounds like you need to read up on the I2C bus, here is a tutorial, Spark Fun I2C tutorialCheers,Richard

I2C is a two wire addressed communication protocol. That means that you can have many devices connected to the SDA and SDL lines. The A0 - A2 pins are address pins. You'll have to read the manual on how the addressing works on a write operation. I would recommend several things:
1) Learn more about I2C before using it2) Start with connecting just a single device first and understanding how to communicate with it3) Get something like a TotalPhase Aardvark and connect it directly to the chip to learn how it works4) Get a logic analyzer such as a Saeleae Logic probe and use it to monitor your I2C lines so you can monitor how I2C is working.Good Luck!

@Jacob_: "...I would recommend several things: 1) Learn more about I2C before using it..."ROFLOL

The recommendation that I would give is to not bit-bang I2C on the Rpi. It's not a real time device and you can't be assured of the accuracy in timing that I2C needs. People do it, as evidenced by the library, but I would strongly recommend sticking to the hardware I2C.
I've not had any good success with anything that require precise timing from the Pi, such as bit-banging anything or PWM. In fact, what I do for PWM is use a small PIC microcontroller to drive the motor controller PWM. I communicate over hardware I2C from the Pi to the PIC.As others have said, you can have multiple devices on the same I2C bus, as long as they have different addresses.I2C can be a bit finicky, so I would start with one PCF8591 chip and one pin. When you have that working, you'll have eliminated a lot of unknowns and it will be easier to add pins and chips.

I need data from all the ADC at the same time instant for my project. I came to know that the master can communicate with only one slave at any time instant and the other slaves have to sit idle at that time instant.I can only use a raspberry pi because of time and financial limitations.I wanted to access different pins in a single PCF8591. That's the problem I am facing. Thank you so much for all your replies! 

If you are multiplexing ADC's, and  scanning using the I2C bus, there will be significant data skew.Please give a few more details, what sampling rate do you need, how many bits, etc.If you are going to need true simultaneous sampling, then you have to use a different method. There are some ADCs that have a  start command, either hardware or software, which allows you to start multiple  conversions simultaneously. This may pertain to either a number of individual ADCs, or there are single chip solutions which have multiple ADC's. After that you have to scan each one in turn to extract the data. Often they are SPI based,  faster than I2C,  with less software overhead during the conversion process.Cheers,Richard