Produto SanHok

Transportador de classificação

This Sorting Conveyor is an automated equipment that uses mechanical, electronic, and computer technology to automatically sort and classify logistics goods such as express delivery and packages.

Contate-nos para um preço

Fale com um especialista em transportadores

Especificações

SanHok Sorting Conveyor

Automatic Classification
Based on the barcode or QR code information read by the scanner, the computer system automatically classifies and sorts the goods. The system’s built-in rules categorize the goods into different destinations according to the specific barcode or QR code information.

Sorting Execution
The logistics sorting line delivers the sorted goods to the corresponding sorting ports. These ports are equipped with mechanical arms, conveyor belts, and other devices to direct the goods to their respective destinations, such as express cabinets, vehicles, or warehouses.

Packaging and Dispatch
Finally, the logistics sorting line packages the sorted goods and dispatches them to their destinations. The entire sorting process is fully automated, requiring no manual intervention, which significantly enhances sorting efficiency and accuracy.

Application Scenarios and Advantages
Logistics sorting lines are widely used in airports, cigarette factories, tobacco warehousing logistics, and postal sorting systems. Their advantages include:

Efficient Processing Capability
The automated sorting equipment boasts strong processing capabilities, capable of sorting 6,000 to 12,000 boxes of goods per hour.

High Precision and Safety
Using automated equipment for sorting ensures the safety and accuracy of the sorting process.

Flexibility
The modular design of the sorting line allows it to adapt flexibly to the sorting needs of different scales of express delivery.

Características

Goods Identification

The logistics sorting line transports goods from the starting point to the destination via a conveyor belt. As the goods move along the conveyor belt, they pass through a scanner that reads the barcode or QR code information on the goods. This information is then transmitted to the computer system.

Successful Cases

SanHok Sorting Conveyor Successful Cases

DWS System

Six sided code reading, volume measurement, and weighing. Integrated design with anti light fabric to avoid visual cameras interfere with the line of sight of surrounding workers

RFID Channel

This channel machine includes: pre reading code (tentative), weighing, and RFID electronic tag recognition. Among them, code reading and weighing. Redesigned at the front end of the channel door, the box is read and weighed before entering the channel door, and rolled back and forth after entering the channel door. The curtain door is closed and electronic tag information is being collected and read.

Fast Scanning

Read code top scan+weigh+measure volume. If the position is placed at the input port position. The weighing machine is equipped with a belt weighing machine with a motor. If it belongs to an independent operating position, a static weighing machine is used. The DWS method is currently evaluated based on independent assignments

Correction and removal of double

The visual system will synchronously output the location coordinates of the package while recognizing it. The customer's PLC (Programmable Logic Controller) can be customized according to preset configurations. The system calculates the offset of the package relative to the central coordinate position and performs correction operations or incorporates the offset during the bagging process to avoid bagging failures. Correcting the package's position reduces the risk of it falling off during high-speed movement and improves overall picking efficiency.

Serviços

Etapas de personalização

O rolo transportador é um produto personalizado não padronizado. As etapas de personalização são as seguintes:

Contate-nos para um preço

Fale com um especialista em transportadores

Acessórios 样式1

Enhance Your Assembly Line With Our Premium Accessories

<script>
document.addEventListener('DOMContentLoaded', () => {

    const FBautoplayTime = 5; // Set autoplay time in secounds

    // Seleccionar todos los conjuntos de tabs
    const tabsSets = document.querySelectorAll('[fb-tabs]');
  


    tabsSets.forEach(tabsSet => {
        const tabs = tabsSet.querySelectorAll('[fb-tabs-btn]');
        const panels = tabsSet.querySelectorAll('[fb-tabs-panel]');
        const tabsMenu = tabsSet.querySelector('[fb-tabs-menu]');
        const tabsTitle = tabsSet.querySelector('[fb-tabs-title]');
        const isVertical = tabsSet.hasAttribute('fb-vertical');
            
      // Añadir la variable CSS --fb-progress-time al estilo de [fb-tabs]
        tabsSet.style.setProperty('--fb-progress-time', `${FBautoplayTime}s`);

        // Asignar aria-label del menú de tabs con el texto del título
        if (tabsMenu && tabsTitle) {
            tabsMenu.setAttribute('aria-label', tabsTitle.textContent.trim());
        }

        // Asignar aria-controls a los tabs y aria-label a los paneles
        if (tabs.length === panels.length) {
            tabs.forEach((tab, index) => {
                const panelId = panels[index].id;
                const tabText = tab.textContent.trim();
                if (panelId && tabText) {
                    tab.setAttribute('aria-controls', panelId);
                    panels[index].setAttribute('aria-label', tabText);
                }
                tab.setAttribute('aria-selected', tab.classList.contains('brx-open'));
                tab.setAttribute('tabindex', tab.classList.contains('brx-open') ? '0' : '-1');
            });
        }

        // Configurar el MutationObserver
        const observer = new MutationObserver((mutations) => {
            mutations.forEach((mutation) => {
                if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
                    const targetTab = mutation.target;
                    targetTab.setAttribute('aria-selected', targetTab.classList.contains('brx-open'));
                    targetTab.setAttribute('tabindex', targetTab.classList.contains('brx-open') ? '0' : '-1');
                }
            });
        });

        // Observar cada tab para cambios en la clase
        tabs.forEach((tab) => {
            observer.observe(tab, { attributes: true });
        });

        let currentTabIndex = 0;
        let autoplayInterval = null;
        let hoverTimeout = null;
        let isHovered = false;
        let manualSelection = false;

        const startAutoplay = () => {
            autoplayInterval = setInterval(() => {
                if (!manualSelection && !isHovered) {
                    const nextIndex = (currentTabIndex + 1) % tabs.length;
                    activateTab(nextIndex);
                }
            }, FBautoplayTime*1000); // Usar la constante para el tiempo del autoplay
        };

        const resetAutoplay = (index) => {
            clearInterval(autoplayInterval);
            activateTab(index);
            manualSelection = true;

            tabs.forEach((tab, idx) => {
                tab.setAttribute('aria-selected', idx === currentTabIndex);
                tab.setAttribute('tabindex', idx === currentTabIndex ? '0' : '-1');
                panels[idx].classList.toggle('brx-open', idx === currentTabIndex);
            });

            setTimeout(() => {
                manualSelection = false;
            }, 100);
        };

        const activateTab = (index) => {
            tabs[currentTabIndex].classList.remove('brx-open');
            panels[currentTabIndex].classList.remove('brx-open');

            currentTabIndex = index;

            tabs[currentTabIndex].classList.add('brx-open');
            panels[currentTabIndex].classList.add('brx-open');

            tabs.forEach((tab, idx) => {
                tab.setAttribute('aria-selected', idx === currentTabIndex);
                tab.setAttribute('tabindex', idx === currentTabIndex ? '0' : '-1');
            });
        };

        startAutoplay();

        const handleHoverStart = () => {
            isHovered = true;
            tabsSet.classList.add('fb-tab-progress');
            clearInterval(autoplayInterval);
        };

        const handleHoverEnd = () => {
            isHovered = false;
            tabsSet.classList.remove('fb-tab-progress');
            if (!manualSelection) {
                startAutoplay();
            }
        };

        // Añadir manejadores de clic y hover para tabs
        tabs.forEach((tab, index) => {
            tab.addEventListener('click', () => {
                resetAutoplay(index);
            });

            tab.addEventListener('focus', () => {
                handleHoverStart();
            });

            tab.addEventListener('mouseenter', () => {
                handleHoverStart();
            });

            tab.addEventListener('mouseleave', () => {
                handleHoverEnd();
            });

            tab.addEventListener('keydown', (event) => {
                if (event.key === 'Enter' || event.key === ' ') {
                    event.preventDefault();
                    resetAutoplay(index);
                }
            });
        });

        // Añadir manejadores de hover para paneles
        panels.forEach((panel) => {
            panel.addEventListener('mouseenter', () => {
                handleHoverStart();
            });

            panel.addEventListener('mouseleave', () => {
                handleHoverEnd();
            });
        });

        // Manejo de eventos de teclado para navegación entre tabs
        tabsSet.addEventListener('keydown', (event) => {
            const currentTab = tabs[currentTabIndex];

            if (event.key === 'ArrowRight' || (isVertical && event.key === 'ArrowDown')) {
                event.preventDefault();
                const nextIndex = (currentTabIndex + 1) % tabs.length;
                resetAutoplay(nextIndex);
                tabs[nextIndex].focus();
            } else if (event.key === 'ArrowLeft' || (isVertical && event.key === 'ArrowUp')) {
                event.preventDefault();
                const nextIndex = currentTabIndex === 0 ? tabs.length - 1 : currentTabIndex - 1;
                resetAutoplay(nextIndex);
                tabs[nextIndex].focus();
            } else if (event.key === 'Home') {
                event.preventDefault();
                resetAutoplay(0);
                tabs[0].focus();
            } else if (event.key === 'End') {
                event.preventDefault();
                resetAutoplay(tabs.length - 1);
                tabs[tabs.length - 1].focus();
            }
        });
    });
  

});
</script>