anchor.diff:        NegOverflow = null;
      
       {ok, InValue} ->
  -      % In normal status, set the main Value output equal to the input value
  -      % Value output is not used to drive 7 segement displays
  -      case format_number(InValue, NumOfDigits, Inputs) of
  -        {ok, DigitsToDisp, Precision} ->
  -          Value = InValue, Status = normal,
  -          
  +      case InValue >= 0.0 of
  +        true -> 
  +          {ok, Precision} = attrib_utils:get_value(Config, pos_precision),
  +          IsPositive = true;
  +    
  +        false -> 
  +          {ok, Precision} = attrib_utils:get_value(Config, neg_precision),
  +          IsPositive = false
  +      end,
  +      
  +      % Just set the output value equal to the string of the input value
  +      % Value is not used to drive 7-Segment display
  +      Value = float_to_list(InValue, [{decimals, Precision}]),
  +      Status = normal,
  +
  +      case check_length(Value, NumOfDigits) of
  +        true ->
  +          % Remove the decimal point, and Pad out the string to the size of the display
  +          InValueStr = unicode:characters_to_nfc_list(string:pad(lists:delete($., Value), NumOfDigits, leading)),
             Digits7SegNoDecPnt = lists:map(fun(Digit) ->
                                 block_utils:char_to_segments(Digit, false)
                                 end,
  -                              DigitsToDisp),
  -                            
  -          DecPntDigitIndex = NumOfDigits - Precision,
  -
  -          DigitWithDecPnt = lists:nth(DecPntDigitIndex, Digits7SegNoDecPnt) bor 16#80,
  -          Digits7Seg = list_replace(Digits7SegNoDecPnt, DigitWithDecPnt, DecPntDigitIndex),
  +                              InValueStr),
  +          
  +          if (Precision > 0) ->
  +            DecPntDigitIndex = NumOfDigits - Precision,
  +            DigitWithDecPnt = lists:nth(DecPntDigitIndex, Digits7SegNoDecPnt) bor 16#80,
  +            Digits7Seg = list_replace(Digits7SegNoDecPnt, DigitWithDecPnt, DecPntDigitIndex);
  +          true ->
  +            Digits7Seg = Digits7SegNoDecPnt
  +          end,
   
             PosOverflow = false,
             NegOverflow = false;
   
  -        {error, too_big, IsNegative} -> 
  -          Value = InValue, Status = normal,
  -          % TODO: create config attributes for user selectable overflow segments to enable
  -          % Set all digits to '-' to indicate overflow condition
  +        false -> % number too big
             Overflow = block_utils:char_to_segments($-, false),
             Digits7Seg = lists:duplicate(NumOfDigits, Overflow),
   
  -          if IsNegative ->
  +          if IsPositive ->
  +            PosOverflow = true,
  +            NegOverflow = false;
  +          true ->
               PosOverflow = false,
  -            NegOverflow = true;
  -          true ->
  -            PosOverflow = true,
  -            NegOverflow = false
  -          end;
  -      
  -        {error, Reason, false} ->
  -          {Value, Status} = input_utils:log_error(Config, precision, Reason),
  -          Digits7Seg = lists:duplicate(NumOfDigits, null),
  -          PosOverflow = null,
  -          NegOverflow = null
  +            NegOverflow = true
  +          end
         end;
   
       {error, Reason} ->
  
positive.code:   attrib_utils:merge_attribute_lists(
      block_common:inputs(),
      [
        {pos_precision, {2, {2}}}, %| int | 2 | 0..num of digits |
        {neg_precision, {1, {1}}}, %| int | 1 | 1..num of digits |
        {input, {empty, {empty}}} %| float | empty | +/- max float |
       ]). 
  
  
  -spec default_outputs() -> output_attribs().
  
negative.code: 
  initialize({Config, Inputs, Outputs, Private}) ->
    % Check the config values
    case config_utils:get_integer_range(Config, num_of_digits, 1, 99) of
      {ok, NumOfDigits} ->
        % Create a digit output for each digit
        Outputs1 = output_utils:resize_attribute_array_value(Outputs, 
                                         digits, NumOfDigits, {null, []}),
        case config_utils:get_integer_range(Config, pos_precision, 0, NumOfDigits) of
          {ok, _PosPrecision} ->
  
            case config_utils:get_integer_range(Config, neg_precision, 0, NumOfDigits) of
              {ok, _NegPrecision} ->
                Value = null, 
                Status = initialed;              
              
              {error, Reason} ->
                {Value, Status} = config_utils:log_error(Config, neg_precision, Reason)
            end;
                
          {error, Reason} ->
            {Value, Status} = config_utils:log_error(Config, pos_precision, Reason)
        end;
      {error, Reason} ->
        Outputs1 = Outputs,
        {Value, Status} = config_utils:log_error(Config, num_of_digits, Reason)      
    end,
  
    Outputs2 = output_utils:set_value_status(Outputs1, Value, Status),
  