TABLE OF CONTENTS

/Messagequeue [ Modules ]

[ Top ] [ Modules ]

DESCRIPTION

A Messagequeue is an object dedicated to Task communication. It holds a defined maximum count of messages with a defined maximum size. A Task can send a message below or equal the max size into the queue, the receiver gets the messages in a LIFO style.

SEE ALSO

    /Mutex, /Pipe, /Semaphore, /Signal, /Syncpipe

Messagequeue/Os_queue_header [ Object Headers ]

[ Top ] [ Messagequeue ] [ Object Headers ]

DESCRIPTION

Header structure of the message queue object

DECLARATION

Const Os_message_hdr_messagesize_ptr = 0                    ' max message size   '
Const Os_message_hdr_maxcount_ptr = 1                       ' max message count   '
Const Os_message_hdr_count_ptr = 2                          ' message count   '
Const Os_message_hdr_writeindex_ptr = 3                     ' FIFO write index   '
Const Os_message_hdr_readindex_ptr = 4                      ' FIFO read index   '
Const Os_message_hdr_senderqueue_ptr = 5                    ' tasks waiting to send   '
Const Os_message_hdr_receiverqueue_ptr = Os_message_hdr_senderqueue_ptr + Os_taskqueue_hdr_size       ' tasks waiting to receive   '
Const Os_message_hdr_size = Os_message_hdr_receiverqueue_ptr + Os_taskqueue_hdr_size

Messagequeue/Os_message_create [ Functions ]

[ Top ] [ Messagequeue ] [ Functions ]

DESCRIPTION

Creates a new message queue.

DECLARATION

Function Os_message_create(byval Messagesize As Byte , Byval Messagecount As Byte) As Word

SOURCE

   Local Messagequeue As Word
   Local Size As Word

   Size = Messagesize + 1                                   ' first byte contains message size   '
   Size = Size * Messagecount
   Size = Size + Os_message_hdr_size                        ' object size   '
   Messagequeue = Malloc(size)
   If Messagequeue = 0 Then
      Os_message_create = 0
      Exit Function
   End If
   Os_mem_clear Messagequeue , Size

   Setbyte Messagequeue , Os_message_hdr_messagesize_ptr , Messagesize
   Setbyte Messagequeue , Os_message_hdr_maxcount_ptr , Messagecount

   Os_message_create = Messagequeue
End Function

Messagequeue/Os_message_kill [ Functions ]

[ Top ] [ Messagequeue ] [ Functions ]

DESCRIPTION

Kills a message queue.

DECLARATION

Sub Os_message_kill(byref Messagequeue As Word)

SOURCE

   Free Messagequeue
End Sub

Messagequeue/Os_message_receive [ Functions ]

[ Top ] [ Messagequeue ] [ Functions ]

DESCRIPTION

Gets a message from the queue. If the queue is empty, the Task can be notified by an error, blocked infinite or blocked with timeout, until a message has been sent into the queue.

DECLARATION

Function Os_message_receive(byref Messagequeue As Word , Byref Pointer As Word , Byref Length As Byte , Byval Queuemode As Word) As Byte

INPUTS

    Messagequeue: message queue object
    Pointer: address of the data to receive
    Length: returns the received data size
    Queue mode: blocking behaviour

SOURCE

   Local Count As Byte
   Local Index As Byte
   Local Maxindex As Byte
   Local Readpointer As Word
   Local Temp As Word

   Os_enter_critical
   Count = Getbyte(Messagequeue , Os_message_hdr_count_ptr)
   If Count = 0 Then
      ' queue is empty   '
      Select Case Queuemode
      Case Os_queuemode_noblock:
         ' return error   '
         Os_exit_critical
         Os_message_receive = False
         Exit Function
      Case Os_queuemode_block:
         ' suspend and wait for a message   '
         Os_task_suspendmode Os_task_active , Os_task_suspend_nowakeup , 0
      Case Else
         ' suspend and wait for a message or timeout   '
         Os_task_suspendmode Os_task_active , Os_task_suspend_timersingleshot , Queuemode
      End Select

      Messagequeue = Messagequeue + Os_message_hdr_receiverqueue_ptr
      Os_sched_taskqueue_insert Messagequeue , Os_task_active
      Messagequeue = Messagequeue - Os_message_hdr_receiverqueue_ptr
      Os_exit_critical
      Os_task_suspend Os_task_active
      Os_enter_critical

      ' Task resumes here when a message is available or timeout has been reached   '
      Count = Getbyte(Messagequeue , Os_message_hdr_count_ptr)
      If Count = 0 Then
         ' no messages available (timeout)   '
         Os_exit_critical
         Os_message_receive = False
         Exit Function
      End If
   End If

   Maxindex = Getbyte(Messagequeue , Os_message_hdr_maxcount_ptr)
   Index = Getbyte(Messagequeue , Os_message_hdr_readindex_ptr)

   ' new index   '
   Decr Count
   Incr Index
   If Index = Maxindex Then Index = 0
   Setbyte Messagequeue , Os_message_hdr_count_ptr , Count
   Setbyte Messagequeue , Os_message_hdr_readindex_ptr , Index
   Os_exit_critical

   ' calc read pointer   '
   If Index = 0 Then Index = Maxindex
   Decr Index
   Temp = Index
   Maxindex = Getbyte(Messagequeue , Os_message_hdr_messagesize_ptr)
   Readpointer = Maxindex
   Incr Readpointer
   Readpointer = Readpointer * Temp
   Readpointer = Readpointer + Messagequeue
   Readpointer = Readpointer + Os_message_hdr_size

   ' copy data to Task   '
   Index = Getbyte(readpointer , 0)
   Temp = Index
   Incr Readpointer
   Os_mem_copy Readpointer , Pointer , Temp

   ' Task waiting to send?   '
   Readpointer = Messagequeue + Os_message_hdr_senderqueue_ptr
   Temp = Os_sched_taskqueue_remove(readpointer)
   If Temp <> 0 Then
      Os_event_task = Temp
      Os_task_event
   End If

   Os_messagequeue_receive = True
End Function

Messagequeue/Os_message_send [ Functions ]

[ Top ] [ Messagequeue ] [ Functions ]

DESCRIPTION

Sends a message to the queue. The message size should not exceed the max. message size of the queue object. If the queue is full, the Task can be notified by an error, blocked infinite or blocked with timeout, until a Task receives (clears) a message.

DECLARATION

Function Os_message_send(byref Messagequeue As Word , Byref Pointer As Word , Byval Length As Byte , Byval Queuemode As Word) As Byte

INPUTS

    Messagequeue: message queue object
    Pointer: address of the data to send
    Length: data length in bytes
    Queuemode: blocking behaviour

SOURCE

   Local Count As Byte
   Local Index As Byte
   Local Maxindex As Byte
   Local Writepointer As Word
   Local Temp As Word

   Os_enter_critical
   Count = Getbyte(Messagequeue , Os_message_hdr_count_ptr)
   Maxindex = Getbyte(Messagequeue , Os_message_hdr_maxcount_ptr)
   If Count = Maxindex Then
      ' queue is full   '
      Select Case Queuemode
      Case Os_queuemode_noblock:
         ' return error   '
         Os_exit_critical
         Os_message_send = False
         Exit Function
      Case Os_queuemode_block:
         ' suspend and wait to send a message   '
         Os_task_suspendmode Os_task_active , Os_task_suspend_nowakeup , 0
      Case Else
         ' suspend and wait to send a message or timeout   '
         Os_task_suspendmode Os_task_active , Os_task_suspend_timersingleshot , Queuemode
      End Select

      ' insert into taskqueue and suspend   '
      Messagequeue = Messagequeue + Os_message_hdr_senderqueue_ptr
      Os_sched_taskqueue_insert Messagequeue , Os_task_active
      Messagequeue = Messagequeue - Os_message_hdr_senderqueue_ptr
      Os_exit_critical
      Os_task_suspend Os_task_active
      Os_enter_critical

      Count = Getbyte(Messagequeue , Os_message_hdr_count_ptr)
      If Count = Maxindex Then
         ' Messagequeue still full (timeout)   '
         Os_exit_critical
         Os_message_send = False
         Exit Function
      End If
   End If

   ' new index   '
   Index = Getbyte(Messagequeue , Os_message_hdr_writeindex_ptr)
   Incr Count
   Incr Index
   If Index = Maxindex Then Index = 0
   Setbyte Messagequeue , Os_message_hdr_count_ptr , Count
   Setbyte Messagequeue , Os_message_hdr_writeindex_ptr , Index
   Os_exit_critical

   ' calc write pointer   '
   If Index = 0 Then Index = Maxindex
   Decr Index
   Temp = Index
   Maxindex = Getbyte(Messagequeue , Os_message_hdr_messagesize_ptr)
   Writepointer = Maxindex
   Incr Writepointer
   Writepointer = Writepointer * Temp
   Writepointer = Writepointer + Messagequeue
   Writepointer = Writepointer + Os_message_hdr_size

   ' store message size   '
   Setbyte Writepointer , 0 , Length
   Incr Writepointer

   ' copy data to queue   '
   Temp = Length
   Os_mem_copy Pointer , Writepointer , Temp

   ' Task waiting for a message?   '
   Writepointer = Messagequeue + Os_message_hdr_receiverqueue_ptr
   Temp = Os_sched_taskqueue_remove(writepointer)
   If Temp <> 0 Then
      Os_event_task = Temp
      Os_task_event
   End If

   Os_message_send = True
End Function