Problem $4$: Sequential Circuit Design $(25$ points$)$

You are interviewing to be digital designer at a reputed Semiconductor company. The interviewer

asks you to design a STRING PARSER as a state machine that will take in an input string,

consisting of sign, digits, and blank spaces, to output TRUE $(1)$ if the string only contains

valid integers or output FALSE $(0)$ i valid $=V$

Inputs are blank space $(00),$ sign $(01),$ digit $(10),$ EOF $(11).$ Your output, VALID, returns

$1,$ if the all the rules are preserved and the string only contains valid integers in the correct

order. Otherwise, VALD$=0.$

Norot Sraks

Answer the following questions, based on the above description.

a$)$ What type of finite state machine would you use to implement the STRING PARSER

and cupl.

described above? Show the state transition table of the same. $(7$ points$)$

I will use

a Mealy Machive

becarse "VALIO"

depents diresty

on states and inpus

b$)$ Draw the state machine diagram that describes the functioning of the STRING

PARSER. $(7$ noints$)$

c$)$ How many bits of memory does the state machine design need $($HIN $1$: un$$k about

how many flip flops will be used$)?(3$ points$)$

since there are three states, we need to stare

three states throughont this design. We will requre

three tip flops which means we need to store

$3$ bits of memory for thris design.f it contains anything other than valid integers. For

example, take the string $-73",$ a custom circuit splits this string for you and gives you one

character at a time. The example $"-73"$ has four inputs, "blank, sign, digit, digit". For this

given example, the state machine you design will have to output TRUE $(1),$ because this

string only contains valid integers.

There are four type of input data you need to handle for designing this state machine:

To design this state machine, you need to have three states:

Given these states and inputs, there are rules you must follow to design this STRING PARSER to

determine what is a valid integer, and they are:

You always start from INIT state and reset back to that state if you receive any inputs

out of order.

You are allowed to have any number of blank spaces as inputs if you are in the INIT

state and haven't gotten any other inputs. If you do get a blank space when NOT in

the INIT state, you reset the state of the machine.

If you get a sign input from the INIT state, you move to the SIGNED state and if you

get a digit input from the INIT state, you move to the INTEGER state.

You are ONLY allowed to get the inputs in this order: blank space $$ sign $>$ digit $>$

EOF. In special cases where sign input is not present, blank space $$ digit $$ EOF

order is also accepted. Any other order resets the machine and returns FALSE $(0).$

Once you are in the INTEGER state, you are allowed to get any number of digit inputs

until you receive the EOF, at which point you reset the parser and return TRUE $(1).$

In summary, the states of the STRING PARSER are INIT, SIGNED and INTEGER.

Not sure if what is written is a $100\%$ correct I think that v$4$ should be $1,1,1,1$