aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/StructCompletionItemPopup.cs
blob: 09512f405adf7dc051ae8aea0d1d52682e7571eb (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace Tango.Scripting.Editors.Intellisense
{
    public class StructCompletionItemPopup : CompletionItemPopupControl
    {
        static StructCompletionItemPopup()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(StructCompletionItemPopup), new FrameworkPropertyMetadata(typeof(StructCompletionItemPopup)));
        }
    }
}
ckground-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
/************************************************************
 * Utils.h
 * general module of system utility functions
 **************************************************************/

#include "include.h"
#include <inc/hw_ints.h>
#include <inc/hw_memmap.h>
#include <driverlib/rom.h>
#include <time.h>
#include "Common/Utilities/Utils.h"
//#include <driverlib/systick.h>
#include "driverlib/hibernate.h"

static const float speedCoef = 5.3051647697298445256294587790838f;//(200 micro steping)/2*Pi*Radius - 200 micro steping

//*****************************************************************************

#define MAX_MEM_LOG 300
int freeIndex=0,malloc_index=0;
uint32_t malloc_size[MAX_MEM_LOG+1];
uint32_t malloc_time[MAX_MEM_LOG+1];
void * malloc_addr[MAX_MEM_LOG+1];
void * free_addr[MAX_MEM_LOG+1];
//uint32_t total_allocated = 0;
void  *my_malloc(size_t _size)
{
    void * addr =  malloc (_size);
    if (_size == 0) return addr;
/*    int i;
    for (i=0; i< MAX_MEM_LOG;i++)
    {
        if (malloc_time[i] == 0)
        {
            malloc_index = i;
            break;
        }
    }
    assert (malloc_index<MAX_MEM_LOG);
    if (malloc_index<MAX_MEM_LOG)
    {
        malloc_addr[malloc_index] = addr;
        malloc_size[malloc_index] = _size;
        malloc_time[malloc_index] = msec_millisecondCounter;
    }
    */
    malloc_addr[malloc_index] = addr;
    malloc_size[malloc_index] = _size;
    malloc_time[malloc_index] = msec_millisecondCounter;
    if (malloc_index++>=MAX_MEM_LOG)
        malloc_index = 0;
    return addr;
}
int allocated_size = 0;
void   my_free(void *_ptr)
{
    int i;
    free(_ptr);
    if (_ptr)
    {
/*        for (i=0; i< MAX_MEM_LOG;i++)
        {
            if ( malloc_addr[i] == _ptr)
            {
                malloc_addr[i] = 0;
                malloc_time[i] = 0;
                malloc_size[i] = 0;
                break;
            }
        }
        if (i==MAX_MEM_LOG)
        {
          //  LOG_ERROR(i,"free error");
                    return;
        }
        allocated_size = 0;
//        for (i=0; i< MAX_MEM_LOG;i++)
//            allocated_size+=malloc_size[i];
 *
 */
        free_addr[freeIndex] = _ptr;
        if (freeIndex++>=MAX_MEM_LOG)
            freeIndex = 0;

    }
}

//*****************************************************************************
//
// Init WD timer
//
//*****************************************************************************
void InitWatchdog(uint32_t clock)
{
	//
	// Enable the watchdog interrupt.
	//
	ROM_IntEnable(INT_WATCHDOG);

	//
	// Set the period of the watchdog timer.
	//
	ROM_WatchdogReloadSet(WATCHDOG0_BASE, clock);

	//
	// Enable reset generation from the watchdog timer.
	//
	ROM_WatchdogResetEnable(WATCHDOG0_BASE);

	//
	// Enable the watchdog timer.
	//
	ROM_WatchdogEnable(WATCHDOG0_BASE);
}
void utilsInit(uint32_t ui32SysClock)
{

    // Configure Hibernate module clock.
    //
    HibernateEnableExpClk(ui32SysClock);


    // Enable RTC mode.
    //
    HibernateRTCEnable();

    //
    // Configure the hibernate module counter to 24-hour calendar mode.
    //
    // HibernateCounterMode(HIBERNATE_COUNTER_24HR);
    // Configure the hibernate module counter to RTC counter mode.
    HibernateCounterMode(HIBERNATE_COUNTER_RTC);


}


uint32_t UsersysTickGet (void) {
    uint32_t tick = 0;
//    tick =  SysTickValueGet();
    tick = HibernateRTCSSGet()*10000/0x8000;
    return tick;
}

//*****************************************************************************
//
// The interrupt handler for the watchdog.  This feeds the dog (so that the
// processor does not get reset) and winks the LED connected to GPIO B3.
//
//*****************************************************************************
void WatchdogIntHandler(void)
{
     //
     // Clear the watchdog interrupt.
     //
     ROM_WatchdogIntClear(WATCHDOG0_BASE);
}

bool sendDataToHost = false;
void UtilsSetCommunicationOk(void)
{
    sendDataToHost = true;
}