Thanks for answering! I’ve done what you tell me and I thought of using my two models like follows:
class WifiDNN(nn.Module):
    input_size = input_size
    output_size = num_positions
    input_channels = 1
    fcl1_size = 200
    fcl2_size = 200
    fcl3_size = 200

    def __init__(self):
        super(WifiDNN, self).__init__()
        # Define the fully connected layers
        self.fcl1 = nn.Linear(self.input_size, self.fcl1_size)
        self.fcl2 = nn.Linear(self.fcl1_size, self.fcl2_size)
        self.fcl3 = nn.Linear(self.fcl2_size, self.fcl3_size)
        self.output = nn.Linear(self.fcl3_size, self.output_size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        # Fully connected layers
        x = self.fcl1(x)
        x = self.fcl2(x)
        x = self.dropout(x)
        x = self.fcl3(x)
        x = self.output(x)

        return x

encoder_net = WifiDNN()
encoder_net.load_state_dict(torch.load('guada_withvalid_DNN'))

class WifiRNN(nn.Module):
    def __init__(self, i_size, h_size, n_layers, num_classes):
        super(WifiRNN, self).__init__()
        self.input_size = i_size
        self.hidden_size = h_size
        self.num_layers = n_layers
        self.num_classes = num_classes

        self.wifi_rnn = nn.RNN(input_size=self.num_classes, hidden_size=self.hidden_size, num_layers=self.num_layers,
                               batch_first=True)
        self.out = nn.Linear(in_features=self.hidden_size * sequence_length, out_features=self.num_classes)

    def forward(self, x_in, h_state):
        r_out, h_state = self.wifi_rnn(x_in, h_state)
        r_out = r_out.reshape(r_out.shape[0], -1)
        out = self.out(r_out)
        return out, h_state

    def init_hidden_state(self, b_size):
        h0 = torch.zeros(self.num_layers, b_size, self.hidden_size).to(device)
        return h0


# neural network architecture definition
class WifiNNMix(nn.Module):
    def __init__(self, model_trained, model_rnn, seq_len, cols):
        super(WifiNNMix, self).__init__()
        self.encoder = model_trained
        self.rnnNet = model_rnn
        self.seq_len = seq_len
        self.col = cols

    def forward(self, x_in, state):
        out_1 = self.encoder(x_in)
        out_1 = out_1.reshape(-1, self.seq_len, self.col)
        out_2, state = self.rnnNet(out_1, state)
        return out_2, state

    def init_hidden_state(self, b_size):
        h0 = torch.zeros(self.num_layers, b_size, self.hidden_size).to(device)
        return h0

rnn = WifiRNN(input_size, hidden_size, num_layers, num_positions).to(device)
model = WifiNNMix(encoder_net, rnn, sequence_length,num_positions).to(device)
print(model)

being the output size of the encoder the input size of the RNN, is this idea correct? After that I froze the encoder parameter so the backprop does not actualize them. Is that correct too?
for param in model.encoder.parameters():
    param.requires_grad = False

Thanks a lot!!