Class: HDLRuby::High::SignalI

Inherits:
Low::SignalI show all
Includes:
HRef, SimSignal, WithFullname
Defined in:
lib/HDLRuby/hruby_high.rb,
lib/HDLRuby/hruby_rsim.rb,
lib/HDLRuby/hruby_rcsim.rb,
lib/HDLRuby/hruby_high_fullname.rb

Overview

Describes a signal.

Constant Summary collapse

High = 
HDLRuby::High
DIRS =

The valid bounding directions.

[ :no, :input, :output, :inout, :inner ]

Constants included from Low::Low2Symbol

Low::Low2Symbol::Low2SymbolPrefix, Low::Low2Symbol::Low2SymbolTable, Low::Low2Symbol::Symbol2LowTable

Instance Attribute Summary collapse

Attributes included from SimSignal

#c_value, #f_value

Attributes inherited from Low::SignalI

#name, #type, #value

Attributes included from Low::Hparent

#parent

Instance Method Summary collapse

Methods included from WithFullname

#fullname

Methods included from SimSignal

#add_anyedge, #add_negedge, #add_posedge, #assign, #assign_at, #each_anyedge, #each_negedge, #each_posedge, #execute, #fullname, #get_vars_with_fullname, #get_vars_with_idstr, #init_sim, #show_hierarchy

Methods included from HRef

#each, included, #objects, #to_event

Methods included from Enumerable

#seach

Methods inherited from Low::SignalI

#add_signal, #clone, #each_deep, #each_signal, #explicit_types!, #get_by_name, #get_signal, #immutable?, #replace_names!, #set_name!, #set_type!, #set_value!, #to_c, #to_c_alias, #to_c_signal, #to_ch, #to_hdr, #to_high, #to_verilog, #to_vhdl, #width

Methods included from Low::Low2Symbol

#to_sym

Methods included from Low::Hparent

#hierarchy, #no_parent!, #scope

Constructor Details

#initialize(name, type, dir, value = nil) ⇒ SignalI

Creates a new signal named +name+ typed as +type+ with +dir+ as bounding direction and possible +value+.

NOTE: +dir+ can be :input, :output, :inout or :inner



3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
3876
3877
3878
3879
3880
3881
3882
3883
 
# File 'lib/HDLRuby/hruby_high.rb', line 3850

def initialize(name,type,dir,value =  nil)
    # Check the value.
    value = value.to_expr.match_type(type) if value
    # Initialize the type structure.
    super(name,type,value)

    unless name.empty? then
        # Named signal, set the hdl-like access to the signal.
        obj = self # For using the right self within the proc
        High.space_reg(name) { obj }
    end

    # Hierarchical type allows access to sub references, so generate
    # the corresponding methods.
    # For that first get the real type.
    type = type.def while type.is_a?(TypeDef)
    # Now process it if it is a structured type.
    if type.struct? then
        type.each_name do |name|
            sig = SignalI.new(name,type.get_type(name),dir)
            self.add_signal(sig)
            self.define_singleton_method(name) do
                RefObject.new(self.to_ref,sig)
            end
        end
    end

    # Check and set the bound.
    self.dir = dir

    # Set the read and write authorisations.
    @can_read = 1.to_expr
    @can_write = 1.to_expr
end

Instance Attribute Details

#can_read ⇒ Object

Tells if the signal can be read.



3841
3842
3843
 
# File 'lib/HDLRuby/hruby_high.rb', line 3841

def can_read
  @can_read
end

#can_write ⇒ Object

Tells if the signal can be written.



3844
3845
3846
 
# File 'lib/HDLRuby/hruby_high.rb', line 3844

def can_write
  @can_write
end

#dir ⇒ Object

The bounding direction.



3838
3839
3840
 
# File 'lib/HDLRuby/hruby_high.rb', line 3838

def dir
  @dir
end

#rcsignalI ⇒ Object (readonly)

Extends the SignalI class for hybrid Ruby-C simulation.



424
425
426
 
# File 'lib/HDLRuby/hruby_rcsim.rb', line 424

def rcsignalI
  @rcsignalI
end

Instance Method Details

#anyedge ⇒ Object

Creates an edge event from the signal.



3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
 
# File 'lib/HDLRuby/hruby_high.rb', line 3930

def anyedge
    # return Event.new(:edge,self.to_ref)
    # Is there any sub signals?
    if self.each_signal.any? then
        # Yes, make events with them instead.
        return self.each_signal.map { |sig| sig.anyedge }
    else
        # No, create a single event.
        return Event.new(:anyedge,self.to_ref)
    end
end

#coerce(obj) ⇒ Object

Coerce by converting signal to an expression.



3953
3954
3955
 
# File 'lib/HDLRuby/hruby_high.rb', line 3953

def coerce(obj)
    return [obj,self.to_expr]
end

#negedge ⇒ Object

Creates a negative edge event from the signal.



3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
 
# File 'lib/HDLRuby/hruby_high.rb', line 3917

def negedge
    # return Event.new(:negedge,self.to_ref)
    # Is there any sub signals?
    if self.each_signal.any? then
        # Yes, make events with them instead.
        return self.each_signal.map { |sig| sig.negedge }
    else
        # No, create a single event.
        return Event.new(:negedge,self.to_ref)
    end
end

#posedge ⇒ Object

Creates a positive edge event from the signal.



3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
 
# File 'lib/HDLRuby/hruby_high.rb', line 3904

def posedge
    # return Event.new(:posedge,self.to_ref)
    # Is there any sub signals?
    if self.each_signal.any? then
        # Yes, make events with them instead.
        return self.each_signal.map { |sig| sig.posedge }
    else
        # No, create a single event.
        return Event.new(:posedge,self.to_ref)
    end
end

#to_expr ⇒ Object

Converts to a new expression.



3948
3949
3950
 
# File 'lib/HDLRuby/hruby_high.rb', line 3948

def to_expr
    return self.to_ref
end

#to_low(name = self.name) ⇒ Object

Converts the system to HDLRuby::Low and set its +name+.



3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968
3969
3970
 
# File 'lib/HDLRuby/hruby_high.rb', line 3958

def to_low(name = self.name)
    # return HDLRuby::Low::SignalI.new(name,self.type.to_low)
    valueL = self.value ? self.value.to_low : nil
    signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low,valueL)
    # Recurse on the sub signals if any.
    self.each_signal do |sig|
        signalIL.add_signal(sig.to_low)
    end
    # # For debugging: set the source high object 
    # signalIL.properties[:low2high] = self.hdr_id
    # self.properties[:high2low] = signalIL
    return signalIL
end

#to_rcsim(rcowner) ⇒ Object

Generate the C description of the signal comming from object whose C description is +rcowner+



428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
 
# File 'lib/HDLRuby/hruby_rcsim.rb', line 428

def to_rcsim(rcowner)
    # Create the signal C object.
    @rcsignalI = RCSim.rcsim_make_signal(self.name.to_s,
                                   self.type.to_rcsim)
    # puts "to_rcsim for signal=(#{self.name})#{self}, @rcsignalI=#{@rcsignalI}"

    # Set the owner.
    RCSim.rcsim_set_owner(@rcsignalI,rcowner)

    # Create and add the sub signals if any.
    RCSim.rcsim_add_signal_signals(@rcsignalI,
                                   self.each_signal.each.map do |sig|
        sig.to_rcsim(@rcsignalI)
    end)

    # Set the initial value if any.
    if self.value then
        RCSim.rcsim_set_signal_value(@rcsignalI,self.value.to_rcsim)
    end

    return @rcsignalI
end

#to_ref ⇒ Object

Converts to a new reference.



3943
3944
3945
 
# File 'lib/HDLRuby/hruby_high.rb', line 3943

def to_ref
    return RefObject.new(this,self)
end