HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/LFR_FSW Commit - r112:5b5da8d2c053

the interrupt sub routine related to the waveform picker is now lighter...

paul -

r112:5b5da8d2c053 VHDLib206

parent child

Context file:

r112:5b5da8d2c053

Collapse all files

FSW-qt/fsw-qt.pro.user +1 -1

             <?xml version="1.0" encoding="UTF-8"?>
             <!DOCTYPE QtCreatorProject>
-            <!-- Written by QtCreator 3.0.1, 2014-03-28T16:51:27. -->
+            <!-- Written by QtCreator 3.0.1, 2014-03-31T06:56:28. -->
             <qtcreator>
              <data>
               <variable>ProjectExplorer.Project.ActiveTarget</variable>

header/fsw_params.h 0 -5

             #define REGS_ADDR_TIME_MANAGEMENT   0x80000600
             #define REGS_ADDR_GRGPIO            0x80000b00
-            #ifdef VHDL_DEV
             #define REGS_ADDR_SPECTRAL_MATRIX   0x80000f00
             #define REGS_ADDR_WAVEFORM_PICKER   0x80000f40
-            #else
-            #define REGS_ADDR_SPECTRAL_MATRIX   0x80000f00
-            #define REGS_ADDR_WAVEFORM_PICKER   0x80000f20
-            #endif
             #define APBUART_CTRL_REG_MASK_DB    0xfffff7ff
             #define APBUART_CTRL_REG_MASK_TE    0x00000002

header/fsw_params_nb_bytes.h +4 -5

             #ifndef TM_BYTE_POSITIONS_H
             #define TM_BYTE_POSITIONS_H
-            #define BYTE_POS_CP_LFR_MODE 11
             // TC_LFR_LOAD_COMMON_PAR
             // TC_LFR_LOAD_NORMAL_PAR
             // TC_LFR_LOAD_SBM2_PAR
             // TC_LFR_UPDATE_INFO
-            #define BYTE_POS_HK_UPDATE_INFO_PAR_SET5    24  // 34 - 10
+            #define BYTE_POS_UPDATE_INFO_PARAMETERS_SET5    34
-            #define BYTE_POS_HK_UPDATE_INFO_PAR_SET6    25  // 35 - 10
+            #define BYTE_POS_UPDATE_INFO_PARAMETERS_SET6    35
             // TC_LFR_ENTER_MODE
-            #define BYTE_POS_CP_LFR_ENTER_MODE_TIME     2   // 12 - 10
+            #define BYTE_POS_CP_MODE_LFR_SET            11
+            #define BYTE_POS_CP_LFR_ENTER_MODE_TIME     12
             #endif // TM_BYTE_POSITIONS_H

header/tc_acceptance.h +1 -1

             //*********************
             // ACCEPTANCE FUNCTIONS
-            int tc_parser(ccsdsTelecommandPacket_t * TCPacket, unsigned int TC_LEN_RCV, unsigned char *computed_CRC);
+            int tc_parser( ccsdsTelecommandPacket_t * TCPacket, unsigned int estimatedPacketLength, unsigned char *computed_CRC );
             int tc_check_type( unsigned char packetType );
             int tc_check_type_subtype( unsigned char packetType, unsigned char packetSubType );
             int tc_check_sid( unsigned char sid );

header/tm_lfr_tc_exe.h +1 -1

                                                 unsigned char byte_position, unsigned char rcv_value );
             int send_tm_lfr_tc_exe_not_executable( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
             int send_tm_lfr_tc_exe_not_implemented( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time );
-            int send_tm_lfr_tc_exe_error( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time );
+            int send_tm_lfr_tc_exe_error(ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
             int send_tm_lfr_tc_exe_corrupted( ccsdsTelecommandPacket_t *TC, rtems_id queue_id,
                                              unsigned char *computed_CRC, unsigned char *currentTC_LEN_RCV, unsigned char destinationID );

src/fsw_init.c +1 -1

             void reset_local_time( void )
             {
+                time_management_regs->coarse_time_load = 0x80000000;
             }
             void create_names( void ) // create all names for tasks and queues

src/fsw_spacewire.c +6 -6

                 unsigned char computed_CRC[ 2 ];
                 unsigned char currentTC_LEN_RCV[ 2 ];
                 unsigned char destinationID;
-                unsigned int currentTC_LEN_RCV_AsUnsignedInt;
+                unsigned int estimatedPacketLength;
                 unsigned int parserCode;
                 rtems_status_code status;
                 rtems_id queue_recv_id;
                             PRINTF("in RECV *** packet lenght too short\n")
                         }
                         else {
-                            currentTC_LEN_RCV_AsUnsignedInt = (unsigned int) (len - CCSDS_TC_TM_PACKET_OFFSET - 3); // => -3 is for Prot ID, Reserved and User App bytes
+                            estimatedPacketLength = (unsigned int) (len - CCSDS_TC_TM_PACKET_OFFSET - 3); // => -3 is for Prot ID, Reserved and User App bytes
-                            currentTC_LEN_RCV[ 0 ] = (unsigned char) (currentTC_LEN_RCV_AsUnsignedInt >> 8);
+                            currentTC_LEN_RCV[ 0 ] = (unsigned char) (estimatedPacketLength >> 8);
-                            currentTC_LEN_RCV[ 1 ] = (unsigned char) (currentTC_LEN_RCV_AsUnsignedInt     );
+                            currentTC_LEN_RCV[ 1 ] = (unsigned char) (estimatedPacketLength     );
                             // CHECK THE TC
-                            parserCode = tc_parser( &currentTC, currentTC_LEN_RCV_AsUnsignedInt, computed_CRC ) ;
+                            parserCode = tc_parser( &currentTC, estimatedPacketLength, computed_CRC ) ;
                             if ( (parserCode == ILLEGAL_APID)       || (parserCode == WRONG_LEN_PKT)
                                  || (parserCode == INCOR_CHECKSUM)  || (parserCode == ILL_TYPE)
                                  || (parserCode == ILL_SUBTYPE)     || (parserCode == WRONG_APP_DATA)
                             else
                             { // send valid TC to the action launcher
                                 status =  rtems_message_queue_send( queue_recv_id, &currentTC,
-                                                                    currentTC_LEN_RCV_AsUnsignedInt + CCSDS_TC_TM_PACKET_OFFSET + 3);
+                                                                    estimatedPacketLength + CCSDS_TC_TM_PACKET_OFFSET + 3);
                             }
                         }
                     }

src/tc_acceptance.c +9 -9

             //*********************
             // ACCEPTANCE FUNCTIONS
-            int tc_parser(ccsdsTelecommandPacket_t * TCPacket, unsigned int TC_LEN_RCV, unsigned char *computed_CRC)
+            int tc_parser(ccsdsTelecommandPacket_t * TCPacket, unsigned int estimatedPacketLength, unsigned char *computed_CRC)
             {
                 /** This function parses TeleCommands.
                  *
                  * @param TC points to the TeleCommand that will be parsed.
-                 * @param TC_LEN_RCV is the received packet length.
+                 * @param estimatedPacketLength is the PACKET_LENGTH field calculated from the effective length of the received packet.
                  *
                  * @return Status code of the parsing.
                  *
                 int status_crc;
                 unsigned char pid;
                 unsigned char category;
-                unsigned int length;
+                unsigned int packetLength;
                 unsigned char packetType;
                 unsigned char packetSubtype;
                 unsigned char sid;
                 // APID check *** APID on 2 bytes
                 pid             = ((TCPacket->packetID[0] & 0x07)<<4) + ( (TCPacket->packetID[1]>>4) & 0x0f );   // PID = 11 *** 7 bits xxxxx210 7654xxxx
                 category        = (TCPacket->packetID[1] & 0x0f);         // PACKET_CATEGORY = 12 *** 4 bits xxxxxxxx xxxx3210
-                length = (TCPacket->packetLength[0] * 256) + TCPacket->packetLength[1];
+                packetLength    = (TCPacket->packetLength[0] * 256) + TCPacket->packetLength[1];
                 packetType      = TCPacket->serviceType;
                 packetSubtype   = TCPacket->serviceSubType;
                 sid             = TCPacket->sourceID;
                         status = ILLEGAL_APID;
                     }
                 }
-                if (status == CCSDS_TM_VALID)   // CHECK THE PACKET LENGTH FIELD AND THE ACTUAL LENGTH COMPLIANCE
+                if (status == CCSDS_TM_VALID)   // CHECK THE PACKET_LENGTH FIELD AND THE ESTIMATED PACKET_LENGTH COMPLIANCE
                 {
-                    if (length != TC_LEN_RCV ) {
+                    if (packetLength != estimatedPacketLength ) {
                         status = WRONG_LEN_PKT;
                     }
                 }
                 if (status == CCSDS_TM_VALID)   // CHECK THAT THE PACKET DOES NOT EXCEED THE MAX SIZE
                 {
-                    if ( length >= CCSDS_TC_PKT_MAX_SIZE ) {
+                    if ( packetLength >= CCSDS_TC_PKT_MAX_SIZE ) {
                         status = WRONG_LEN_PKT;
                     }
                 }
                 }
                 if (status == CCSDS_TM_VALID)   // CHECK THE SUBTYPE AND LENGTH COMPLIANCE
                 {
-                    status = tc_check_length( packetSubtype, length );
+                    status = tc_check_length( packetSubtype, packetLength );
                 }
-                status_crc = tc_check_crc( TCPacket, length, computed_CRC );
+                status_crc = tc_check_crc( TCPacket, estimatedPacketLength, computed_CRC );
                 if (status == CCSDS_TM_VALID )  // CHECK CRC
                 {
                     status = status_crc;

src/tc_handler.c +21 -9

                 unsigned char requestedMode;
                 unsigned int *transitionCoarseTime_ptr;
                 unsigned int transitionCoarseTime;
+                unsigned char * bytePosPtr;
-                requestedMode = TC->dataAndCRC[1];
+                bytePosPtr = (unsigned char *) &TC->packetID;
-                transitionCoarseTime_ptr = (unsigned int *) (&TC->dataAndCRC[BYTE_POS_CP_LFR_ENTER_MODE_TIME]);
+                requestedMode = bytePosPtr[ BYTE_POS_CP_MODE_LFR_SET ];
+                transitionCoarseTime_ptr = (unsigned int *) ( &bytePosPtr[ BYTE_POS_CP_LFR_ENTER_MODE_TIME ] );
                 transitionCoarseTime = (*transitionCoarseTime_ptr) & 0x7fffffff;
                 status = check_mode_value( requestedMode );
-                if ( status != LFR_SUCCESSFUL )
+                if ( status != LFR_SUCCESSFUL )     // the mode value is inconsistent
                 {
-                    send_tm_lfr_tc_exe_inconsistent( TC, queue_id, BYTE_POS_CP_LFR_MODE, requestedMode );
+                    send_tm_lfr_tc_exe_inconsistent( TC, queue_id, BYTE_POS_CP_MODE_LFR_SET, requestedMode );
                 }
                 else                                // the mode value is consistent, check the transition
                 {
                     if (status != LFR_SUCCESSFUL)
                     {
                         PRINTF("ERR *** in action_enter_mode *** check_transition_date\n")
-                        send_tm_lfr_tc_exe_not_executable( TC, queue_id );
+                        send_tm_lfr_tc_exe_inconsistent( TC, queue_id,
+                                                         BYTE_POS_CP_LFR_ENTER_MODE_TIME,
+                                                         bytePosPtr[ BYTE_POS_CP_LFR_ENTER_MODE_TIME + 3 ] );
                     }
                 }
                 int result;
                 unsigned int status;
                 unsigned char mode;
+                unsigned char * bytePosPtr;
+                bytePosPtr = (unsigned char *) &TC->packetID;
                 // check LFR mode
-                mode = (TC->dataAndCRC[ BYTE_POS_HK_UPDATE_INFO_PAR_SET5 ] & 0x1e) >> 1;
+                mode = (bytePosPtr[ BYTE_POS_UPDATE_INFO_PARAMETERS_SET5 ] & 0x1e) >> 1;
                 status = check_update_info_hk_lfr_mode( mode );
                 if (status == LFR_SUCCESSFUL)  // check TDS mode
                 {
-                    mode = (TC->dataAndCRC[ BYTE_POS_HK_UPDATE_INFO_PAR_SET6 ] & 0xf0) >> 4;
+                    mode = (bytePosPtr[ BYTE_POS_UPDATE_INFO_PARAMETERS_SET6 ] & 0xf0) >> 4;
                     status = check_update_info_hk_tds_mode( mode );
                 }
                 if (status == LFR_SUCCESSFUL)  // check THR mode
                 {
-                    mode = (TC->dataAndCRC[ BYTE_POS_HK_UPDATE_INFO_PAR_SET6 ] & 0x0f);
+                    mode = (bytePosPtr[ BYTE_POS_UPDATE_INFO_PARAMETERS_SET6 ] & 0x0f);
                     status = check_update_info_hk_thr_mode( mode );
                 }
                 if (status == LFR_SUCCESSFUL)  // if the parameter check is successful
                 {
                     localCoarseTime = time_management_regs->coarse_time & 0x7fffffff;
-                    if ( transitionCoarseTime < localCoarseTime )   // SSS-CP-EQS-322
+                    if ( transitionCoarseTime <= localCoarseTime )   // SSS-CP-EQS-322
                     {
                         status = LFR_DEFAULT;
                         PRINTF2("ERR *** in check_transition_date *** transition = %x, local = %x\n", transitionCoarseTime, localCoarseTime)
                         updateLFRCurrentMode();
                     }
                 }
+                else
+                {
+                    send_tm_lfr_tc_exe_error( TC, queue_id );
+                }
             }
             //***************************

src/tc_load_dump_parameters.c +2 -2

                 result = LFR_DEFAULT;
                 lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4;
-                if ( (lfrMode == LFR_MODE_SBM1) || (lfrMode == LFR_MODE_SBM2) ) {
+                if ( lfrMode == LFR_MODE_SBM1 ) {
                     status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
                     result = LFR_DEFAULT;
                 }
                 result = LFR_DEFAULT;
                 lfrMode = (housekeeping_packet.lfr_status_word[0] & 0xf0) >> 4;
-                if ( (lfrMode == LFR_MODE_SBM1) || (lfrMode == LFR_MODE_SBM2) ) {
+                if ( lfrMode == LFR_MODE_SBM2 ) {
                     status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
                     result = LFR_DEFAULT;
                 }

src/tm_lfr_tc_exe.c +1 -1

                 return status;
             }
-            int send_tm_lfr_tc_exe_error( ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time )
+            int send_tm_lfr_tc_exe_error( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
             {
                 /** This function sends a TM_LFR_TC_EXE_ERROR packet in the dedicated RTEMS message queue.
                  *

src/wf_handler.c +37 -42

@@ -154,33 +154,13 rtems_isr waveforms_isr( rtems_vector_nu
154	// SBM1	154	// SBM1
155	case(LFR_MODE_SBM1):	155	case(LFR_MODE_SBM1):
156	if ( (waveform_picker_regs->status & 0x02) == 0x02 ) { // [0010] check the f1 full bit	156	if ( (waveform_picker_regs->status & 0x02) == 0x02 ) { // [0010] check the f1 full bit
157	// (0) launch snapshot extraction if needed
158	if (extractSWF == true)
159	{
160	ring_node_to_send_swf_f1 = current_ring_node_f1;
161	// extract the snapshot
162	status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_SBM1 );
163	extractSWF = false;
164	swf_f1_ready = true;
165	}
166	// (1) change the receiving buffer for the waveform picker	157	// (1) change the receiving buffer for the waveform picker
167	ring_node_to_send_cwf_f1 = current_ring_node_f1;	158	ring_node_to_send_cwf_f1 = current_ring_node_f1;
168	current_ring_node_f1 = current_ring_node_f1->next;	159	current_ring_node_f1 = current_ring_node_f1->next;
169	waveform_picker_regs->addr_data_f1 = current_ring_node_f1->buffer_address;	160	waveform_picker_regs->addr_data_f1 = current_ring_node_f1->buffer_address;
170	// (2) send an event for the the CWF1 task for transmission	161	// (2) send an event for the the CWF1 task for transmission (and snapshot extraction if needed)
171	status = rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_SBM1 );	162	status = rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_SBM1 );
172	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffddd; // [1111 1101 1101 1101] f1 bits = 0	163	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffddd; // [1111 1101 1101 1101] f1 bits = 0
173	if (swf_f0_ready == true)
174	{
175	extractSWF = true;
176	swf_f0_ready = false;
177	}
178	if ((swf_f1_ready == true) && (swf_f2_ready == true))
179	{
180	status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM1 );
181	swf_f1_ready = false;
182	swf_f2_ready = false;
183	}
184	}	164	}
185	if ( (waveform_picker_regs->status & 0x01) == 0x01 ) { // [0001] check the f0 full bit	165	if ( (waveform_picker_regs->status & 0x01) == 0x01 ) { // [0001] check the f0 full bit
186	swf_f0_ready = true;	166	swf_f0_ready = true;
@@ -196,16 +176,6 rtems_isr waveforms_isr( rtems_vector_nu
196	// SBM2	176	// SBM2
197	case(LFR_MODE_SBM2):	177	case(LFR_MODE_SBM2):
198	if ( (waveform_picker_regs->status & 0x04) == 0x04 ){ // [0100] check the f2 full bit	178	if ( (waveform_picker_regs->status & 0x04) == 0x04 ){ // [0100] check the f2 full bit
199	// (0) launch snapshot extraction if needed
200	if (extractSWF == true)
201	{
202	ring_node_to_send_swf_f2 = current_ring_node_f2;
203	// extract the snapshot
204	status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_SBM2 );
205	// send the snapshot when build, SWBD priority < WFRM priority
206	status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 );
207	extractSWF = false;
208	}
209	// (1) change the receiving buffer for the waveform picker	179	// (1) change the receiving buffer for the waveform picker
210	ring_node_to_send_cwf_f2 = current_ring_node_f2;	180	ring_node_to_send_cwf_f2 = current_ring_node_f2;
211	current_ring_node_f2 = current_ring_node_f2->next;	181	current_ring_node_f2 = current_ring_node_f2->next;
@@ -213,13 +183,6 rtems_isr waveforms_isr( rtems_vector_nu
213	// (2) send an event for the waveforms transmission	183	// (2) send an event for the waveforms transmission
214	status = rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_SBM2 );	184	status = rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_SBM2 );
215	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffbbb; // [1111 1011 1011 1011] f2 bit = 0	185	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffbbb; // [1111 1011 1011 1011] f2 bit = 0
216	// (3) check whether swf_fo and swf_f& are ready or not
217	if (swf_f0_ready && swf_f1_ready)
218	{
219	extractSWF = true;
220	swf_f0_ready = false;
221	swf_f1_ready = false;
222	}
223	}	186	}
224	if ( (waveform_picker_regs->status & 0x01) == 0x01 ) { // [0001] check the f0 full bit	187	if ( (waveform_picker_regs->status & 0x01) == 0x01 ) { // [0001] check the f0 full bit
225	swf_f0_ready = true;	188	swf_f0_ready = true;
@@ -402,6 +365,22 rtems_task cwf2_task(rtems_task_argument
402	if (event_out == RTEMS_EVENT_MODE_SBM2)	365	if (event_out == RTEMS_EVENT_MODE_SBM2)
403	{	366	{
404	send_waveform_CWF( (volatile int *) ring_node_to_send_cwf_f2->buffer_address, SID_SBM2_CWF_F2, headerCWF_F2_SBM2, queue_id );	367	send_waveform_CWF( (volatile int *) ring_node_to_send_cwf_f2->buffer_address, SID_SBM2_CWF_F2, headerCWF_F2_SBM2, queue_id );
		368	// launch snapshot extraction if needed
		369	if (extractSWF == true)
		370	{
		371	ring_node_to_send_swf_f2 = ring_node_to_send_cwf_f2;
		372	// extract the snapshot
		373	build_snapshot_from_ring( ring_node_to_send_swf_f2, 2 );
		374	// send the snapshot when built
		375	status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 );
		376	extractSWF = false;
		377	}
		378	if (swf_f0_ready && swf_f1_ready)
		379	{
		380	extractSWF = true;
		381	swf_f0_ready = false;
		382	swf_f1_ready = false;
		383	}
405	}	384	}
406	}	385	}
407	}	386	}
@@ -436,6 +415,25 rtems_task cwf1_task(rtems_task_argument
436	rtems_event_receive( RTEMS_EVENT_MODE_SBM1,	415	rtems_event_receive( RTEMS_EVENT_MODE_SBM1,
437	RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);	416	RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
438	send_waveform_CWF( (volatile int*) ring_node_to_send_cwf_f1->buffer_address, SID_SBM1_CWF_F1, headerCWF_F1, queue_id );	417	send_waveform_CWF( (volatile int*) ring_node_to_send_cwf_f1->buffer_address, SID_SBM1_CWF_F1, headerCWF_F1, queue_id );
		418	// launch snapshot extraction if needed
		419	if (extractSWF == true)
		420	{
		421	ring_node_to_send_swf_f1 = ring_node_to_send_cwf_f1;
		422	// launch the snapshot extraction
		423	status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_SBM1 );
		424	extractSWF = false;
		425	}
		426	if (swf_f0_ready == true)
		427	{
		428	extractSWF = true;
		429	swf_f0_ready = false; // this step shall be executed only one time
		430	}
		431	if ((swf_f1_ready == true) && (swf_f2_ready == true)) // swf_f1 is ready after the extraction
		432	{
		433	status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM1 );
		434	swf_f1_ready = false;
		435	swf_f2_ready = false;
		436	}
439	}	437	}
440	}	438	}
441		439
@@ -458,10 +456,7 rtems_task swbd_task(rtems_task_argument
458	if (event_out == RTEMS_EVENT_MODE_SBM1)	456	if (event_out == RTEMS_EVENT_MODE_SBM1)
459	{	457	{
460	build_snapshot_from_ring( ring_node_to_send_swf_f1, 1 );	458	build_snapshot_from_ring( ring_node_to_send_swf_f1, 1 );
461	}	459	swf_f1_ready = true; // the snapshot has been extracted and is ready to be sent
462	else if (event_out == RTEMS_EVENT_MODE_SBM2)
463	{
464	build_snapshot_from_ring( ring_node_to_send_swf_f2, 2 );
465	}	460	}
466	else	461	else
467	{	462	{

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages