Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&gist=

1_Storage.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view returns (uint256){
        return number;
    }
}

2_Owner.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title Owner
 * @dev Set & change owner
 */
contract Owner {

    address private owner;
    
    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);
    
    // modifier to check if caller is owner
    modifier isOwner() {
        // If the first argument of 'require' evaluates to 'false', execution terminates and all
        // changes to the state and to Ether balances are reverted.
        // This used to consume all gas in old EVM versions, but not anymore.
        // It is often a good idea to use 'require' to check if functions are called correctly.
        // As a second argument, you can also provide an explanation about what went wrong.
        require(msg.sender == owner, "Caller is not owner");
        _;
    }
    
    /**
     * @dev Set contract deployer as owner
     */
    constructor() public {
        owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
        emit OwnerSet(address(0), owner);
    }

    /**
     * @dev Change owner
     * @param newOwner address of new owner
     */
    function changeOwner(address newOwner) public isOwner {
        emit OwnerSet(owner, newOwner);
        owner = newOwner;
    }

    /**
     * @dev Return owner address 
     * @return address of owner
     */
    function getOwner() external view returns (address) {
        return owner;
    }
}

3_Ballot.sol

pragma solidity >=0.4.22 <0.7.0;

/** 
 * @title Ballot
 * @dev Implements voting process along with vote delegation
 */
contract Ballot {
   
    struct Voter {
        uint weight; // weight is accumulated by delegation
        bool voted;  // if true, that person already voted
        address delegate; // person delegated to
        uint vote;   // index of the voted proposal
    }

    struct Proposal {
        // If you can limit the length to a certain number of bytes, 
        // always use one of bytes1 to bytes32 because they are much cheaper
        bytes32 name;   // short name (up to 32 bytes)
        uint voteCount; // number of accumulated votes
    }

    address public chairperson;

    mapping(address => Voter) public voters;

    Proposal[] public proposals;

    /** 
     * @dev Create a new ballot to choose one of 'proposalNames'.
     * @param proposalNames names of proposals
     */
    constructor(bytes32[] memory proposalNames) public {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;

        for (uint i = 0; i < proposalNames.length; i++) {
            // 'Proposal({...})' creates a temporary
            // Proposal object and 'proposals.push(...)'
            // appends it to the end of 'proposals'.
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }
    
    /** 
     * @dev Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.
     * @param voter address of voter
     */
    function giveRightToVote(address voter) public {
        require(
            msg.sender == chairperson,
            "Only chairperson can give right to vote."
        );
        require(
            !voters[voter].voted,
            "The voter already voted."
        );
        require(voters[voter].weight == 0);
        voters[voter].weight = 1;
    }

    /**
     * @dev Delegate your vote to the voter 'to'.
     * @param to address to which vote is delegated
     */
    function delegate(address to) public {
        Voter storage sender = voters[msg.sender];
        require(!sender.voted, "You already voted.");
        require(to != msg.sender, "Self-delegation is disallowed.");

        while (voters[to].delegate != address(0)) {
            to = voters[to].delegate;

            // We found a loop in the delegation, not allowed.
            require(to != msg.sender, "Found loop in delegation.");
        }
        sender.voted = true;
        sender.delegate = to;
        Voter storage delegate_ = voters[to];
        if (delegate_.voted) {
            // If the delegate already voted,
            // directly add to the number of votes
            proposals[delegate_.vote].voteCount += sender.weight;
        } else {
            // If the delegate did not vote yet,
            // add to her weight.
            delegate_.weight += sender.weight;
        }
    }

    /**
     * @dev Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.
     * @param proposal index of proposal in the proposals array
     */
    function vote(uint proposal) public {
        Voter storage sender = voters[msg.sender];
        require(sender.weight != 0, "Has no right to vote");
        require(!sender.voted, "Already voted.");
        sender.voted = true;
        sender.vote = proposal;

        // If 'proposal' is out of the range of the array,
        // this will throw automatically and revert all
        // changes.
        proposals[proposal].voteCount += sender.weight;
    }

    /** 
     * @dev Computes the winning proposal taking all previous votes into account.
     * @return winningProposal_ index of winning proposal in the proposals array
     */
    function winningProposal() public view
            returns (uint winningProposal_)
    {
        uint winningVoteCount = 0;
        for (uint p = 0; p < proposals.length; p++) {
            if (proposals[p].voteCount > winningVoteCount) {
                winningVoteCount = proposals[p].voteCount;
                winningProposal_ = p;
            }
        }
    }

    /** 
     * @dev Calls winningProposal() function to get the index of the winner contained in the proposals array and then
     * @return winnerName_ the name of the winner
     */
    function winnerName() public view
            returns (bytes32 winnerName_)
    {
        winnerName_ = proposals[winningProposal()].name;
    }
}

mainNet.sol

pragma solidity >=0.4.22 <0.7.0;
pragma experimental ABIEncoderV2;

// "SPDX-License-Identifier: UNLICENSED"



contract MainContract{
    
    address owner;
    uint256 public sensorCounter;
    uint256 public dataCounter;
    mapping(uint256=>Sensor) public sensorList; // sensorId -> Sensor
    mapping(uint256=>Data) public dataList; // dataId -> Data
    mapping(string=>uint256) public timeToData; // timein string format -> Data 
    // address[] public ownerList;
    
    // mapping(uint256 => address) sensorOwnerList;
    
    modifier onlyOwner(){
        require(msg.sender == owner, "Caller is not owner");
        _;
    }
    
    constructor() public payable{
        owner = msg.sender;
        sensorCounter = 0;
    }
    
    // struct sensorOwner{
    //     uint256 ownerId;
    //     uint256[] sensorList; // Sensor Id 
    // }
    
    struct Sensor{
        uint256 sensorId;
        uint256 sensorType;
        uint256[] sensorDataList;
    }
    
    struct Data{
        uint256 dataId;
        uint256 sensorId;
        uint256 date; // yyyymmdd
        uint256 hour; // 24 hours
        uint256 minute; // 60 minutes
        uint256[] datas; // array of data -> index=>sensorreading; Ex. 0 -> 15.6 
    }
    
    function numberToString(uint v) public returns (string memory) {
        
        uint length = v/1000 >0 ? 64 : 16;
        
        bytes memory reversed = new bytes(length);
        
        uint i = 0;
        
        while (v != 0) {
            uint remainder = v % 10;
            v = v / 10;
            reversed[i++] = byte(48 + uint8(remainder));
        }
        
        bytes memory s = new bytes(i + 1);
        
        for (uint j = 0; j <= i; j++) {
            s[j] = reversed[i - j];
        }
        
        return string(s);
    }
    
    function append(string memory a, string memory b, string memory c) public pure returns(string memory){
        return string(abi.encodePacked(a, b, c));
    }
    
    function dateTime(uint256 _date, uint256 _hour, uint256 _minute) public returns(string memory){
        string memory tempDate = numberToString(_date);
        
        string memory tempHour = numberToString(_hour);
        
        string memory tempMinutes = numberToString(_minute);
        
        return append(tempDate,tempHour,tempMinutes);
    }
    
    
    function createData(uint256 _sensorId, uint256 _date, uint256 _hour, uint256 _minute, uint256[] memory _datas) public payable {
        Data memory tempData = Data(dataCounter, _sensorId, _date, _hour, _minute, _datas);
        dataList[dataCounter] = tempData;
        sensorList[_sensorId].sensorDataList.push(dataCounter);
        timeToData[dateTime(_date,_hour,_minute)] = dataCounter;
        dataCounter++;
    }
    
    function getData(uint256 _dataId) public view returns(Data memory){
        Data memory tempData = dataList[_dataId];
        return tempData;
    }
    
    function createSensor(uint256 _sensorType) public payable onlyOwner{
        uint256 _sensorId = sensorCounter;
        uint256[] memory notData;
        Sensor memory tempSensor = Sensor(_sensorId,_sensorType, notData);
        sensorCounter++;
        sensorList[_sensorId] = tempSensor;
    }
    
    function getSensor(uint256 _sensorId) public view returns(uint256[][] memory){
        Sensor memory tempSensor = sensorList[_sensorId] ;
        uint256 size = tempSensor.sensorDataList.length;
        
        uint256[][] memory temp = new uint256[][](size);
        
        for (uint i=0; i < size; i++) {
            
            Data memory tempData = dataList[tempSensor.sensorDataList[i]];
            
            uint256 len = tempData.datas.length;
            
            uint256[] memory arr = new uint256[](len);
            
            arr = tempData.datas;
            
            temp[i] = arr;
        }
        
        return temp;
    }
    
    // function getData(uint256 _dataId) public view returns(uint256, uint256, uint256, uint256, uint256[] memory){
        
    // }
    
    
    
    // function getTime(uint256 _date, uint256 _hour, uint256 _minute) public pure returns(uint256){
        
    //     uint256 tempTime = _date * 10000;
        
    //     tempTime+= _hour * 100;
        
    //     tempTime+= _minute;
        
    //     return tempTime;
    // }
    
    // function createData(uint256 _sensorId, uint256 _date, uint256 _hour, uint256 _minute, uint256[] memory _datas) public payable {
        
    //     uint256 Time = getTime(_date, _hour, _minute);
        
    //     dataset[_sensorId].sensorData[Time] = _datas;
    //     dataset[_sensorId].dataCount++;
        
    // }
    
    // function createSensor(string memory _sensorName) public payable onlyOwner{
        
    //     Sensor memory tempSensor = Sensor(sensorCounter, _sensorName, 0);
        
    //     dataset[sensorCounter]=tempSensor;
        
    //     sensorCounter++;
        
    // }
    
    // function getData(uint256 _sensorId, uint256 _date, uint256 _hour, uint256 _minute) public view returns(uint256[] memory){
         
    //      uint256 time = getTime(_date,_hour,_minute);
         
    //      return dataset[_sensorId].sensorData[time];
         
    // }

    // function getSensor(uint256 _sensorId) public view returns(uint256[] memory){
        
    //     Sensor memory tempSensor = dataset[_sensorId];
        
    //     uint256[] memory memoryArray = new uint256[](tempSensor.dataCount);
        
    //     for(uint256 i=0;i<tempSensor.dataCount;i++){
            
    //     }
        
    // }
    
}

testNet.sol

pragma solidity >=0.4.22 <0.7.0;
pragma experimental ABIEncoderV2;

// "SPDX-License-Identifier: UNLICENSED"

contract MainContract{

    address owner;
    uint256 public sensorCounter;
    uint256 public dataCounter;
    mapping(uint256=>Sensor) public sensorList; // sensorId -> Sensor
    mapping(uint256=>Data) public dataList; // dataId -> Data
    mapping(string=>uint256) public timeToData; // timein string format -> Data

    // address[] public ownerList;

    // mapping(uint256 => address) sensorOwnerList;

    modifier onlyOwner(){
        require(msg.sender == owner, "Caller is not owner");
        _;
    }

    constructor() public payable{
        owner = msg.sender;
        sensorCounter = 0;
    }

    // struct sensorOwner{
    //     uint256 ownerId;
    //     uint256[] sensorList; // Sensor Id
    // }

    struct Sensor{
        uint256 sensorId;
        string _sensorString;
        uint256[] sensorDataList;
    }
    
    struct Data{
        uint256 dataId;
        uint256 sensorId;
        string date; // yyyymmdd
        string hour; // 24 hours
        string minute; // 60 minutes
        uint256[] datas; // array of data -> index=>sensorreading; Ex. 0 -> 15.6
    }

    function dateToString(string memory _date, string memory _hour, string memory _minute) public pure returns(string memory){
        // return string(abi.encodePacked(_date, _hour, _minute));

        bytes memory _ba = bytes(_date);
        bytes memory _bb = bytes(_hour);
        bytes memory _bc = bytes(_minute);
        string memory abcde = new string(_ba.length + _bb.length + _bc.length);
        bytes memory babcde = bytes(abcde);
        uint k = 0;

        for (uint i = 0; i < _ba.length; i++) {
            babcde[k++] = _ba[i];
        }

        for(uint i = 0; i < _bb.length; i++){
            babcde[k++] = _bb[i];
        }

        for(uint i = 0; i < _bc.length; i++){
            babcde[k++] = _bc[i];
        }

        return string(babcde);
    }

    function createData(uint256 _sensorId, string memory _date, string memory _hour, string memory _minute, uint256[] memory _datas) public payable returns(uint256) {
        Data memory tempData = Data(dataCounter, _sensorId, _date, _hour, _minute, _datas);
        dataList[dataCounter] = tempData;
        sensorList[_sensorId].sensorDataList.push(dataCounter);
        timeToData[dateToString(_date, _hour, _minute)] = dataCounter;
        dataCounter++;
        return tempData.dataId;
    }

    function getData(uint256 _dataId) public view returns(uint256[] memory){
        Data memory tempData = dataList[_dataId];
        return tempData.datas;
    }

    function createSensor(string memory _sensorString) public payable onlyOwner returns(uint256)  {
        uint256 _sensorId = sensorCounter;
        uint256[] memory notData;
        Sensor memory tempSensor = Sensor(_sensorId, _sensorString, notData);
        sensorCounter++;
        sensorList[_sensorId] = tempSensor;
        return _sensorId;
    }

    function getSensorById(uint256 _sensorId) public view returns(uint256[][] memory){
        Sensor memory tempSensor = sensorList[_sensorId];
        uint256 size = tempSensor.sensorDataList.length;

        uint256[][] memory temp = new uint256[][](size);

        for (uint i = 0; i < size; i++) {
            Data memory tempData = dataList[tempSensor.sensorDataList[i]];
            uint256 len = tempData.datas.length;
            uint256[] memory arr = new uint256[](len);
            arr = tempData.datas;
            temp[i] = arr;
        }
        return temp;
    }

    function getSenesorList() public view returns(string[] memory){
        string[] memory tempSensorList;

        for(uint i = 0; i < sensorCounter; i++){
            Sensor memory tempSensor = sensorList[i];
            tempSensorList[i] = tempSensor._sensorString;
        }

        return tempSensorList;
    }
}