public static Nibble AddTwoBits(Bit2 a, Bit2 b, bool c)
{
var add1 = Add(a.Low, b.Low, c);
var add2 = Add(a.High, b.High, add1.High);
return(new Nibble(new Bit2(false, add2.High), new Bit2(add2.Low, add1.Low)));
}
public void It_is_impossible_to_store_data_at_a_clocktick()
{
// Arrange
var register2Bit = new Register2Bit();
// Act
var data = new Bit2(true, true);
var output = register2Bit.Do(true, data, true);
// Assert
output.High.Should().BeFalse();
output.Low.Should().BeFalse();
}
public void When_store_is_true_and_clock_is_false_the_previous_value_should_be_returned()
{
// Arrange
var register2Bit = new Register2Bit();
// Act
var data = new Bit2(true, true);
var output = register2Bit.Do(true, data, false);
// Assert
output.High.Should().BeFalse();
output.Low.Should().BeFalse();
}
public void Test1()
{
// Arrange
var ram = new RandomAccessMemory2();
var byte2 = new Byte2(42);
var address = new Bit2(false, false);
// Act
var output = ram.Do(address, true, byte2, false);
// Assert
output.ToInt16().Should().Be(0);
}
public void After_storing_data_a_clocktick_returns_the_new_data()
{
// Arrange
var register2Bit = new Register2Bit();
// Act
var data = new Bit2(true, true);
register2Bit.Do(true, data, false); // store data
var output = register2Bit.Do(false, new Bit2(false, false), true); // return data because clock==true
// Assert
output.High.Should().BeTrue();
output.Low.Should().BeTrue();
}
public Byte2 Do(Bit2 address, bool store, Byte2 data, bool clock)
{
var invertedAddress = Gates.Invert(address.High);
var storeAtRam0 = Gates.And(invertedAddress, store);
var storeAtRam1 = Gates.And(address.High, store);
var output0 = _ram0.Do(address.Low, storeAtRam0, data, clock);
var output1 = _ram1.Do(address.Low, storeAtRam1, data, clock);
var outputTotal = Select16.Do(address.High,
output1,
output0);
return(outputTotal);
}
public void Store_different_values_at_different_addresses2()
{
// Arrange
var ram = new RandomAccessMemory2();
var byte2A = new Byte2(42);
var byte2B = new Byte2(3);
var byte2C = new Byte2(999);
var addressA = new Bit2(false, false);
var addressB = new Bit2(true, true);
// Act
ram.Do(addressA, false, byte2A, false);
ram.Do(addressA, true, byte2A, false);
ram.Do(addressA, true, byte2A, true);
ram.Do(addressB, true, byte2B, false);
ram.Do(addressB, true, byte2B, true);
var output = ram.Do(addressB, false, byte2C, false);
// Assert
output.ToInt16().Should().Be(3);
}
/// <summary>
/// Stores and emits a 16-bit word, synchronized by a clock signal.
/// </summary>
/// <param name="st">Store: yes/no</param>
/// <param name="data">data that needs to be stored</param>
/// <param name="clock">Clock signal</param>
/// <returns>The previously stored values</returns>
//public Bit2 Do(bool st, bool d0, bool d1, bool clock)
//{
// return new Bit2(_dff1.Do(st, d1, clock),
// _dff2.Do(st, d0, clock));
//}
public Bit2 Do(bool st, Bit2 data, bool clock)
{
return(new Bit2(_dff0.Do(st, data.High, clock),
_dff1.Do(st, data.Low, clock)));
}
public static Bit2 And2(Bit2 a, Bit2 b)
{
return(new Bit2(And(a.High, b.High),
And(a.Low, b.Low)));
}
public static Bit2 Invert2(Bit2 a)
{
return(new Bit2(Invert(a.High), Invert(a.Low)));
}
public static bool EqualsZero(Bit2 a)
{
var orA = Gates.Or(a.High, a.Low);
return(Gates.Invert(orA));
}
