Implementation of Nor Flip Flop Logic Gates in Go

Question

I'm trying to implement the following nor flip flop circuit logic in Go and having some difficulty with variable declarations:

My goal is to simulate the logic gates and circuitry as it would physically work. I've implemented a function for the nor gates [func nor()] and the flip flop itself [func norFlipFlop()]. The issue I'm facing is in declaring out0 and out1 since they depend on each other. As can be seen below out0 is defined as nor(a1, out1) and out1 is defined as nor(out0, a0). This obviously spits out a compilation error since out1 is not yet initialized and defined when out0 is defined. Is there a way to make this logic work while keeping it as close to the physical circuit logic as possible?

func nor(a int, b int) int {
    if a + b == 0 {
        return 1
    } else {
        return 0
    }
}   

func norFlipFlop(a1 int, a0 int) (int, int) {
    out0 := nor(a1, out1)
    out1 := nor(out0, a0)
    return out1, out0
}

func main() {
    out1, out0 := norFlipFlip(1, 1)
    out := fmt.Sprint(out1, out0)
    fmt.Println(out)
}

Not at all. That was purely an oversight and I'm likely going to convert to code to use bools. I believe this would run into the same issues however due to the dependencies. — RogueKnight, May 23 '20 at 02:43

Andrew W. Phillips · Accepted Answer · 2020-05-23T04:50:59.877

First, a flip flop stores state, so you need some sort of value to retain the state. Also, apart from a condition (usually avoided in hardware) where A0 and A1 are 0 (false) and Out0 and Out1 are both 1 (true) the outputs (Out0 and Out1) are usually the complement of each other and a flip flop effectively stores only a single boolean value so you can just use a bool. You typically "pulse" the inputs to set (make true) or reset (make false) the flip-flop's value. Eg:

package main

import "fmt"

type flipFlop bool

func (ff flipFlop)GetOut0() bool {
    return bool(ff)
}

func (ff flipFlop)GetOut1() bool {
    return !bool(ff)
}

func (ff *flipFlop)PulseA0() {
    *ff = true
}

func (ff *flipFlop)PulseA1() {
    *ff = false
}

func main() {
    var ff flipFlop
    ff.PulseA0()
    fmt.Println(ff.GetOut0(), ff.GetOut1())
    ff.PulseA1()
    fmt.Println(ff.GetOut0(), ff.GetOut1())
}

If you want to more closely simulate the hardware you need to keep track of the hardware states. Maybe something like this:

package main

import "fmt"

type flipFlop struct {
    A0, A1 bool
    out0, out1 bool
}

func nor(a, b bool) bool { return !(a || b) }

func (ff *flipFlop)Eval() {
    // Evaluate the circuit until it is stable
    for {
        prev0, prev1 := ff.out0, ff.out1
        ff.out0 = nor(ff.A1, ff.out1)
        ff.out1 = nor(ff.A0, ff.out0)
        if ff.out0 == prev0 && ff.out1 == prev1 {
            break // flip flop is stable
        }
    }
}

func main() {
    var ff flipFlop
    fmt.Println(ff)

    // Pulse a0
    ff.A0 = true
    ff.Eval()
    fmt.Println(ff)
    ff.A0 = false
    ff.Eval()
    fmt.Println(ff)

    // Pulse a1
    ff.A1 = true
    ff.Eval()
    fmt.Println(ff)
    ff.A1 = false
    ff.Eval()
    fmt.Println(ff)
}

I hope this helps (BTW I'm not an electronics engineer :).

This is really helpful and I greatly appreciate it! Let me play around with this and let you know how it goes. — RogueKnight, May 23 '20 at 06:53
I was able to get it working with your solution. Thanks for the help! I'm in the process of simulating a simple 8 Bit CPU that I've been designing in Go. I'll probably open source the code and share it once I get more of it working. I really appreciate the help! Thanks! — RogueKnight, May 23 '20 at 21:02

Implementation of Nor Flip Flop Logic Gates in Go

1 Answers1