#include <Bin2nImageWriter.hh>

Inheritance diagram for Bin2nImageWriter:

Collaboration diagram for Bin2nImageWriter:

Public Member Functions
	Bin2nImageWriter (const BitVector &bits, int rowLength)

virtual	~Bin2nImageWriter ()

virtual void	writeImage (std::ostream &stream) const

const BitVector &	bits () const

void	writeSequence (std::ostream &stream, unsigned int length) const

Public Member Functions inherited from BitImageWriter
virtual	~BitImageWriter ()

Private Member Functions
unsigned int	nextPowerOf2 (unsigned int n) const

Static Private Member Functions
static char	character (const BitVector &bits, unsigned int startIndex, int length)

Private Attributes
const BitVector &	bits_
	The bits to be written. More...

int	rowLength_
	The length of a row in the output. More...

unsigned int	nextBitIndex_
	The index of the next bit to be written. More...

Detailed Description

Writes the data image with binary 1's and 0's. Pads from the left to next multiple of 2 of rowLength_ and after that reverses the byte endianness. Used for programming the FPGA with Jupyter through AlmaIF

Definition at line 46 of file Bin2nImageWriter.hh.

Constructor & Destructor Documentation

◆ Bin2nImageWriter()

Bin2nImageWriter::Bin2nImageWriter	(	const BitVector &	bits,
		int	rowLength
	)

Definition at line 40 of file Bin2nImageWriter.cc.

                                                   :
     bits_(bits), rowLength_(rowLength), nextBitIndex_(0) {
 }

◆ ~Bin2nImageWriter()

Bin2nImageWriter::~Bin2nImageWriter ( )

virtual

Definition at line 45 of file Bin2nImageWriter.cc.

45 {

46 }

Member Function Documentation

◆ bits()

const BitVector & Bin2nImageWriter::bits ( ) const

Definition at line 157 of file Bin2nImageWriter.cc.

                              {
     return bits_;
 }

References bits_.

Referenced by character(), and Bin2nProgramImageWriter::writeImage().

◆ character()

char Bin2nImageWriter::character	(	const BitVector &	bits,
		unsigned int	startIndex,
		int	length
	)

staticprivate

Returns the byte of the given bit vector that starts at the given index and is 'length' bits long. Pads from the left to size 8.

Parameters

bits	The bit vector.
startIndex	The start index.
length	How many indexes forward is read. 0-8.

Returns: The byte.

Pad from the left with zeros.

Read the first bit.

Read the rest of the bits.

Definition at line 77 of file Bin2nImageWriter.cc.

                                                                                       {
     unsigned int vectorSize = bits.size();
     char character = 0;
  
     /// Pad from the left with zeros.
     character = character << (8 - length);
  
     /// Read the first bit.
     if (bits[startIndex]  && length > 0){
         character++;
     }
  
     /// Read the rest of the bits.
     for (int i = 1; i < length; i++) {
         character = character << 1;
         if (startIndex + i < vectorSize && bits[startIndex + i]) {
             character++;
         }
     }
     return character;
 }

References bits().

Referenced by writeSequence().

Here is the call graph for this function:

◆ nextPowerOf2()

unsigned int Bin2nImageWriter::nextPowerOf2 ( unsigned int n ) const

private

Returns the next power of 2 of the given parameter

Parameters

n

Returns: p the next power of 2 of n

Definition at line 168 of file Bin2nImageWriter.cc.

                                                   {
  
     unsigned int p = 1;
  
     if (!(n & (n - 1)))
         return n;
  
     while(p < n)  {
         p <<= 1;
     }
  
     return p;
 }

Referenced by writeSequence().

◆ writeImage()

void Bin2nImageWriter::writeImage ( std::ostream & stream ) const

virtual

Writes the data bits to the given stream. Reverses the byte endianness

Parameters

stream The output stream.

Bitvector-size has to always be exactly divisible by rowlength

Implements BitImageWriter.

Reimplemented in Bin2nProgramImageWriter.

Definition at line 54 of file Bin2nImageWriter.cc.

                                                      {
  
     unsigned int size = bits_.size();
  
     /// Bitvector-size has to always be exactly divisible by rowlength
     unsigned int numOfRows = size / rowLength_;
  
     for (unsigned int i = 0; i < numOfRows; i++){
         writeSequence(stream, rowLength_);
  
     }
 }

References bits_, rowLength_, and writeSequence().

Here is the call graph for this function:

◆ writeSequence()

void Bin2nImageWriter::writeSequence	(	std::ostream &	stream,
		unsigned int	length
	)		const

Writes a sequence of bits to the given stream.

When this method is called sequentially, the first bit to be written is the next bit to the last bit written in the previous method call. Pads the sequence from the left with zeroes up to the nearest multiple of 2. After that, reverses the string before writing it to the stream.

Parameters

stream	The output stream.
length	The length of the sequence to be written.

Pad from the left the correct amount of "0 bytes".

There might be a partial byte, which needs to be padded from the left

If there is no partial byte, we don't want to insert anything

Create the full bytes.

Update this for the next iteration of the function.

Reverse the byte endianness and write the stream.

Definition at line 112 of file Bin2nImageWriter.cc.

                                                                             {
  
     if (length == 0){
         return;
     }
  
     unsigned int lastIndex = nextBitIndex_ + length -1;
     unsigned int imem_width = nextPowerOf2(length);
     std::string sequence_word = "";
  
     /// Pad from the left the correct amount of "0 bytes".
     for (unsigned int i = 0;i < (imem_width-length)/8; i++){
         char zero = 0;
         sequence_word.push_back(zero);
     }
  
     /// There might be a partial byte, which needs to be padded from the left
     unsigned int partial_start_index = nextBitIndex_;
     unsigned int partial_char_len = length % 8;
  
     /// If there is no partial byte, we don't want to insert anything
     if (partial_char_len != 0){
         sequence_word.push_back(character(bits_, partial_start_index, partial_char_len));
         partial_start_index += partial_char_len;
     }
  
     /// Create the full bytes.
     for (unsigned int index = partial_start_index; index <= lastIndex; index +=8){
  
         sequence_word.push_back(character(bits_, index, 8));
  
     }
  
     /// Update this for the next iteration of the function.
     nextBitIndex_ = lastIndex + 1;
  
     /// Reverse the byte endianness and write the stream.
     for (std::string::reverse_iterator iter = sequence_word.rbegin();
          iter != sequence_word.rend(); iter++){
  
         stream << *iter;
     }
 }

References bits_, character(), nextBitIndex_, and nextPowerOf2().

Referenced by Bin2nProgramImageWriter::writeImage(), and writeImage().

Here is the call graph for this function:

Member Data Documentation

◆ bits_

const BitVector& Bin2nImageWriter::bits_

private

The bits to be written.

Definition at line 63 of file Bin2nImageWriter.hh.

Referenced by bits(), writeImage(), and writeSequence().

◆ nextBitIndex_

unsigned int Bin2nImageWriter::nextBitIndex_

mutableprivate

The index of the next bit to be written.

Definition at line 67 of file Bin2nImageWriter.hh.

Referenced by writeSequence().

◆ rowLength_

int Bin2nImageWriter::rowLength_

private

The length of a row in the output.

Definition at line 65 of file Bin2nImageWriter.hh.

Referenced by writeImage().

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Bin2nImageWriter()

◆ ~Bin2nImageWriter()

Member Function Documentation

◆ bits()

◆ character()

◆ nextPowerOf2()

◆ writeImage()

◆ writeSequence()

Member Data Documentation

◆ bits_

◆ nextBitIndex_

◆ rowLength_