LPP » INSTRU » Solar Orbiter LFR » LFR-FSW

# -*- coding: utf-8 *-*

################################################################################

# activateLfrMode

# SVS-0034 (REQ-LFR-SRS-5509)

# SSS-CP-FS-320

################################################################################

# execfile('/opt/PYTHON/lfrverif/LFR_SVS/SVS-0034/activateLfrModeTiming.py')

#import sys

## To ensure the imported modified files are properly reloaded.

#for mod in sys.modules.values():

    #strmod = str(mod)

    #if not ('\'PythonQt' in strmod) and not ('\'sys\'' in strmod) and \

        #not ('\'pygments.' in strmod) and \

        #not ('\'__main__\'' in strmod) and not ('\'paste\'' in strmod) and \

        #not ('\'/usr/lib64/python2.7/' in strmod) and not(mod is None):

    ##if ('\'lfrverif' in strmod):

        #print mod

        #reload(mod)

import inspect

from lfrverif.common.param import *

#import time

#from datetime import datetime

import time

import lfrcompliance.common.socfunctions as socfunctions

import lfrcompliance.tcpackets.telecommands as tc

from   lfrcompliance.tcpackets.constants import *

import lfrcompliance.common.general_functions as gen

# fonction renommee pour ne pas utilisee celle de /opt/PYTHON_PLE

# Repertoire qui evolue en temps-reel

def my_setTimeGenval( soc ):

        # flush the transmission before changing the spacewire link

        soc.flushTCTransmission()

        soc.setSpaceWireLink( 2 )

        # get the local time with the following reference date: Jan 01 2000

        #localTime = gen.getLocalTimeInDPUFormat()

        # Utiliser la bonne fct de paul qui prend un argument

        localTime = 457571799

        # build the TC that will be sent to the timegen system

        tcUpdateTime = tc.TCLFRUpdateTime(DEFAULT_SEQUENCE_COUNT, RPW_INTERNAL, localTime)

        # send the local time to the system time generator

        soc.sendTC( tcUpdateTime )

        # flush the transmission before changing the spacewire link

        soc.flushTCTransmission()

        soc.setSpaceWireLink( 1 )

# setting up LPPMON plugins

from __main__ import proxy

if not(proxy.instanceExists("SpwPlugin0")):

        proxy.loadSysDriver("SpwPlugin","SpwPlugin0")

        SpwPlugin0.selectBridge("STAR-Dundee Spw USB Brick")

        proxy.loadSysDriverToParent("dsu3plugin","SpwPlugin0")

        proxy.loadSysDriverToParent("LFRControlPlugin","SpwPlugin0")

        availableBrickCount = SpwPlugin0.StarDundeeGetAvailableBrickCount()

        print str(availableBrickCount) + " SpaceWire brick(s) found"

        SpwPlugin0.StarDundeeSelectBrick(1)

        SpwPlugin0.StarDundeeSetBrickAsARouter(1)

        SpwPlugin0.connectBridge()

        #SpwPlugin0.TCPServerSetIP("127.0.0.1")

        SpwPlugin0.TCPServerConnect()

        # OPEN SPACEWIRE SERVER

        #LFRControlPlugin0.SetSpwServerIP(129,104,27,164)

        LFRControlPlugin0.TCPServerConnect()

        # OPEN TM ECHO BRIDGE SERVER

        LFRControlPlugin0.TMEchoBridgeOpenPort()

        # LOAD TIMEGEN USING  LINK 2

        SpwPlugin0.StarDundeeSelectLinkNumber( 2 )

        dsu3plugin0.openFile(TIMEGEN_PATH)

        dsu3plugin0.loadFile()

        dsu3plugin0.run()

        # LOAD FSW USING LINK 1

        SpwPlugin0.StarDundeeSelectLinkNumber( 1 )

        dsu3plugin0.openFile(LFR_FSW_PATH)

        dsu3plugin0.loadFile()

        dsu3plugin0.run()

        # START SENDING TIMECODES AT 1 Hz

        SpwPlugin0.StarDundeeStartTimecodes( 1 )

from __main__ import SpwPlugin0

from lfrverif.common.actions_tc_lfr_launcher import *

from lfrverif.common.test_monitor import time_sent

from lfrverif.common.miscellaneous.fun_misc import *

current_file = inspect.currentframe().f_code.co_filename

test_launcher = TestLauncher(LFRControlPlugin0)

test_launcher.test_monitor.log_memo(current_file)

test_launcher.test_monitor.progress_memo += (

    "SocExplorerEngine.getSocExplorer: Version = " + SocExplorerEngine.getSocExplorerVersion() +

    ", Branch = " + SocExplorerEngine.getSocExplorerBranch() +

    ", Changeset = " + SocExplorerEngine.getSocExplorerChangeset() + '\n')

ACK_EXECUTION_COMPLETION = 1

ACK_ACCEPTANCE = 1

SOURCE_ID = SOURCE_ID_ENUM[0]

rk10 = SPW_HEADER_SIZE + 10

rk11 = SPW_HEADER_SIZE + 11

rk12 = SPW_HEADER_SIZE + 12

rk14 = SPW_HEADER_SIZE + 14

rk16 = SPW_HEADER_SIZE + 16

rk18 = SPW_HEADER_SIZE + 18

log_time = ""

# Gerald dit de remplacer cette code

#postponeNextTimeBeforeTc(1)

surveyAnyTmPacket(test_launcher, 1)

tc_lfr_enter_mode = TcLfrEnterMode()

tc_lfr_update_time = TcLfrUpdateTime()

init_tc_header([tc_lfr_enter_mode, tc_lfr_update_time],

    ACK_EXECUTION_COMPLETION, ACK_ACCEPTANCE, SOURCE_ID)

# For this TC, Msb of byte 11 is used (for spare)

spare = tc_lfr_enter_mode.SpW[SPW_HEADER_SIZE + 11] & 0xf0

# Initial mode is NORMAL (ie cp_lfr_mode=1):

tc_lfr_enter_mode.SpW[rk11] = spare | 1

tc_lfr_enter_mode.ComputeCrc()

#tc_lfr_enter_mode.SpW[rk12:rk18] = CUC0[:]

dispCrcSendSpwTcWaitVerifPkt(test_launcher, tc_lfr_enter_mode)

surveyAnyTmPacket(test_launcher, 2)  # delay to verify the current mode

#    cp_rpw_time_aux = 0x7fffffff & random.randrange(0xffffffff)

#    tc_lfr_update_time.SpW[rk10:rk14] =\

#        [(cp_rpw_time_aux >> 24) & 0xff, (cp_rpw_time_aux >> 16) & 0xff,

#        (cp_rpw_time_aux >> 8) & 0xff, cp_rpw_time_aux & 0xff]

#    tc_lfr_update_time.ComputeCrc()

#    displayInfoSendTc(test_launcher, tc_lfr_update_time)

#    surveyAnyTmPacket(test_launcher, SY_RPW_CTR_FREQUENCY)

# je me mets au 1er juillet 2014

# 23h10 = 0x1B45 FD97 0000

# en decimal 457571799

# create a SocFunction object to access SocEplorer

soc = socfunctions.SocFunctions( LFRControlPlugin0, SpwPlugin0 )

my_setTimeGenval( soc )

# Wait to time takes place

surveyAnyTmPacket(test_launcher, 5)

#tc_lfr_update_time.SpW[rk10:rk14] = [ 0x1B,0x45,0xfd,0x97]

#tc_lfr_update_time.ComputeCrc()

#dispCrcSendSpwTcSurvey(test_launcher, tc_lfr_update_time)

#surveyAnyTmPacket(test_launcher, .3)

#RMAPPlugin0.sendOneTimecode()

surveyAnyTmPacket(test_launcher, 340)

f_detail = open('lfr_internal_time.txt', 'w')

f_detail.write(log_time)

f_detail.close()

# Final mode in STANDBY (ie cp_lfr_mode=0):

tc_lfr_enter_mode.SpW[rk11] = spare

tc_lfr_enter_mode.SpW[rk12:rk18] = CUC0[:]

dispCrcSendSpwTcWaitVerifPkt(test_launcher, tc_lfr_enter_mode)

surveyAnyTmPacket(test_launcher, 1)  # delay to verify the current mode

test_launcher.test_monitor.log_memo("End(" + current_file + ")")

test_launcher.test_monitor.archivalRecord()