aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Technician/TechItems/ThreadMotionItem.cs
blob: a5789377f66bb3350c7302cf28d1a81f94377bfa (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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;
using System.Xml.Serialization;
using Tango.SharedUI.Helpers;

namespace Tango.MachineStudio.Technician.TechItems
{
    /// <summary>
    /// Represents a thread motion controller item.
    /// </summary>
    /// <seealso cref="Tango.MachineStudio.Technician.TechItems.TechItem" />
    [TechItem(9)]
    public class ThreadMotionItem : TechItem
    {
        /// <summary>
        /// Occurs when the user has pressed/released on of the item actions.
        /// </summary>
        public event EventHandler<MotorActionType> ActionExecuted;

        private double _speed;
        /// <summary>
        /// Gets or sets the motor speed.
        /// </summary>
        public double Speed
        {
            get { return _speed; }
            set { _speed = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ThreadMotionItem"/> class.
        /// </summary>
        public ThreadMotionItem() : base()
        {
            Name = "Thread Motion";
            Description = "Thread Motion Controller";
            Image = ResourceHelper.GetImageFromResources("Images/thread.png");
            TechName = Name;
            Color = Colors.White;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ThreadMotionItem"/> class.
        /// </summary>
        /// <param name="dummyConstructor">Does not matter.</param>
        public ThreadMotionItem(object dummyConstructor) : this()
        {

        }

        /// <summary>
        /// Clones this instance.
        /// </summary>
        /// <returns></returns>
        public override TechItem Clone()
        {
            ThreadMotionItem cloned = base.Clone() as ThreadMotionItem;
            cloned.Speed = Speed;
            return cloned;
        }

        /// <summary>
        /// Raises the <see cref="ActionExecuted"/> event with the specified action.
        /// </summary>
        /// <param name="action">The action.</param>
        public void RaiseAction(MotorActionType action)
        {
            ActionExecuted?.Invoke(this, action);
        }
    }
}
">10][SHORT_BUFFER_SIZE]; char CommRxBuffer[2][COMM_MAX_BUFFER_SIZE]; SerialBuffer inBuffer[12]; bool SerialBufferUsed[12] = {false,false,false,false,false,false,false,false,false,false,false,false}; uint32_t initArray(size_t initialSize) { if (initialSize >= COMM_MAX_BUFFER_SIZE) return 0xFF; if (initialSize > SHORT_BUFFER_SIZE) { if ((SerialBufferUsed[10] == true)&&(SerialBufferUsed[11] == true)) { return 0xFF; } else { if (SerialBufferUsed[10] == false) { SerialBufferUsed[10] = true; inBuffer[10].buffer = CommRxBuffer; inBuffer[10].used = 0; inBuffer[10].size = initialSize; //Report("initArray", __FILE__, 10, inBuffer[10].size, RpWarning, (int)0, 0); return 10; } else if (SerialBufferUsed[11] == false) { SerialBufferUsed[11] = true; inBuffer[11].buffer = CommRxBuffer; inBuffer[11].used = 0; inBuffer[11].size = initialSize; //Report("initArray", __FILE__, 10, inBuffer[10].size, RpWarning, (int)0, 0); return 11; } else return 0xFF; } } else { int i,j; for (i = 0; i < 10; i++) { if (SerialBufferUsed[i] == false) break; } if (i == 10) { for (j = 0; j < 10; j++) Report("initArray all buffers busy", __FILE__, j, inBuffer[j].size, RpWarning, (int)SerialBufferUsed[j], 0); return 0xFF; } else { SerialBufferUsed[i] = true; inBuffer[i].buffer = (char *)&CommShortRxBuffer[i]; inBuffer[i].used = 0; inBuffer[i].size = initialSize; //Report("initArray", __FILE__, i, inBuffer[i].size, RpWarning, (int)0, 0); return i; } } /*SerialBuffer *a = &inBuffer; a->buffer = CommRxBuffer; a->used = 0; a->size = initialSize; return initialSize;*/ } bool insertArray(uint32_t buffer,char element) { /*if (buffer>=12) { LOG_ERROR(buffer,"insertArray"); return false; }*/ SerialBuffer *a = &inBuffer[buffer]; // a->used is the number of used entries, because a->array[a->used++] updates a->used only *after* the array has been accessed. // Therefore a->used can go up to a->size a->buffer[a->used++] = element; return true; } void freeArray(uint32_t buffer) { //Report("freeArray", __FILE__, buffer, inBuffer[buffer].size, RpWarning, (int)0, 0); SerialBufferUsed[buffer] = false; } uint32_t CommunicationTaskInit(void) { USBCDCD_init(); //Init_U0(); return OK; } uint32_t CommTxMsgCounter = 0; uint32_t CommRxMsgCounter = 0; uint32_t CommunicationTaskMessageReceived(uint32_t buffer,uint16_t msgSize) { CommRxMessageStruc CommRxMessage; CommRxMsgCounter++; //CommRxMessage.messageId = 1; CommRxMessage.msgSize = msgSize; CommRxMessage.BuffId = buffer; if (CommunicationRxMsgQ != NULL) /*retcode =*/ Mailbox_post(CommunicationRxMsgQ , &CommRxMessage, BIOS_NO_WAIT); return OK; } /****************************************************************************** * ======== communicationTask ======== * Task for this function is created statically. See the project's .cfg file. * this communication task is created statically in system initialization, in blocking mode * over one of the chosen ommunication methods (USB or Blutooth). ******************************************************************************/ uint32_t cLength[51] = {0}; byte cindex = 0; void communicationTask(UArg arg0, UArg arg1) { CommRxMessageStruc CommRxMessage; //ui32RxCount = 0; CommunicationRxMsgQ = Mailbox_create(sizeof(CommRxMessageStruc), 20, NULL,NULL); /* Block while the device is NOT connected to the USB */ // Semaphore_pend(initConnectionSem, BIOS_WAIT_FOREVER); while(1) { Mailbox_pend(CommunicationRxMsgQ , &CommRxMessage, BIOS_WAIT_FOREVER); /*switch (CommRxMessage.messageId) { case 1:*/ cLength[cindex] = CommRxMessage.msgSize; if (cindex++>=50) cindex = 0; receive_callback(inBuffer[CommRxMessage.BuffId].buffer,inBuffer[CommRxMessage.BuffId].used); freeArray(CommRxMessage.BuffId); /* break; default: break; }*/ } } int UnSentMessages=0, deliveryfailure = 0; bool CommunicationTaskSendMessage(char* buffer,size_t length) { CommTxMessageStruc CommTxMessage; CommTxMsgCounter++; bool retcode = true; //CommTxMessage.messageId = 1; CommTxMessage.msgSize = length; CommTxMessage.Buff = buffer; UnSentMessages++; if (CommunicationTxMsgQ != NULL) retcode = Mailbox_post(CommunicationTxMsgQ , &CommTxMessage, BIOS_NO_WAIT); if (retcode == false) { my_free(buffer); deliveryfailure++; // CommunicationMailboxFlush(); } return retcode; } int memoryrelease = 0; void CommunicationMailboxFlush(void) { int i; CommTxMessageStruc CommTxMessage; for (i=0;i<COMMUNICATION_NUM_MSGS;i++) { if (Mailbox_pend(CommunicationTxMsgQ , &CommTxMessage, BIOS_NO_WAIT)) { UnSentMessages--; LOG_ERROR(CommTxMessage.msgSize,"Flushing CommTxMessage"); my_free(CommTxMessage.Buff); memoryrelease+=CommTxMessage.msgSize; } } } int32_t SetCommunicationPath(bool UARTorUSB) { CommType = UARTorUSB; return OK; } /*#define MAX_CONT_LOG 199 uint16_t cSendSize[MAX_CONT_LOG+1] = {0}; uint32_t cSendTime[MAX_CONT_LOG+1] = {0}; uint16_t cSendindex = 0; */ /****************************************************************************** * ======== communicationTask ======== * Task for this function is created statically. See the project's .cfg file. * this communication task is created statically in system initialization, in blocking mode * over one of the chosen Communication methods (USB or Bluetooth). ******************************************************************************/ void communicationTxTask(UArg arg0, UArg arg1) { CommTxMessageStruc CommTxMessage; //initArray(1); CommunicationTxMsgQ = Mailbox_create(sizeof(CommTxMessageStruc), COMMUNICATION_NUM_MSGS, NULL,NULL); while(1) { Mailbox_pend(CommunicationTxMsgQ , &CommTxMessage, BIOS_WAIT_FOREVER); UnSentMessages--; if ( CommTxMessage.msgSize > COMM_MAX_BUFFER_SIZE) { LOG_ERROR(CommTxMessage.msgSize , "message too long"); } else { if (CommType == isUSB) USBCDCD_sendData(CommTxMessage.Buff, CommTxMessage.msgSize,10); else if (CommType == isUART) Uart_Tx(CommTxMessage.Buff, CommTxMessage.msgSize); } /* cSendSize[cSendindex] = CommTxMessage.msgSize; cSendTime[cSendindex] = msec_millisecondCounter; if (cSendindex++>=MAX_CONT_LOG) cSendindex = 0; */ if (diagnosticscontainer_buffer == CommTxMessage.Buff) diagnosticscontainer_buffer = 0; my_free(CommTxMessage.Buff); //delayms(1); //wait 5 milliseconds between messages } }